fog-aws 0.0.5

data/lib/fog/aws/requests/glacier/list_parts.rb

@@ -0,0 +1,35 @@
+module Fog
+  module AWS
+    class Glacier
+      class Real
+        #  lists the parts of an archive that have been uploaded in a specific multipart upload
+        #
+        # ==== Parameters
+        # * name<~String> Name of the vault
+        # * upload_id<~String> The id of the upload
+        # * options<~Hash>
+        #   * limit<~Integer> - The maximum number of items returned in the response. (default 1000)
+        #   * marker<~String> - marker used for pagination
+        #   * account_id<~String> - The AWS account id. Defaults to the account owning the credentials making the request
+        # ==== Returns
+        # * response<~Excon::Response>:
+        # ==== See Also
+        # http://docs.amazonwebservices.com/amazonglacier/latest/dev/api-multipart-list-parts.html
+        #
+        def list_parts(vault_name, upload_id, options={})
+          account_id = options.delete('account_id') || '-'
+          path = "/#{account_id}/vaults/#{Fog::AWS.escape(vault_name)}/multipart-uploads/#{Fog::AWS.escape(upload_id)}"
+
+          request(
+            :expects  => 200,
+            :idempotent => true,
+            :headers => {},
+            :method   => :get,
+            :path     => path,
+            :query    => options
+          )
+        end
+      end
+    end
+  end
+end

data/lib/fog/aws/requests/glacier/list_vaults.rb

@@ -0,0 +1,34 @@
+module Fog
+  module AWS
+    class Glacier
+      class Real
+        # This operation lists all vaults owned by the calling user’s account.
+        #
+        # ==== Parameters
+        # * options<~Hash>
+        #   * limit<~Integer> - The maximum number of items returned in the response. (default 1000)
+        #   * marker<~String> - marker used for pagination
+        #   * account_id<~String> - The AWS account id. Defaults to the account owning the credentials making the request
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #
+        # ==== See Also
+        # http://docs.amazonwebservices.com/amazonglacier/latest/dev/api-vaults-get.html
+        #
+        def list_vaults(options={})
+          account_id = options.delete('account_id') || '-'
+          path = "/#{account_id}/vaults"
+          request(
+            :expects  => 200,
+            :idempotent => true,
+            :headers => {},
+            :method   => 'GET',
+            :path     => path,
+            :query => options
+          )
+        end
+      end
+    end
+  end
+end

data/lib/fog/aws/requests/glacier/set_vault_notification_configuration.rb

@@ -0,0 +1,35 @@
+module Fog
+  module AWS
+    class Glacier
+      class Real
+        # Set a vault's notification configuration
+        #
+        # ==== Parameters
+        # * name<~String> Name of the vault
+        # * SnsTopic<~String> ARN of the topic to notify
+        # * events<~Array> Events you wish to receive. Valid events are ArchiveRetrievalCompleted, InventoryRetrievalCompleted
+        # * options<~Hash>
+        #   * account_id<~String> - The AWS account id. Defaults to the account owning the credentials making the request
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #
+        # ==== See Also
+        # http://docs.amazonwebservices.com/amazonglacier/latest/dev/api-vault-notifications-put.html
+        #
+        def set_vault_notification_configuration(name,sns_topic, events, options={})
+          account_id = options['account_id'] || '-'
+          path = "/#{account_id}/vaults/#{Fog::AWS.escape(name)}/notification-configuration"
+          request(
+            :expects  => 204,
+            :idempotent => true,
+            :headers => {},
+            :method   => :put,
+            :path     => path,
+            :body     => Fog::JSON.encode('SNSTopic' => sns_topic, 'Events' => events)
+          )
+        end
+      end
+    end
+  end
+end

data/lib/fog/aws/requests/glacier/upload_part.rb

@@ -0,0 +1,44 @@
+module Fog
+  module AWS
+    class Glacier
+      class Real
+        # Upload an archive
+        #
+        # ==== Parameters
+        # * name<~String> Name of the vault to upload to
+        # * uploadId<~String> Id of the upload
+        # * body<~String> The data to upload
+        # * offset<~Integer> The offset of the data within the archive
+        # * hash<~String> The tree hash for this part
+        # * options<~Hash>
+        #   * account_id<~String> - The AWS account id. Defaults to the account owning the credentials making the request
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #
+        # ==== See Also
+        # http://docs.amazonwebservices.com/amazonglacier/latest/dev/api-upload-part.html
+        #
+        def upload_part(vault_name, upload_id, body, offset, hash, options={})
+          account_id = options['account_id'] || '-'
+          path = "/#{account_id}/vaults/#{Fog::AWS.escape(vault_name)}/multipart-uploads/#{Fog::AWS.escape(upload_id)}"
+
+          headers = {
+            'Content-Length' => body.bytesize.to_s,
+            'Content-Range' => "bytes #{offset}-#{offset+body.bytesize-1}/*",
+            'x-amz-content-sha256' => Digest::SHA256.hexdigest(body),
+            'x-amz-sha256-tree-hash' => hash
+          }
+
+          request(
+            :expects  => 204,
+            :idempotent => true,
+            :headers => headers,
+            :method   => :put,
+            :path     => path,
+            :body     => body
+          )
+        end
+      end
+    end
+  end
+end

