phpfog-fog 0.4.1

data/lib/fog/aws/requests/elb/create_load_balancer.rb

@@ -0,0 +1,59 @@
+module Fog
+  module AWS
+    class ELB
+      class Real
+
+        require 'fog/aws/parsers/elb/create_load_balancer'
+
+        # Create a new Elastic Load Balancer
+        #
+        # ==== Parameters
+        # * availability_zones<~Array> - List of availability zones for the ELB
+        # * lb_name<~String> - Name for the new ELB -- must be unique
+        # * listeners<~Array> - Array of Hashes describing ELB listeners to assign to the ELB
+        #   * 'Protocol'<~String> - Protocol to use. Either HTTP or TCP.
+        #   * 'LoadBalancerPort'<~Integer> - The port that the ELB will listen to for outside traffic
+        #   * 'InstancePort'<~Integer> - The port on the instance that the ELB will forward traffic to
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'ResponseMetadata'<~Hash>:
+        #       * 'RequestId'<~String> - Id of request
+        #     * 'CreateLoadBalancerResult'<~Hash>:
+        #       * 'DNSName'<~String> - DNS name for the newly created ELB
+        def create_load_balancer(availability_zones, lb_name, listeners)
+          params = AWS.indexed_param('AvailabilityZones.member', [*availability_zones])
+
+          listener_protocol = []
+          listener_lb_port = []
+          listener_instance_port = []
+          listeners.each do |listener|
+            listener_protocol.push(listener['Protocol'])
+            listener_lb_port.push(listener['LoadBalancerPort'])
+            listener_instance_port.push(listener['InstancePort'])
+          end
+
+          params.merge!(AWS.indexed_param('Listeners.member.%d.Protocol', listener_protocol))
+          params.merge!(AWS.indexed_param('Listeners.member.%d.LoadBalancerPort', listener_lb_port))
+          params.merge!(AWS.indexed_param('Listeners.member.%d.InstancePort', listener_instance_port))
+
+          request({
+            'Action'           => 'CreateLoadBalancer',
+            'LoadBalancerName' => lb_name,
+            :parser            => Fog::Parsers::AWS::ELB::CreateLoadBalancer.new
+          }.merge!(params))
+        end
+
+      end
+
+      class Mock
+
+        def create_load_balancer(availability_zones, lb_name, listeners)
+          Fog::Mock.not_implemented
+        end
+
+      end
+
+    end
+  end
+end

data/lib/fog/aws/requests/elb/delete_load_balancer.rb

@@ -0,0 +1,42 @@
+module Fog
+  module AWS
+    class ELB
+      class Real
+
+        require 'fog/aws/parsers/elb/delete_load_balancer'
+
+        # Delete an existing Elastic Load Balancer
+        #
+        # Note that this API call, as defined by Amazon, is idempotent.
+        # That is, it will not return an error if you try to delete an
+        # ELB that does not exist.
+        #
+        # ==== Parameters
+        # * lb_name<~String> - Name of the ELB to be deleted
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'DeleteLoadBalancerResponse'<~nil>
+        #     * 'ResponseMetadata'<~Hash>:
+        #       * 'RequestId'<~String> - Id of request
+        def delete_load_balancer(lb_name)
+          request({
+            'Action'           => 'DeleteLoadBalancer',
+            'LoadBalancerName' => lb_name,
+            :parser            => Fog::Parsers::AWS::ELB::DeleteLoadBalancer.new
+          })
+        end
+
+      end
+
+      class Mock
+
+        def delete_load_balancer(lb_name)
+          Fog::Mock.not_implemented
+        end
+
+      end
+
+    end
+  end
+end

data/lib/fog/aws/requests/elb/deregister_instances_from_load_balancer.rb

