bbcloud 0.8 → 0.8.1

data/lib/bbcloud/vendor/fog-0.3.23/lib/fog/aws/requests/compute/run_instances.rb

@@ -0,0 +1,167 @@
+module Fog
+  module AWS
+    class Compute
+      class Real
+
+        require 'fog/aws/parsers/compute/run_instances'
+
+        # Launch specified instances
+        #
+        # ==== Parameters
+        # * image_id<~String> - Id of machine image to load on instances
+        # * min_count<~Integer> - Minimum number of instances to launch. If this
+        #   exceeds the count of available instances, no instances will be
+        #   launched.  Must be between 1 and maximum allowed for your account
+        #   (by default the maximum for an account is 20)
+        # * max_count<~Integer> - Maximum number of instances to launch. If this
+        #   exceeds the number of available instances, the largest possible
+        #   number of instances above min_count will be launched instead. Must
+        #   be between 1 and maximum allowed for you account
+        #   (by default the maximum for an account is 20)
+        # * options<~Hash>:
+        #   * 'Placement.AvailabilityZone'<~String> - Placement constraint for instances
+        #   * 'BlockDeviceMapping'<~Array>: array of hashes
+        #     * 'DeviceName'<~String> - where the volume will be exposed to instance
+        #     * 'VirtualName'<~String> - volume virtual device name
+        #     * 'Ebs.SnapshotId'<~String> - id of snapshot to boot volume from
+        #     * 'Ebs.VolumeSize'<~String> - size of volume in GiBs required unless snapshot is specified
+        #     * 'Ebs.DeleteOnTermination'<~String> - specifies whether or not to delete the volume on instance termination
+        #   * 'ClientToken'<~String> - unique case-sensitive token for ensuring idempotency
+        #   * 'SecurityGroup'<~Array> or <~String> - Name of security group(s) for instances (you must omit this parameter if using Virtual Private Clouds)
+        #   * 'InstanceInitiatedShutdownBehaviour'<~String> - specifies whether volumes are stopped or terminated when instance is shutdown, in [stop, terminate]
+        #   * 'InstanceType'<~String> - Type of instance to boot. Valid options
+        #     in ['m1.small', 'm1.large', 'm1.xlarge', 'c1.medium', 'c1.xlarge', 'm2.2xlarge', 'm2.4xlarge']
+        #     default is 'm1.small'
+        #   * 'KernelId'<~String> - Id of kernel with which to launch
+        #   * 'KeyName'<~String> - Name of a keypair to add to booting instances
+        #   * 'Monitoring.Enabled'<~Boolean> - Enables monitoring, defaults to
+        #     disabled
+        #   * 'RamdiskId'<~String> - Id of ramdisk with which to launch
+        #   * 'UserData'<~String> -  Additional data to provide to booting instances
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'groupSet'<~Array>: groups the instances are members in
+        #       * 'groupName'<~String> - Name of group
+        #     * 'instancesSet'<~Array>: returned instances
+        #       * instance<~Hash>:
+        #         * 'amiLaunchIndex'<~Integer> - reference to instance in launch group
+        #         * 'architecture'<~String> - architecture of image in [i386, x86_64]
+        #         * 'blockDeviceMapping'<~Array>
+        #           * 'attachTime'<~Time> - time of volume attachment
+        #           * 'deleteOnTermination'<~Boolean> - whether or not to delete volume on termination
+        #           * 'deviceName'<~String> - specifies how volume is exposed to instance
+        #           * 'status'<~String> - status of attached volume
+        #           * 'volumeId'<~String> - Id of attached volume
+        #         * 'dnsName'<~String> - public dns name, blank until instance is running
+        #         * 'imageId'<~String> - image id of ami used to launch instance
+        #         * 'instanceId'<~String> - id of the instance
+        #         * 'instanceState'<~Hash>:
+        #           * 'code'<~Integer> - current status code
+        #           * 'name'<~String> - current status name
+        #         * 'instanceType'<~String> - type of instance
+        #         * 'ipAddress'<~String> - public ip address assigned to instance
+        #         * 'kernelId'<~String> - Id of kernel used to launch instance
+        #         * 'keyName'<~String> - name of key used launch instances or blank
+        #         * 'launchTime'<~Time> - time instance was launched
+        #         * 'monitoring'<~Hash>:
+        #           * 'state'<~Boolean - state of monitoring
+        #         * 'placement'<~Hash>:
+        #           * 'availabilityZone'<~String> - Availability zone of the instance
+        #         * 'privateDnsName'<~String> - private dns name, blank until instance is running
+        #         * 'privateIpAddress'<~String> - private ip address assigned to instance
+        #         * 'productCodes'<~Array> - Product codes for the instance
+        #         * 'ramdiskId'<~String> - Id of ramdisk used to launch instance
+        #         * 'reason'<~String> - reason for most recent state transition, or blank
+        #         * 'rootDeviceName'<~String> - specifies how the root device is exposed to the instance
+        #         * 'rootDeviceType'<~String> - root device type used by AMI in [ebs, instance-store]
+        #     * 'ownerId'<~String> - Id of owner
+        #     * 'requestId'<~String> - Id of request
+        #     * 'reservationId'<~String> - Id of reservation
+        def run_instances(image_id, min_count, max_count, options = {})
+          if block_device_mapping = options.delete('BlockDeviceMapping')
+            block_device_mapping.each_with_index do |mapping, index|
+              for key, value in mapping
+                options.merge!({ format("BlockDeviceMapping.%d.#{key}", index) => value })
+              end
+            end
+          end
+          if security_groups = options.delete('SecurityGroup')
+            options.merge!(AWS.indexed_param('SecurityGroup', [*security_groups]))
+          end
+          if options['UserData']
+            options['UserData'] = Base64.encode64(options['UserData'])
+          end
+
+          idempotent = !(options['ClientToken'].nil? || options['ClientToken'].empty?)
+
+          request({
+            'Action'    => 'RunInstances',
+            'ImageId'   => image_id,
+            'MinCount'  => min_count,
+            'MaxCount'  => max_count,
+            :idempotent => idempotent,
+            :parser     => Fog::Parsers::AWS::Compute::RunInstances.new
+          }.merge!(options))
+        end
+
+      end
+
+      class Mock
+
+        def run_instances(image_id, min_count, max_count, options = {})
+          response = Excon::Response.new
+          response.status = 200
+
+          group_set = [ (options['GroupId'] || 'default') ]
+          instances_set = []
+          reservation_id = Fog::AWS::Mock.reservation_id
+
+          min_count.times do |i|
+            instance_id = Fog::AWS::Mock.instance_id
+            instance = {
+              'amiLaunchIndex'      => i,
+              'blockDeviceMapping'  => [],
+              'clientToken'         => options['clientToken'],
+              'dnsName'             => nil,
+              'imageId'             => image_id,
+              'instanceId'          => instance_id,
+              'instanceState'       => { 'code' => 0, 'name' => 'pending' },
+              'instanceType'        => options['InstanceType'] || 'm1.small',
+              'kernelId'            => options['KernelId'] || Fog::AWS::Mock.kernel_id,
+              # 'keyName'             => options['KeyName'],
+              'launchTime'          => Time.now,
+              'monitoring'          => { 'state' => options['Monitoring.Enabled'] || false },
+              'placement'           => { 'availabilityZone' => options['Placement.AvailabilityZone'] || Fog::AWS::Mock.availability_zone },
+              'privateDnsName'      => nil,
+              'productCodes'        => [],
+              'ramdiskId'           => options['RamdiskId'] || Fog::AWS::Mock.ramdisk_id,
+              'reason'              => nil,
+              'rootDeviceType'      => 'instance-store'
+            }
+            instances_set << instance
+            @data[:instances][instance_id] = instance.merge({
+              'architecture'        => 'i386',
+              'groupSet'            => group_set,
+              'ownerId'             => @owner_id,
+              'privateIpAddress'    => nil,
+              'reservationId'       => reservation_id,
+              'stateReason'         => {},
+              'tagSet'              => {}
+            })
+          end
+          response.body = {
+            'groupSet'      => group_set,
+            'instancesSet'  => instances_set,
+            'ownerId'       => @owner_id,
+            'requestId'     => Fog::AWS::Mock.request_id,
+            'reservationId' => reservation_id
+          }
+          response
+        end
+
+      end
+    end
+  end
+end