data/lib/fog/aws/requests/iam/add_role_to_instance_profile.rb

@@ -0,0 +1,32 @@
+module Fog
+  module AWS
+    class IAM
+      class Real
+        require 'fog/aws/parsers/iam/basic'
+
+        # Add a role to an instance profile
+        #
+        # ==== Parameters
+        # * instance_profile_name<~String>: Name of the instance profile to update.
+        # * role_name<~String>:Name of the role to add.
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'RequestId'<~String> - Id of the request
+        #
+        # ==== See Also
+        # http://docs.amazonwebservices.com/IAM/latest/APIReference/API_AddRoleToInstanceProfile.html
+        #
+        def add_role_to_instance_profile(role_name, instance_profile_name)
+          request(
+            'Action'    => 'AddRoleToInstanceProfile',
+            'InstanceProfileName' => instance_profile_name,
+            'RoleName'  => role_name,
+            :parser     => Fog::Parsers::AWS::IAM::Basic.new
+          )
+        end
+      end
+    end
+  end
+end

data/lib/fog/aws/requests/iam/add_user_to_group.rb

@@ -0,0 +1,54 @@
+module Fog
+  module AWS
+    class IAM
+      class Real
+        require 'fog/aws/parsers/iam/basic'
+
+        # Add a user to a group
+        #
+        # ==== Parameters
+        # * group_name<~String>: name of the group
+        # * user_name<~String>: name of user to add
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'RequestId'<~String> - Id of the request
+        #
+        # ==== See Also
+        # http://docs.amazonwebservices.com/IAM/latest/APIReference/API_AddUserToGroup.html
+        #
+        def add_user_to_group(group_name, user_name)
+          request(
+            'Action'    => 'AddUserToGroup',
+            'GroupName' => group_name,
+            'UserName'  => user_name,
+            :parser     => Fog::Parsers::AWS::IAM::Basic.new
+          )
+        end
+      end
+
+      class Mock
+        def add_user_to_group(group_name, user_name)
+          if data[:groups].key? group_name
+            if data[:users].key? user_name
+
+              unless data[:groups][group_name][:members].include?(user_name)
+                data[:groups][group_name][:members] << user_name
+              end
+
+              Excon::Response.new.tap do |response|
+                response.status = 200
+                response.body = { 'RequestId' => Fog::AWS::Mock.request_id }
+              end
+            else
+              raise Fog::AWS::IAM::NotFound.new("The user with name #{user_name} cannot be found.")
+            end
+          else
+            raise Fog::AWS::IAM::NotFound.new("The group with name #{group_name} cannot be found.")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fog/aws/requests/iam/create_access_key.rb

@@ -0,0 +1,66 @@
+module Fog
+  module AWS
+    class IAM
+      class Real
+        require 'fog/aws/parsers/iam/create_access_key'
+
+        # Create a access keys for user (by default detects user from access credentials)
+        #
+        # ==== Parameters
+        # * options<~Hash>:
+        #   * 'UserName'<~String> - name of the user to create (do not include path)
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'AccessKey'<~Hash>:
+        #       * 'AccessKeyId'<~String> -
+        #       * 'UserName'<~String> -
+        #       * 'SecretAccessKey'<~String> -
+        #       * 'Status'<~String> -
+        #     * 'RequestId'<~String> - Id of the request
+        #
+        # ==== See Also
+        # http://docs.amazonwebservices.com/IAM/latest/APIReference/API_CreateAccessKey.html
+        #
+        def create_access_key(options = {})
+          request({
+            'Action'    => 'CreateAccessKey',
+            :parser     => Fog::Parsers::AWS::IAM::CreateAccessKey.new
+          }.merge!(options))
+        end
+      end
+      class Mock
+        def create_access_key(options)
+          #FIXME: Not 100% correct as AWS will use the signing credentials when there is no 'UserName' in the options hash
+          #       Also doesn't raise an error when there are too many keys
+          if user = options['UserName']
+            if data[:users].key? user
+              access_keys_data = data[:users][user][:access_keys]
+            else
+              raise Fog::AWS::IAM::NotFound.new('The user with name #{user_name} cannot be found.')
+            end
+          else
+            access_keys_data = data[:access_keys]
+          end
+
+          key = { 'SecretAccessKey' => Fog::Mock.random_base64(40),
+                  'Status' => 'Active',
+                  'AccessKeyId' => Fog::AWS::Mock.key_id(20),
+                }
+          if user
+            key["UserName"] = user
+          end
+
+          access_keys_data << key
+
+          Excon::Response.new.tap do |response|
+            response.status = 200
+            response.body = { 'AccessKey' => key,
+                              'RequestId' => Fog::AWS::Mock.request_id }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fog/aws/requests/iam/create_account_alias.rb