@@ -0,0 +1,47 @@
+module Fog
+  module AWS
+    class ELB
+      class Real
+
+        require 'fog/aws/parsers/elb/deregister_instances_from_load_balancer'
+
+        # Deregister an instance from an existing ELB
+        #
+        # ==== Parameters
+        # * instance_ids<~Array> - List of instance IDs to remove from ELB
+        # * lb_name<~String> - Load balancer to remove instances from
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'ResponseMetadata'<~Hash>:
+        #       * 'RequestId'<~String> - Id of request
+        #     * 'DeregisterInstancesFromLoadBalancerResult'<~Hash>:
+        #       * 'Instances'<~Array> - array of hashes describing instances currently enabled
+        #         * 'InstanceId'<~String>
+        def deregister_instances_from_load_balancer(instance_ids, lb_name)
+          params = AWS.indexed_param('Instances.member.%d.InstanceId', [*instance_ids])
+          request({
+            'Action'           => 'DeregisterInstancesFromLoadBalancer',
+            'LoadBalancerName' => lb_name,
+            :parser            => Fog::Parsers::AWS::ELB::DeregisterInstancesFromLoadBalancer.new
+          }.merge!(params))
+        end
+
+        alias :deregister_instances :deregister_instances_from_load_balancer
+
+      end
+
+      class Mock
+
+        def deregister_instances_from_load_balancer(instance_ids, lb_name)
+          Fog::Mock.not_implemented
+        end
+
+        alias :deregister_instances :deregister_instances_from_load_balancer
+
+      end
+
+    end
+  end
+end

data/lib/fog/aws/requests/elb/describe_instance_health.rb

@@ -0,0 +1,46 @@
+module Fog
+  module AWS
+    class ELB
+      class Real
+
+        require 'fog/aws/parsers/elb/describe_instance_health'
+
+        # Get health status for one or more instances on an existing ELB
+        #
+        # ==== Parameters
+        # * lb_name<~String> - Load balancer to check instances health on
+        # * instance_ids<~Array> - Optional list of instance IDs to check
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'ResponseMetadata'<~Hash>:
+        #       * 'RequestId'<~String> - Id of request
+        #     * 'DescribeInstanceHealthResult'<~Hash>:
+        #       * 'InstanceStates'<~Array> - array of hashes describing instance health
+        #         * 'Description'<~String>
+        #         * 'State'<~String>
+        #         * 'InstanceId'<~String>
+        #         * 'ReasonCode'<~String>
+        def describe_instance_health(lb_name, instance_ids = [])
+          params = AWS.indexed_param('Instances.member.%d.InstanceId', [*instance_ids])
+          request({
+            'Action'           => 'DescribeInstanceHealth',
+            'LoadBalancerName' => lb_name,
+            :parser            => Fog::Parsers::AWS::ELB::DescribeInstanceHealth.new
+          }.merge!(params))
+        end
+
+      end
+
+      class Mock
+
+        def describe_instance_health(lb_name, instance_ids = [])
+          Fog::Mock.not_implemented
+        end
+
+      end
+
+    end
+  end
+end

data/lib/fog/aws/requests/elb/describe_load_balancers.rb

@@ -0,0 +1,59 @@
+module Fog
+  module AWS
+    class ELB
+      class Real
+
+        require 'fog/aws/parsers/elb/describe_load_balancers'
+
+        # Describe all or specified load balancers
+        #
+        # ==== Parameters
+        # * lb_name<~Array> - List of load balancer names to describe, defaults to all
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'ResponseMetadata'<~Hash>:
+        #       * 'RequestId'<~String> - Id of request
+        #     * 'DescribeLoadBalancersResult'<~Hash>:
+        #       * 'LoadBalancerDescriptions'<~Array>
+        #         * 'LoadBalancerName'<~String> - name of load balancer
+        #         * 'DNSName'<~String> - external DNS name of load balancer
+        #         * 'CreatedTime'<~Time> - time load balancer was created
+        #         * 'ListenerDescriptions'<~Array>
+        #           * 'PolicyNames'<~Array> - list of policies enabled
+        #           * 'Listener'<~Hash>:
+        #             * 'InstancePort'<~Integer> - port on instance that requests are sent to
+        #             * 'Protocol'<~String> - transport protocol used for routing in [TCP, HTTP]
+        #             * 'LoadBalancerPort'<~Integer> - port that load balancer listens on for requests
+        #         * 'HealthCheck'<~Hash>:
+        #           * 'HealthyThreshold'<~Integer> - number of consecutive health probe successes required before moving the instance to the Healthy state
+        #           * 'Timeout'<~Integer> - number of seconds after which no response means a failed health probe
+        #           * 'Interval'<~Integer> - interval (in seconds) between health checks of an individual instance
+        #           * 'UnhealthyThreshold'<~Integer> - number of consecutive health probe failures that move the instance to the unhealthy state
+        #           * 'Target'<~String> - string describing protocol type, port and URL to check
+        #         * 'Policies'<~Hash>:
+        #           * 'LBCookieStickinessPolicies'<~Array> - list of Load Balancer Generated Cookie Stickiness policies for the LoadBalancer
+        #           * 'AppCookieStickinessPolicies'<~Array> - list of Application Generated Cookie Stickiness policies for the LoadBalancer
+        #         * 'AvailabilityZones'<~Array> - list of availability zones covered by this load balancer
+        #         * 'Instances'<~Array> - list of instances that the load balancer balances between
+        def describe_load_balancers(lb_name = [])
+          params = AWS.indexed_param('LoadBalancerNames.member', [*lb_name])
+          request({
+            'Action'  => 'DescribeLoadBalancers',
+            :parser   => Fog::Parsers::AWS::ELB::DescribeLoadBalancers.new
+          }.merge!(params))
+        end
+
+      end
+
+      class Mock
+
+        def describe_load_balancers(lb_name = [])
+          Fog::Mock.not_implemented
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/aws/requests/elb/disable_availability_zones_for_load_balancer.rb

