fog-akamai 0.1.1 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f8e1c183618f068be64f0d0959e390b23b19b46f
-  data.tar.gz: cdb9cd220be1caff79b65c156aa6754fb75b7fde
+  metadata.gz: f6c27c6eba6ca0f38e804c4eb82ebb102367e1eb
+  data.tar.gz: b2f945bf7fdb1be2e4bb987c31fc1af89be4ef8d
 SHA512:
-  metadata.gz: 5197933b51c297b44232851ce28e99ba5911019ed43db5f4de44b7907c327f1fe4a70a85ba1b59bdd510e2239bbb830b666aaf8be235216fb85eaf8c454e66f9
-  data.tar.gz: fc093806a9fd762caddce13ad6f6796f5a05dbd857097d0f77fb8744a99cd04cd2d1d565d5ae8477db05d140f303eda50d37c2e996647f1c23456fbf2a1d1e07
+  metadata.gz: b4f0605c05d091ce683511b8363ed4d07c9a737df8950373b91f8a38ebca998c9b7b741010a2e327579428ce6d44bcaaccb24887381960824380f5b20d77408c
+  data.tar.gz: 163d6e859734fb81e94c6f9897adc7a125c436f1339b38a4b0edc18119adac2ed84cb3e22cc879ef8e8ed78738e29b6104ae990fc66ce396f1fd49a0f2444e97

data/.rubocop.yml

@@ -0,0 +1,5 @@
+Metrics/LineLength:
+  Max: 160
+
+Style/Documentation:
+  Enabled: false

data/Gemfile

@@ -3,4 +3,4 @@ source 'https://rubygems.org'
 # Specify your gem's dependencies in fog-netstorage.gemspec
 gemspec
 
-gem 'codeclimate-test-reporter', group: :test, require: nil
+gem 'codeclimate-test-reporter', group: :test, require: nil

data/README.md