@@ -0,0 +1,17 @@
+module Fog
+  module AWS
+    class IAM
+      class Real
+        require 'fog/aws/parsers/iam/basic'
+
+        def create_account_alias(account_alias)
+          request(
+            'Action'    => 'CreateAccountAlias',
+            'AccountAlias'  => account_alias,
+            :parser     => Fog::Parsers::AWS::IAM::Basic.new
+          )
+        end
+      end
+    end
+  end
+end

data/lib/fog/aws/requests/iam/create_group.rb

@@ -0,0 +1,56 @@
+module Fog
+  module AWS
+    class IAM
+      class Real
+        require 'fog/aws/parsers/iam/create_group'
+
+        # Create a new group
+        #
+        # ==== Parameters
+        # * group_name<~String>: name of the group to create (do not include path)
+        # * path<~String>: optional path to group, defaults to '/'
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'Group'<~Hash>:
+        #       * Arn<~String> -
+        #       * GroupId<~String> -
+        #       * GroupName<~String> -
+        #       * Path<~String> -
+        #     * 'RequestId'<~String> - Id of the request
+        #
+        # ==== See Also
+        # http://docs.amazonwebservices.com/IAM/latest/APIReference/API_CreateGroup.html
+        #
+        def create_group(group_name, path = '/')
+          request(
+            'Action'    => 'CreateGroup',
+            'GroupName' => group_name,
+            'Path'      => path,
+            :parser     => Fog::Parsers::AWS::IAM::CreateGroup.new
+          )
+        end
+      end
+
+      class Mock
+        def create_group(group_name, path = '/')
+          if data[:groups].key? group_name
+            raise Fog::AWS::IAM::EntityAlreadyExists.new("Group with name #{group_name} already exists.")
+          else
+            data[:groups][group_name][:path] = path
+            Excon::Response.new.tap do |response|
+              response.body = { 'Group' => {
+                                             'GroupId'   => (data[:groups][group_name][:group_id]).strip,
+                                             'GroupName' => group_name,
+                                             'Path'      => path,
+                                             'Arn'       => (data[:groups][group_name][:arn]).strip },
+                                'RequestId' => Fog::AWS::Mock.request_id }
+              response.status = 200
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fog/aws/requests/iam/create_instance_profile.rb

@@ -0,0 +1,45 @@
+module Fog
+  module AWS
+    class IAM
+      class Real
+        require 'fog/aws/parsers/iam/instance_profile'
+
+        # Create a new instance_profile
+        #
+        # ==== Parameters
+        # * instance_profile_name<~String>: name of the instance profile to create (do not include path)
+        # * path<~String>: optional path to group, defaults to '/'
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'InstanceProfile'<~Hash>:
+        #       * Arn<~String> -
+        #       * CreateDate<~Date>
+        #       * InstanceProfileId<~String> -
+        #       * InstanceProfileName<~String> -
+        #       * Path<~String> -
+        #       * Roles<~Array> -
+        #         role<~Hash>:
+        #           * 'Arn'<~String> -
+        #           * 'AssumeRolePolicyDocument'<~String<
+        #           * 'Path'<~String> -
+        #           * 'RoleId'<~String> -
+        #           * 'RoleName'<~String> -
+        #     * 'RequestId'<~String> - Id of the request
+        #
+        # ==== See Also
+        # http://docs.amazonwebservices.com/IAM/latest/APIReference/API_CreateInstanceProfile.html
+        #
+        def create_instance_profile(instance_profile_name, path='/', options={})
+          request({
+            'Action'    => 'CreateInstanceProfile',
+            'InstanceProfileName' => instance_profile_name,
+            'Path'      => path,
+            :parser     => Fog::Parsers::AWS::IAM::InstanceProfile.new
+          }.merge!(options))
+        end
+      end
+    end
+  end
+end

data/lib/fog/aws/requests/iam/create_login_profile.rb

@@ -0,0 +1,34 @@
+module Fog
+  module AWS
+    class IAM
+      class Real
+        require 'fog/aws/parsers/iam/login_profile'
+
+        # Creates a login profile for a user
+        #
+        # http://docs.amazonwebservices.com/IAM/latest/APIReference/API_CreateLoginProfile.html
+        # ==== Parameters
+        # * user_name<~String> - Name of user to create a login profile for
+        # * password<~String> - The new password for this user
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'LoginProfile'<~Hash>
+        #        * UserName<~String>
+        #        * CreateDate
+        #     * 'RequestId'<~String> - Id of the request
+        #
+        #
+        def create_login_profile(user_name, password)
+          request({
+            'Action'    => 'CreateLoginProfile',
+            'UserName'  => user_name,
+            'Password'  => password,
+            :parser     => Fog::Parsers::AWS::IAM::LoginProfile.new
+          })
+        end
+      end
+    end
+  end
+end