data/lib/bbcloud/vendor/fog-0.3.23/lib/fog/aws/requests/compute/start_instances.rb

@@ -0,0 +1,38 @@
+module Fog
+  module AWS
+    class Compute
+      class Real
+
+        require 'fog/aws/parsers/compute/start_stop_instances'
+
+        # Start specified instance
+        #
+        # ==== Parameters
+        # * instance_id<~Array> - Id of instance to start
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'requestId'<~String> - Id of request
+        #     * TODO: fill in the blanks
+        def start_instances(instance_id)
+          params = AWS.indexed_param('InstanceId', instance_id)
+          request({
+            'Action'    => 'StartInstances',
+            :idempotent => true,
+            :parser     => Fog::Parsers::AWS::Compute::StartStopInstances.new
+          }.merge!(params))
+        end
+
+      end
+
+      class Mock
+
+        def start_instances(instance_id)
+          Fog::Mock.not_implemented
+        end
+
+      end
+    end
+  end
+end

data/lib/bbcloud/vendor/fog-0.3.23/lib/fog/aws/requests/compute/stop_instances.rb

@@ -0,0 +1,38 @@
+module Fog
+  module AWS
+    class Compute
+      class Real
+
+        require 'fog/aws/parsers/compute/start_stop_instances'
+
+        # Stop specified instance
+        #
+        # ==== Parameters
+        # * instance_id<~Array> - Id of instance to start
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'requestId'<~String> - Id of request
+        #     * TODO: fill in the blanks
+        def stop_instances(instance_id)
+          params = AWS.indexed_param('InstanceId', instance_id)
+          request({
+            'Action'    => 'StopInstances',
+            :idempotent => true,
+            :parser     => Fog::Parsers::AWS::Compute::StartStopInstances.new
+          }.merge!(params))
+        end
+
+      end
+
+      class Mock
+
+        def stop_instances(instance_id)
+          Fog::Mock.not_implemented
+        end
+
+      end
+    end
+  end
+end