@@ -2,7 +2,7 @@
 
 Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/fog/storage`. To experiment with that code, run `bin/console` for an interactive prompt.
 
-This is still under development only very basic net storage functionality has been put in place.
+All the functionality of the net storage api is implemented except the really dangerous bit, quick-delete.
 
 ## Installation
 
@@ -66,8 +66,6 @@ directory.files.create(directory: directory, body: file_body, key: file_name)
 
 ## Roadmap
 
-- finish implementing the netstorage api
-- add mock support
 - implement ccu api
 
 ## Development

data/Rakefile

@@ -8,4 +8,4 @@ Rake::TestTask.new do |t|
 end
 
 desc 'Default Task'
-task :default => [ :test ]
+task default: [:test]

data/bin/console

@@ -1,7 +1,7 @@
 #!/usr/bin/env ruby
 
-require "bundler/setup"
-require "fog/akamai"
+require 'bundler/setup'
+require 'fog/akamai'
 
 # You can add fixtures and/or initialization code here to make experimenting
 # with your gem easier. You can also use a different console, if you like.
@@ -10,5 +10,5 @@ require "fog/akamai"
 # require "pry"
 # Pry.start
 
-require "irb"
+require 'irb'
 IRB.start

data/fog-akamai.gemspec

@@ -10,9 +10,9 @@ Gem::Specification.new do |spec|
   spec.email         = ['calinoiu.alexandru@agilefreaks.com']
   spec.license       = 'MIT'
 
-  spec.summary       = %q{Module for 'fog' gem to support Akamai}
-  spec.description   = %q{This library can be used as a module for `fog` or as standalone provider
-                        to use Akamai}
+  spec.summary       = "Module for 'fog' gem to support Akamai"
+  spec.description   = 'This library can be used as a module for `fog` or as standalone provider
+                        to use Akamai'
   spec.homepage      = 'https://github.com/alexandru-calinoiu/fog-akamai'
 
   spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
@@ -26,6 +26,8 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'minitest-reporters', '~> 1.1'
   spec.add_development_dependency 'test-unit', '~> 3.1'
   spec.add_development_dependency 'webmock', '~> 1.22'
+  spec.add_development_dependency 'rubocop', '~> 0.35'
+  spec.add_development_dependency 'timecop', '~> 0.8.0'
 
   spec.add_dependency 'fog-core',  '~> 1.27'
   spec.add_dependency 'fog-json',  '~> 1.0'

data/lib/fog/akamai/models/storage/directories.rb

@@ -4,15 +4,33 @@ module Fog
       class Directories < Fog::Collection
         model Fog::Storage::Akamai::Directory
 
+        attribute :parent
+
+        def all
+          requires :parent
+          parent.directories
+        end
+
         def get(key)
           data = service.dir(key).body
 
-          directory = new(:key => data[:directory].sub("/#{service.akamai_cp_code}", ''))
-          directory.files.load(data[:files].map { |file| file.merge(:directory => directory) })
+          directory = new(key: data[:directory].sub("/#{service.akamai_cp_code}", ''))
+          load_files(directory, data)
+          load_directories(directory, data)
 
           directory
         end
+
+        private
+
+        def load_files(directory, data)
+          directory.files.load(data[:files].map { |file| file.merge(directory: directory) })
+        end
+
+        def load_directories(directory, data)
+          directory.directories.load(data[:directories].map { |dir| dir.merge(parent: directory) })
+        end
       end
     end
   end
-end
+end

data/lib/fog/akamai/models/storage/directory.rb

@@ -2,16 +2,38 @@ module Fog
   module Storage
     class Akamai
       class Directory < Fog::Model
-        identity :key
+        include Fog::Akamai::Shared
+
+        identity :key, aliases: 'name'
 
         attribute :parent
+        attribute :name
+        attribute :mtime
 
         def files
           @files ||= Fog::Storage::Akamai::Files.new(
-            :directory => self,
-            :service => service
+            directory: self,
+            service: service
+          )
+        end
+
+        def directories
+          @directories ||= Fog::Storage::Akamai::Directories.new(
+            parent: self,
+            service: service
           )
         end
+
+        def save
+          requires :key
+          path = parent.nil? ? key : full_path(key, parent)
+          service.mkdir(path)
+        end
+
+        def destroy
+          requires :key
+          service.rmdir(key)
+        end
       end
     end
   end

data/lib/fog/akamai/models/storage/file.rb

@@ -1,35 +1,47 @@
 module Fog
-   module Storage
-     class Akamai
-       class File < Fog::Model
-         include Fog::Akamai::Shared
-
-         identity :key, :aliases => 'name'
-
-         attribute :directory
-         attribute :name
-         attribute :mtime
-         attribute :md5
-         attribute :size
-         attribute :body
-
-         def get(key)
-           requires :directory
-         end
-
-         def save
-           requires :body, :directory, :key
-           service.upload(full_path(key, directory), body)
-         end
-
-         def destroy
-           requires :directory, :key
-         end
-
-         def ready?
-           true
-         end
-       end
-     end
-   end
+  module Storage
+    class Akamai
+      class File < Fog::Model
+        include Fog::Akamai::Shared
+
+        identity :key, aliases: 'name'
+
+        attribute :directory
+        attribute :name
+        attribute :mtime
+        attribute :md5
+        attribute :size
+        attribute :body
+
+        def get(_key)
+          requires :directory
+        end
+
+        def save
+          requires :body, :directory, :key
+          service.upload(full_path(key, directory), body)
+        end
+
+        def destroy
+          requires :directory, :key
+        end
+
+        def ready?
+          true
+        end
+
+        def touch(mtime = DateTime.now.to_time.to_i)
+          requires :directory, :key
+          service.mtime(full_path(key, directory), mtime)
+        end
+
+        def rename(new_name)
+          requires :directory, :key
+          service.rename(full_path(key, directory), full_path(new_name, directory))
+          self.key = new_name
+          self.name = new_name
+        end
+      end
+    end
+  end
 end

data/lib/fog/akamai/models/storage/files.rb

@@ -10,11 +10,12 @@ module Fog
 
         def all
           requires :directory
+          directory.files
         end
 
         def get(path)
           body = service.download(full_path(path, directory)).data[:body]
-          new(:body => body)
+          new(body: body)
         end
 
         def stat(path)
@@ -25,4 +26,4 @@ module Fog
       end
     end
   end
-end
+end

data/lib/fog/akamai/parsers/storage/dir.rb

@@ -4,30 +4,30 @@ module Fog
       module Akamai
         class Dir < Fog::Parsers::Base
           def reset
-            @response = { :directory => '', :files => [] }
+            @response = { directory: '', files: [], directories: [] }
           end
 
           def start_element(name, attrs = [])
             case name
-              when 'stat'
-                @response[:directory] = attrs.first.value
-              when 'file'
-                @response[:files] << attrs_to_hash(attrs) if is_file?(attrs)
+            when 'stat'
+              @response[:directory] = attrs.first.value
+            when 'file'
+              @response[:files] << attrs_to_hash(attrs) if of_type?(attrs, 'file')
+              @response[:directories] << attrs_to_hash(attrs) if of_type?(attrs, 'dir')
             end
           end
 
           private
 
-            def is_file?(attrs)
-              attrs.any? { |attr| attr.localname == 'type' && attr.value == 'file' }
-            end
-
-            def attrs_to_hash(attrs)
-              attrs.inject({}) { |result, attr| result.merge(attr.localname => attr.value) }
-            end
+          def of_type?(attrs, type)
+            attrs.any? { |attr| attr.localname == 'type' && attr.value == type }
+          end
 
+          def attrs_to_hash(attrs)
+            attrs.inject({}) { |a, e| a.merge(e.localname => e.value) }
+          end
         end
       end
     end
   end
-end
+end

data/lib/fog/akamai/parsers/storage/du.rb

@@ -0,0 +1,29 @@
+module Fog
+  module Parsers
+    module Storage
+      module Akamai
+        class Du < Fog::Parsers::Base
+          def reset
+            @response = { directory: '', files: '', bytes: '' }
+          end
+
+          def start_element(name, attrs = [])
+            case name
+            when 'du'
+              @response[:directory] = value_for_attr(attrs, 'directory')
+            when 'du-info'
+              @response[:files] = value_for_attr(attrs, 'files')
+              @response[:bytes] = value_for_attr(attrs, 'bytes')
+            end
+          end
+
+          private
+
+          def value_for_attr(attrs, name)
+            attrs.find { |attr| attr.localname == name }.value
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fog/akamai/requests/storage/delete.rb

@@ -0,0 +1,46 @@
+require 'pathname'
+
+module Fog
+  module Storage
+    class Akamai
+      class Real
+        # Use this action to delete an individual file or symbolic link.
+        # @param path [String] the path for the file that will be downloaded
+        # @return [Excon::Response] response
+
+        def delete(path)
+          path_guard(path)
+          request(:delete,
+                  path: format_path(path),
+                  method: 'PUT',
+                  expects: 200)
+        end
+      end
+
+      class Mock
+        def delete(path)
+          path_guard(path)
+
+          if remove_file(Pathname.new(format_path(path)))
+            Excon::Response.new(status: 200)
+          else
+            fail(Excon::Errors::NotFound, '404 Not Found')
+          end
+        end
+
+        private
+
+        def remove_file(path)
+          return false unless data.key?(path.to_s)
+
+          data[path.to_s] = nil
+          remove_file_from_parent_dir(path)
+        end
+
+        def remove_file_from_parent_dir(path)
+          data[path.split.first.to_s][:files].reject! { |hash| hash['name'] == path.basename.to_s }
+        end
+      end
+    end
+  end
+end

data/lib/fog/akamai/requests/storage/dir.rb

@@ -4,23 +4,36 @@ module Fog
       class Real
         require 'fog/akamai/parsers/storage/dir'
 
-        def dir(path = nil)
-          path ||= ''
+        # Use this action to return the structure for a selected directory
+        # @return [Excon::Response] response:
+        #   * body [Hash]:
+        #     * directory [String] - Path to directory
+        #     * files [Array]:
+        #       * type [String]
+        #       * name [String]
+        #       * mtime [String]
+        #       * size [String]
+        #       * md5 [String]
+        #     * directories [Array]:
+        #       * type [String]
+        #       * name [String]
+        #       * mtime [String]
+
+        def dir(path = '')
           request(:dir,
-                  {
-                    :path => format_path(path),
-                    :method => 'GET',
-                    :expects => 200,
-                    :parser => Fog::Parsers::Storage::Akamai::Dir.new
-                  })
+                  path: format_path(path),
+                  method: 'GET',
+                  expects: 200,
+                  parser: Fog::Parsers::Storage::Akamai::Dir.new)
         end
       end
 
       class Mock
-        def dir
-          raise Fog::Mock.not_implemented
+        def dir(path = '')
+          key = format_path(path)
+          data.key?(key) ? Excon::Response.new(status: 200, body: data[key]) : fail(Excon::Errors::NotFound, '404 Not Found')
         end
       end
     end
   end
-end
+end

data/lib/fog/akamai/requests/storage/download.rb

@@ -2,21 +2,28 @@ module Fog
   module Storage
     class Akamai
       class Real
+        # Use this action to download a file
+        # @param path [String] the path for the file that will be downloaded
+        # @return [Excon::Response] response:
+        #   * body [binary]
+
         def download(path)
+          path_guard(path)
           request(:download,
-                  {
-                    :path => format_path(path),
-                    :method => 'GET',
-                    :expects => 200
-                  })
+                  path: format_path(path),
+                  method: 'GET',
+                  expects: 200)
         end
       end
 
       class Mock
         def download(path)
-          raise Fog::Mock.not_implemented
+          path_guard(path)
+          formatted_path = format_path(path)
+          fail(Excon::Errors::NotFound, '404 Not Found') unless data.key?(formatted_path) && data[formatted_path].key?(:body)
+          Excon::Response.new(status: 200, body: data[formatted_path][:body])
         end
       end
     end
   end
-end
+end

data/lib/fog/akamai/requests/storage/du.rb

@@ -0,0 +1,42 @@
+module Fog
+  module Storage
+    class Akamai
+      class Real
+        require 'fog/akamai/parsers/storage/du'
+
+        # Use this action to return disk usage information for the directory specified by the
+        # @path, including all files stored in any sub-directories that may exist.
+        # @param path [String] the path for the file that will be downloaded
+        # @return [Excon::Response] response:
+        #   * body [Hash]:
+        #     * directory [String] - The path to the directory
+        #     * files [String] - The size of the files in bytes
+        #     * bytes [String] - The size of the directory in bytes
+
+        def du(path)
+          path_guard(path)
+          request(:du,
+                  path: format_path(path),
+                  method: 'GET',
+                  expects: 200,
+                  parser: Fog::Parsers::Storage::Akamai::Du.new)
+        end
+      end
+
+      class Mock
+        def du(path)
+          path_guard(path)
+
+          key = format_path(path)
+          directory = data[key]
+
+          if directory
+            Excon::Response.new(status: 200, body: { directory: key, files: directory[:files].count.to_s, bytes: directory[:directories].count.to_s })
+          else
+            fail(Excon::Errors::NotFound, '404 Not Found')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fog/akamai/requests/storage/mkdir.rb

@@ -0,0 +1,52 @@
+require 'pathname'
+
+module Fog
+  module Storage
+    class Akamai
+      class Real
+        # Use this action to create a dir
+        # @param path [String] the path to create, it will create directories recursively
+        # @return [Excon::Response] response
+
+        def mkdir(path)
+          path_guard(path)
+          request(:mkdir,
+                  path: format_path(path),
+                  method: 'PUT',
+                  expects: 200
+                 )
+        end
+      end
+
+      class Mock
+        def mkdir(path)
+          path_guard(path)
+
+          path = Pathname.new(format_path(path))
+          last_path_basename = ''
+
+          path.ascend do |parent|
+            break if parent.nil?
+
+            key = parent.to_s
+            update_data(key, last_path_basename)
+            last_path_basename = parent.basename.to_s
+          end
+
+          Excon::Response.new(headers: { 'Status' => 200 })
+        end
+
+        private
+
+        def update_data(key, last_path_basename)
+          data[key] ||= { directory: key, files: [], directories: [] }
+          data[key][:directories] << build_directory_node(last_path_basename) unless last_path_basename.empty?
+        end
+
+        def build_directory_node(last_path_basename)
+          { 'type' => 'dir', 'name' => last_path_basename, 'mtime' => DateTime.now.to_time.to_i.to_s }
+        end
+      end
+    end
+  end
+end

data/lib/fog/akamai/requests/storage/mtime.rb

@@ -0,0 +1,45 @@
+require 'pathname'
+
+module Fog
+  module Storage
+    class Akamai
+      class Real
+        # Use this action to change a file's modification time ("touch").
+        # @param path [String] the path for he file that will be downloaded
+        # @param mtime [int] the desired modification time for the target content (i.e., in UNIX epoch time).
+        # @return [Excon::Response] response
+
+        def mtime(path, mtime = DateTime.now.to_time.to_i)
+          path_guard(path)
+          request({ action: :mtime, mtime: mtime },
+                  path: format_path(path),
+                  method: 'POST',
+                  expects: 200)
+        end
+      end
+
+      class Mock
+        def mtime(path, mtime = DateTime.now.to_time.to_i)
+          path_guard(path)
+
+          pathname = Pathname.new(format_path(path))
+          file = get_file(pathname)
+
+          if file
+            file['mtime'] = mtime.to_s
+            Excon::Response.new(status: 200)
+          else
+            fail(Excon::Errors::NotFound, '404 Not Found')
+          end
+        end
+
+        private
+
+        def get_file(pathname)
+          dir = data[pathname.split.first.to_s] || { files: [] }
+          dir[:files].find { |file_hash| file_hash['name'] == pathname.basename.to_s }
+        end
+      end
+    end
+  end
+end

data/lib/fog/akamai/requests/storage/rename.rb

@@ -0,0 +1,54 @@
+require 'pathname'
+
+module Fog
+  module Storage
+    class Akamai
+      class Real
+        # Use this action to rename a file or symbolic link.
+        # @param source [String] the path to check
+        # @param destination [String] the path to check
+        # @return [Excon::Response] response
+
+        def rename(source, destination)
+          path_guard(source)
+          path_guard(destination)
+
+          request({ action: :rename, destination: CGI.escape(format_path(destination)) },
+                  path: format_path(source),
+                  method: 'POST',
+                  expects: 200)
+        end
+      end
+
+      class Mock
+        def rename(source, destination)
+          path_guard(source)
+          path_guard(destination)
+
+          source_pathname = Pathname.new(format_path(source))
+          destination_pathname = Pathname.new(format_path(destination))
+
+          if rename_file(source_pathname, destination_pathname)
+            move_file(source_pathname, destination_pathname)
+            Excon::Response.new(status: 200)
+          else
+            fail(Excon::Errors::NotFound, '404 Not Found')
+          end
+        end
+
+        private
+
+        def rename_file(source, destination)
+          source_dir = data[source.split.first.to_s] || { files: [] }
+          source_file = source_dir[:files].find { |file| file['name'] == source.basename.to_s }
+          source_file['name'] = destination.basename.to_s if source_file
+        end
+
+        def move_file(source, destination)
+          data[destination.to_s] = data[source.to_s]
+          data[source.to_s] = nil
+        end
+      end
+    end
+  end
+end

data/lib/fog/akamai/requests/storage/rmdir.rb

@@ -0,0 +1,41 @@
+module Fog
+  module Storage
+    class Akamai
+      class Real
+        # Use this action to delete an empty directory.
+        # @param path [String] the path to the directory
+        # @return [Excon::Response] response
+
+        def rmdir(path)
+          path_guard(path)
+          request(:rmdir,
+                  method: 'POST',
+                  path: format_path(path),
+                  expects: 200)
+        end
+      end
+
+      class Mock
+        def rmdir(path)
+          path_guard(path)
+
+          formatted_path = format_path(path)
+          dir = data[formatted_path]
+
+          if empty?(dir)
+            data.delete(formatted_path)
+            Excon::Response.new(status: 200)
+          else
+            fail(Excon::Errors::Conflict, 'Not a empty directory')
+          end
+        end
+
+        private
+
+        def empty?(dir)
+          dir[:files].empty? && dir[:directories].empty?
+        end
+      end
+    end
+  end
+end

data/lib/fog/akamai/requests/storage/stat.rb

@@ -1,26 +1,66 @@
+require 'pathname'
+
 module Fog
   module Storage
     class Akamai
       class Real
         require 'fog/akamai/parsers/storage/dir'
 
+        # Use this action to check if a file or directory existis
+        # @param path [String] the path to check
+        # @return [Excon::Response] response:
+        #   * body [Hash]:
+        #     * directory [String] - Path of the parnt directory
+        #     * files [Array]: - In case the stat was for a file
+        #       * type [String]
+        #       * name [String]
+        #       * mtime [String]
+        #       * size [String]
+        #       * md5 [String]
+        #     * directories [Array]: - In case the stat was for a directory
+        #       * type [String]
+        #       * name [String]
+        #       * mtime [String]
+
         def stat(path)
-          raise ArgumentError.new('path needs to have a value') if path.empty?
+          path_guard(path)
           request(:stat,
-                  {
-                    :path => format_path(path),
-                    :method => 'GET',
-                    :expects => 200,
-                    :parser => Fog::Parsers::Storage::Akamai::Dir.new
-                  })
+                  path: format_path(path),
+                  method: 'GET',
+                  expects: 200,
+                  parser: Fog::Parsers::Storage::Akamai::Dir.new)
         end
       end
 
       class Mock
         def stat(path)
-          raise Fog::Mock.not_implemented
+          path_guard(path)
+
+          path = Pathname.new(format_path(path))
+          key = path.split.first.to_s
+
+          response = Excon::Response.new(status: get_status(key, path.basename.to_s), body: get_body(key))
+
+          fail(Excon::Errors::NotFound, '404 Not Found') if response.status == 404
+          response
+        end
+
+        private
+
+        def get_status(key, basename)
+          if data.key?(key) &&
+             (data[key][:directories].any? { |dir| dir['name'] == basename } ||
+               data[key][:files].any? { |file| file['name'] == basename })
+            200
+          else
+            404
+          end
+        end
+
+        def get_body(key)
+          data[key] if data.key?(key)
         end
       end
     end
   end
-end
+end

data/lib/fog/akamai/requests/storage/symlink.rb

@@ -0,0 +1,25 @@
+module Fog
+  module Storage
+    class Akamai
+      class Real
+        # Use this action to rename a file or symbolic link.
+        # @param source [String] the path to check
+        # @param target [String] the path to check
+        # @return [Excon::Response] response
+
+        def symlink(source, target)
+          path_guard(source)
+          path_guard(target)
+
+          request({ action: :symlink, target: CGI.escape(format_path(target)) },
+                  path: format_path(source),
+                  method: 'POST',
+                  expects: 200)
+        end
+      end
+
+      class Mock
+      end
+    end
+  end
+end

data/lib/fog/akamai/requests/storage/upload.rb

@@ -1,27 +1,51 @@
+require 'pathname'
+
 module Fog
   module Storage
     class Akamai
       class Real
+        # Use this action to upload a file
+        # @param path [String] the path to where to upload
+        # @param body [File] the file to upload, can be file or a byte array
+        # @return [Excon::Response] response
+
         def upload(path, body)
-          raise ArgumentError('path is required') if path.empty?
-          raise ArgumentError('body is required') if body == nil
+          path_and_body_guard(path, body)
+
           data = Fog::Storage.parse_data(body)
           request(:upload,
-                  {
-                    :path => format_path(path),
-                    :method => 'PUT',
-                    :headers => data[:headers],
-                    :body => data[:body],
-                    :expects => 200
-                  })
+                  path: format_path(path),
+                  method: 'PUT',
+                  headers: data[:headers],
+                  body: data[:body],
+                  expects: 200)
         end
       end
 
       class Mock
         def upload(path, body)
-          raise Fog::Mock.not_implementedend
+          path_and_body_guard(path, body)
+
+          path = Pathname(path)
+          dir = path.split.first.to_s
+
+          mkdir(dir)
+          add_file(dir, path, body)
+
+          Excon::Response.new(status: 200)
+        end
+
+        private
+
+        def add_file(dir, path, body)
+          data[format_path(dir)][:files] << build_file(body, path)
+          data[format_path(path.to_s)] = { body: body }
+        end
+
+        def build_file(body, path)
+          { 'type' => 'file', 'name' => path.basename.to_s, 'mtime' => DateTime.now.to_time.to_i.to_s, 'size' => body.size.to_s }
         end
       end
     end
   end
-end
+end

data/lib/fog/akamai/storage.rb

@@ -3,7 +3,7 @@ module Fog
     class Akamai < Fog::Service
       requires :akamai_host, :akamai_key_name, :akamai_key, :akamai_cp_code
 
-      VALID_ACTIONS = [:dir, :download, :stat, :upload]
+      VALID_ACTIONS = [:dir, :mkdir, :download, :stat, :upload, :delete, :du, :mtime, :rename, :rmdir, :symlink]
       ACS_AUTH_DATA_HEADER = 'X-Akamai-ACS-Auth-Data'
       ACS_AUTH_SIGN_HEADER = 'X-Akamai-ACS-Auth-Sign'
       ACS_AUTH_ACTION_HEADER = 'X-Akamai-ACS-Action'
@@ -16,25 +16,75 @@ module Fog
 
       request_path 'fog/akamai/requests/storage'
       request :dir
+      request :mkdir
       request :download
       request :stat
       request :upload
+      request :delete
+      request :du
+      request :mtime
+      request :rename
+      request :rmdir
+      request :symlink
 
       module Helpers
         def format_path(path)
           ["/#{akamai_cp_code}", path].reject(&:empty?).join
         end
+
+        def path_and_body_guard(path, body)
+          path_guard(path)
+          fail ArgumentError('body is required') if body.nil?
+        end
+
+        def path_guard(path)
+          fail(ArgumentError, 'path needs to have a value') if path.nil? || path.empty?
+        end
+      end
+
+      module Initializer
+        def self.included(klass)
+          klass.instance_eval do
+            attr_reader :akamai_key, :akamai_host, :akamai_cp_code, :akamai_key_name, :scheme, :port
+          end
+        end
+
+        def init(options)
+          @akamai_host = options[:akamai_host]
+          @akamai_key_name = options[:akamai_key_name]
+          @akamai_key = options[:akamai_key]
+          @akamai_cp_code = options[:akamai_cp_code]
+
+          @scheme = options[:scheme] || 'https'
+          @port = options[:port] || 443
+        end
       end
 
       class Mock
-        def initialize(_options = {})
+        include Helpers
+        include Initializer
+
+        def self.data
+          @data ||= {}
+        end
+
+        def initialize(options = {})
+          init(options)
+        end
+
+        def data
+          self.class.data
+        end
+
+        def reset_data
+          self.class.data.clear
         end
       end
 
       class Real
         include Helpers
+        include Initializer
 
-        attr_reader :akamai_key, :akamai_host, :akamai_cp_code, :akamai_key_name, :scheme, :port
         # Initialize connection to Akamai
         #
         # ==== Notes
@@ -55,13 +105,7 @@ module Fog
         # ==== Returns
         # * Storage object for akamai.
         def initialize(options = {})
-          @akamai_host = options[:akamai_host]
-          @akamai_key_name = options[:akamai_key_name]
-          @akamai_key = options[:akamai_key]
-          @akamai_cp_code = options[:akamai_cp_code]
-
-          @scheme = options[:scheme] || 'https'
-          @port = options[:port] || 443
+          init(options)
         end
 
         def acs_auth_data
@@ -74,40 +118,41 @@ module Fog
         end
 
         def acs_action(action)
-          raise ArgumentError.new("Invalid action #{action} valid actions are: #{VALID_ACTIONS}") unless VALID_ACTIONS.include?(action)
+          action = { action: action } if action.is_a?(Symbol)
+
+          fail(ArgumentError, "Invalid action #{action} valid actions are: #{VALID_ACTIONS}") unless VALID_ACTIONS.include?(action[:action])
 
-          "version=1&action=#{action}&format=xml"
+          "version=1&#{action.map { |v, k| "#{v}=#{k}" }.join('&')}&format=xml"
         end
 
         def acs_auth_sign(auth_data, path, action)
           data = auth_data + sign_string(path, action)
           digest = OpenSSL::Digest::Digest::SHA256.new
-          Base64.encode64(OpenSSL::HMAC.digest(digest, akamai_key, data)).strip()
+          Base64.encode64(OpenSSL::HMAC.digest(digest, akamai_key, data)).strip
         end
 
         private
 
-          def request(action, params)
-            url = "#{scheme}://#{akamai_host}:#{port}"
+        def request(action, params)
+          url = "#{scheme}://#{akamai_host}:#{port}"
 
-            path = params[:path]
-            auth_data = acs_auth_data
-            auth_sign = acs_auth_sign(auth_data, path, action)
+          path = params[:path]
+          auth_data = acs_auth_data
 
-            headers = {
-              ACS_AUTH_DATA_HEADER => auth_data,
-              ACS_AUTH_SIGN_HEADER => auth_sign,
-              ACS_AUTH_ACTION_HEADER => acs_action(action)
-            }.merge(params[:headers] || {})
+          headers = {
+            ACS_AUTH_DATA_HEADER => auth_data,
+            ACS_AUTH_SIGN_HEADER => acs_auth_sign(auth_data, path, action),
+            ACS_AUTH_ACTION_HEADER => acs_action(action)
+          }.merge(params[:headers] || {})
 
-            params = params.merge(headers: headers)
-            Fog::XML::Connection.new(url).request(params)
-          end
+          params = params.merge(headers: headers)
+          Fog::XML::Connection.new(url).request(params)
+        end
 
-          def sign_string(path, action)
-            action = "x-akamai-acs-action:#{acs_action(action)}\n"
-            "#{path}\n#{action}"
-          end
+        def sign_string(path, action)
+          action = "x-akamai-acs-action:#{acs_action(action)}\n"
+          "#{path}\n#{action}"
+        end
       end
     end
   end

data/lib/fog/akamai/version.rb

@@ -1,5 +1,5 @@
 module Fog
   module Akamai
-    VERSION = '0.1.1'
+    VERSION = '0.5.0'
   end
 end

data/lib/fog/akamai.rb

@@ -14,9 +14,7 @@ module Fog
 
     module Shared
       def full_path(path, directory = nil)
-        if directory
-          path = [directory.key, path].join('/')
-        end
+        path = [directory.key, path].join('/') if directory
         path
       end
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fog-akamai
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.5.0
 platform: ruby
 authors:
 - Calin
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2015-11-05 00:00:00.000000000 Z
+date: 2015-11-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -94,6 +94,34 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.22'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.35'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.35'
+- !ruby/object:Gem::Dependency
+  name: timecop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.8.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.8.0
 - !ruby/object:Gem::Dependency
   name: fog-core
   requirement: !ruby/object:Gem::Requirement
@@ -146,6 +174,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
+- ".rubocop.yml"
 - ".ruby-gemset"
 - ".ruby-version"
 - ".travis.yml"
@@ -166,9 +195,17 @@ files:
 - lib/fog/akamai/models/storage/file.rb
 - lib/fog/akamai/models/storage/files.rb
 - lib/fog/akamai/parsers/storage/dir.rb
+- lib/fog/akamai/parsers/storage/du.rb
+- lib/fog/akamai/requests/storage/delete.rb
 - lib/fog/akamai/requests/storage/dir.rb
 - lib/fog/akamai/requests/storage/download.rb
+- lib/fog/akamai/requests/storage/du.rb
+- lib/fog/akamai/requests/storage/mkdir.rb
+- lib/fog/akamai/requests/storage/mtime.rb
+- lib/fog/akamai/requests/storage/rename.rb
+- lib/fog/akamai/requests/storage/rmdir.rb
 - lib/fog/akamai/requests/storage/stat.rb
+- lib/fog/akamai/requests/storage/symlink.rb
 - lib/fog/akamai/requests/storage/upload.rb
 - lib/fog/akamai/storage.rb
 - lib/fog/akamai/version.rb
@@ -192,7 +229,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.6
+rubygems_version: 2.4.8
 signing_key: 
 specification_version: 4
 summary: Module for 'fog' gem to support Akamai