@@ -0,0 +1,46 @@
+module Fog
+  module AWS
+    class ELB
+      class Real
+
+        require 'fog/aws/parsers/elb/disable_availability_zones_for_load_balancer'
+
+        # Disable an availability zone for an existing ELB
+        #
+        # ==== Parameters
+        # * availability_zones<~Array> - List of availability zones to disable on ELB
+        # * lb_name<~String> - Load balancer to disable availability zones on
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'ResponseMetadata'<~Hash>:
+        #       * 'RequestId'<~String> - Id of request
+        #     * 'DisableAvailabilityZonesForLoadBalancerResult'<~Hash>:
+        #       * 'AvailabilityZones'<~Array> - array of strings describing instances currently enabled
+        def disable_availability_zones_for_load_balancer(availability_zones, lb_name)
+          params = AWS.indexed_param('AvailabilityZones.member', [*availability_zones])
+          request({
+            'Action'           => 'DisableAvailabilityZonesForLoadBalancer',
+            'LoadBalancerName' => lb_name,
+            :parser            => Fog::Parsers::AWS::ELB::DisableAvailabilityZonesForLoadBalancer.new
+          }.merge!(params))
+        end
+
+        alias :disable_zones :disable_availability_zones_for_load_balancer
+
+      end
+
+      class Mock
+
+        def disable_availability_zones_for_load_balancer(availability_zones, lb_name)
+          Fog::Mock.not_implemented
+        end
+
+        alias :disable_zones :disable_availability_zones_for_load_balancer
+
+      end
+
+    end
+  end
+end

data/lib/fog/aws/requests/elb/enable_availability_zones_for_load_balancer.rb

@@ -0,0 +1,46 @@
+module Fog
+  module AWS
+    class ELB
+      class Real
+
+        require 'fog/aws/parsers/elb/enable_availability_zones_for_load_balancer'
+
+        # Enable an availability zone for an existing ELB
+        #
+        # ==== Parameters
+        # * availability_zones<~Array> - List of availability zones to enable on ELB
+        # * lb_name<~String> - Load balancer to enable availability zones on
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'ResponseMetadata'<~Hash>:
+        #       * 'RequestId'<~String> - Id of request
+        #     * 'EnableAvailabilityZonesForLoadBalancerResult'<~Hash>:
+        #       * 'AvailabilityZones'<~Array> - array of strings describing instances currently enabled
+        def enable_availability_zones_for_load_balancer(availability_zones, lb_name)
+          params = AWS.indexed_param('AvailabilityZones.member', [*availability_zones])
+          request({
+            'Action'           => 'EnableAvailabilityZonesForLoadBalancer',
+            'LoadBalancerName' => lb_name,
+            :parser            => Fog::Parsers::AWS::ELB::EnableAvailabilityZonesForLoadBalancer.new
+          }.merge!(params))
+        end
+
+        alias :enable_zones :enable_availability_zones_for_load_balancer
+
+      end
+
+      class Mock
+
+        def enable_availability_zones_for_load_balancer(availability_zones, lb_name)
+          Fog::Mock.not_implemented
+        end
+
+        alias :enable_zones :enable_availability_zones_for_load_balancer
+
+      end
+
+    end
+  end
+end

data/lib/fog/aws/requests/elb/register_instances_with_load_balancer.rb