data/lib/bbcloud/vendor/fog-0.3.23/lib/fog/aws/requests/compute/terminate_instances.rb

@@ -0,0 +1,94 @@
+module Fog
+  module AWS
+    class Compute
+      class Real
+
+        require 'fog/aws/parsers/compute/terminate_instances'
+
+        # Terminate specified instances
+        #
+        # ==== Parameters
+        # * instance_id<~Array> - Ids of instances to terminates
+        #
+        # ==== Returns
+        # # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'requestId'<~String> - Id of request
+        #     * 'instancesSet'<~Array>:
+        #       * 'instanceId'<~String> - id of the terminated instance
+        #       * 'previousState'<~Hash>: previous state of instance
+        #         * 'code'<~Integer> - previous status code
+        #         * 'name'<~String> - name of previous state
+        #       * 'shutdownState'<~Hash>: shutdown state of instance
+        #         * 'code'<~Integer> - current status code
+        #         * 'name'<~String> - name of current state
+        def terminate_instances(instance_id)
+          params = AWS.indexed_param('InstanceId', instance_id)
+          request({
+            'Action'    => 'TerminateInstances',
+            :idempotent => true,
+            :parser     => Fog::Parsers::AWS::Compute::TerminateInstances.new
+          }.merge!(params))
+        end
+
+      end
+
+      class Mock
+
+        def terminate_instances(instance_id)
+          response = Excon::Response.new
+          instance_id = [*instance_id]
+          if (@data[:instances].keys & instance_id).length == instance_id.length
+            response.body = {
+              'requestId'     => Fog::AWS::Mock.request_id,
+              'instancesSet'  => []
+            }
+            response.status = 200
+            for id in instance_id
+              instance = @data[:instances][id]
+              @data[:deleted_at][id] = Time.now
+              code = case instance['instanceState']['name']
+              when 'pending'
+                0
+              when 'running'
+                16
+              when 'shutting-down'
+                32
+              when 'terminated'
+                48
+              when 'stopping'
+                64
+              when 'stopped'
+                80
+              end
+              state = { 'name' => 'shutting-down', 'code' => 32}
+              response.body['instancesSet'] << {
+                'instanceId'    => id,
+                'previousState' => instance['instanceState'],
+                'currentState'  => state
+              }
+              instance['instanceState'] = state
+            end
+
+            describe_addresses.body['addressesSet'].each do |address|
+              if instance_id.include?(address['instanceId'])
+                disassociate_address(address['publicIp'])
+              end
+            end
+
+            describe_volumes.body['volumeSet'].each do |volume|
+              if volume['attachmentSet'].first && instance_id.include?(volume['attachmentSet'].first['instanceId'])
+                detach_volume(volume['volumeId'])
+              end
+            end
+
+            response
+          else
+            raise Fog::AWS::Compute::NotFound.new("The instance ID '#{instance_id}' does not exist")
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/bbcloud/vendor/fog-0.3.23/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 = ELB.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/bbcloud/vendor/fog-0.3.23/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/bbcloud/vendor/fog-0.3.23/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/bbcloud/vendor/fog-0.3.23/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/bbcloud/vendor/fog-0.3.23/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/bbcloud/vendor/fog-0.3.23/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