@@ -0,0 +1,47 @@
+module Fog
+  module AWS
+    class ELB
+      class Real
+
+        require 'fog/aws/parsers/elb/register_instances_with_load_balancer'
+
+        # Register an instance with an existing ELB
+        #
+        # ==== Parameters
+        # * instance_ids<~Array> - List of instance IDs to associate with ELB
+        # * lb_name<~String> - Load balancer to assign instances to
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'ResponseMetadata'<~Hash>:
+        #       * 'RequestId'<~String> - Id of request
+        #     * 'RegisterInstancesWithLoadBalancerResult'<~Hash>:
+        #       * 'Instances'<~Array> - array of hashes describing instances currently enabled
+        #         * 'InstanceId'<~String>
+        def register_instances_with_load_balancer(instance_ids, lb_name)
+          params = AWS.indexed_param('Instances.member.%d.InstanceId', [*instance_ids])
+          request({
+            'Action'           => 'RegisterInstancesWithLoadBalancer',
+            'LoadBalancerName' => lb_name,
+            :parser            => Fog::Parsers::AWS::ELB::RegisterInstancesWithLoadBalancer.new
+          }.merge!(params))
+        end
+
+        alias :register_instances :register_instances_with_load_balancer
+
+      end
+
+      class Mock
+
+        def register_instances_with_load_balancer(instance_ids, lb_name)
+          Fog::Mock.not_implemented
+        end
+
+        alias :register_instances :register_instances_with_load_balancer
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+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)
+          Fog::Mock.not_implemented
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+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(user_name = nil)
+          Fog::Mock.not_implemented
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+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 = '/')
+          Fog::Mock.not_implemented
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+module Fog
+  module AWS
+    class IAM
+      class Real
+
+        require 'fog/aws/parsers/iam/create_user'
+
+        # Create a new user
+        # 
+        # ==== Parameters
+        # * user_name<~String>: name of the user to create (do not include path)
+        # * path<~String>: optional path to group, defaults to '/'
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'User'<~Hash>:
+        #       * 'Arn'<~String> -
+        #       * 'Path'<~String> -
+        #       * 'UserId'<~String> -
+        #       * 'UserName'<~String> -
+        #     * 'RequestId'<~String> - Id of the request
+        #
+        # ==== See Also
+        # http://docs.amazonwebservices.com/IAM/latest/APIReference/API_CreateUser.html
+        #
+        def create_user(user_name, path = '/')
+          request(
+            'Action'    => 'CreateUser',
+            'UserName'  => user_name,
+            'Path'      => path,
+            :parser     => Fog::Parsers::AWS::IAM::CreateUser.new
+          )
+        end
+
+      end
+
+      class Mock
+
+        def create_user(user_name, path = '/')
+          Fog::Mock.not_implemented
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+module Fog
+  module AWS
+    class IAM
+      class Real
+
+        require 'fog/aws/parsers/iam/basic'
+
+        # Delete an access key
+        # 
+        # ==== Parameters
+        # * access_key_id<~String> - Access key id to delete
+        # * options<~Hash>:
+        #   * 'UserName'<~String> - name of the user to create (do not include path)
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'RequestId'<~String> - Id of the request
+        #
+        # ==== See Also
+        # http://docs.amazonwebservices.com/IAM/latest/APIReference/API_DeleteAccessKey.html
+        #
+        def delete_access_key(access_key_id, options = {})
+          request({
+            'AccessKeyId' => access_key_id,
+            'Action'      => 'DeleteAccessKey',
+            :parser       => Fog::Parsers::AWS::IAM::Basic.new
+          }.merge!(options))
+        end
+
+      end
+
+      class Mock
+
+        def delete_access_key(access_key_id, user_name = nil)
+          Fog::Mock.not_implemented
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+module Fog
+  module AWS
+    class IAM
+      class Real
+
+        require 'fog/aws/parsers/iam/basic'
+
+        # Delete a group
+        # 
+        # ==== Parameters
+        # * group_name<~String>: name of the group to delete
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'RequestId'<~String> - Id of the request
+        #
+        # ==== See Also
+        # http://docs.amazonwebservices.com/IAM/latest/APIReference/API_DeleteGroup.html
+        #
+        def delete_group(group_name)
+          request(
+            'Action'    => 'DeleteGroup',
+            'GroupName' => group_name,
+            :parser     => Fog::Parsers::AWS::IAM::Basic.new
+          )
+        end
+
+      end
+
+      class Mock
+
+        def delete_group(group_name)
+          Fog::Mock.not_implemented
+        end
+
+      end
+    end
+  end
+end