fog 0.7.1 → 2.3.0

data/lib/fog/compute/models/aws/key_pair.rb

@@ -1,42 +0,0 @@
-require 'fog/core/model'
-
-module Fog
-  module AWS
-    class Compute
-
-      class KeyPair < Fog::Model
-
-        identity  :name,        :aliases => 'keyName'
-
-        attribute :fingerprint, :aliases => 'keyFingerprint'
-        attribute :private_key, :aliases => 'keyMaterial'
-
-        attr_accessor :public_key
-
-        def destroy
-          requires :name
-
-          connection.delete_key_pair(name)
-          true
-        end
-
-        def save
-          requires :name
-
-          data = if public_key
-            connection.import_key_pair(name, public_key).body
-          else
-            connection.create_key_pair(name).body
-          end
-          new_attributes = data.reject {|key,value| !['keyFingerprint', 'keyMaterial', 'keyName'].include?(key)}
-          merge_attributes(new_attributes)
-          true
-        end
-
-        private
-
-      end
-
-    end
-  end
-end

data/lib/fog/compute/models/aws/key_pairs.rb

@@ -1,88 +0,0 @@
-require 'fog/core/collection'
-require 'fog/compute/models/aws/key_pair'
-
-module Fog
-  module AWS
-    class Compute
-
-      class KeyPairs < Fog::Collection
-
-        attribute :filters
-        attribute :key_name
-
-        model Fog::AWS::Compute::KeyPair
-
-        # Used to create a key pair.  There are 3 arguments and only name is required.  You can generate a new key_pair as follows:
-        # AWS.key_pairs.create(:name => "test", :fingerprint => "123", :private_key => '234234')
-        #
-        # ==== Returns
-        #
-        #<Fog::AWS::Compute::KeyPair
-        #  name="test",
-        #  fingerprint="3a:d3:e5:17:e5:e7:f7:de:fe:db:1b:c2:55:7d:94:0b:07:2e:05:aa",
-        #  private_key="-----BEGIN RSA PRIVATE KEY-----\nf/VtfXJ/ekTSlRS2GSItBSzMrEGoZ+EXeMOuiA7HFkDcgKt6aBiOX9Bysiyfc1rIrgWdFKqXBRJA\nrtvBPa3/32koMPV4FxG7RZrPuKLITmFoEV86M0DSLo+ErlOPuDChfrR9dk6eI17/o1VmSvYsIpDc\njvbgx+tt7ZEPvduoUag7YdnUI0f20fttsdXjMlyDg9pPOVF3/hqucqOb3t5y9lvVJJxdTnEDFSjb\nvodpaDT9+ssw4IsQsZEIvfL0hK+Lt4phbclUWfG7JVnYfdd2u4zU6Nqe0+3qoR0ZOH4/zaUko7z8\n7JMbJqs5bmdWfnQTrvbJ13545FRI/W48ZRJxqPcj0t2MzasbT4gMgtNJrSadq78RkRJjNTu4lZmK\nvJejkBZPicHvo5IRSEbDc90Rhdh0aZNifXn0d0DSV2N6Ywo2o1lwRAi3/l6XSjukyRpTPcMr14MP\ntGwS1Tvez41Oa7Y96VfsJB2xtKc6LGRFiPUg2ZAEHU15Q9bIISVzHXgdAcef1bsh8UN/fDBrTusm\nvJisQ+dLaPH7cZ03od+XTwJc+IyeL4RqWuASE0NNfEVJMS+qcpt0WeNzfG0C27SwIcfEKL0sC0kn\nCfX2WpZDg7T5xN+88ftKJaN9tymxTgvoJVS1/WKvWBAXVozKp4f6K8wKmwf7VdUt/FWbUi54LW02\nf1ONkaYEOVwDgWlGxVSx43MWqvVdT2MPFNEBL7OA1LPwCO2nyQQ9UM9gCE65S9Najf939Bq8xwqx\nGNFlLmaH6biZUyL8ewRJ8Y7rMQ5cXy/gHZywjkuoyLQ8vVpmVpb7r1FaM/AYSr5l6gJEWdqbJleN\ntnhjPeE6qXISzIUBvwKzzgFTyW8ZHQtgbP3bHEiPG2/OjKHnLUoOId/eetcE+ovIxWsBrTDbf2SV\nYUD91u+W9K35eX89ZaIiohLNg4z9+QHCs4rcWyOXEfprBKcP2QU5+Y9ysnXLAmZt6QhInaAsUpQZ\nyhImA24UqvqrK0yyGhf/quouK7q0QkVQR+f7nGClIaphJkxO/xylrnK/pYObr4s3B8kmksuHiYOu\n1yz6SeRkj8F9dxkRmzbBK/G0tLkxIElDbM7icI9gsEO7vvgaR/K8hSDi0RkFPG43I20tU8PqwHe7\nR4jFW+6sB2+9FDeLn+qkoDSaxzmAuIRW082z/r7rJVIpFEo14hNhQYkNXpH40+P/hA9RFgvhZe8M\nvK4rz/eu246Kij6kObieTfpZhgGHqvtU8x5cnqEZOz5Hc5m4B+gMaTA53kFSPOA0pn6gqgiuYEdI\nZUhO8P1PkNqkmLz7NJRnz3qpAo6RisAxPBVr2WdSg4bP0YpGS/0TE4OOJwGLldx6dCsX60++mn0q\n1fhNw8oyZiguYMAeEEDWP8x/bsRaFz5L8uQVnnnj8ei1oTmZ+Uw9/48snWYcurL2jsbuWhhE0NTt\nfe/cqov7ZaZHs+Tr20ZBEDEqUEWr/MMskj/ZSVxnza1G/hztFJMAThF9ZJoGQkHWHfXCGOLLGY+z\nqi0SC8EIeu8PUxjO2SRj9S9o/Dwg3iHyM3pj57kD7fDNnl3Ed6LMoCXoaQV8BdMX4xh=\n-----END RSA PRIVATE KEY-----"
-        #>
-        #
-        # The key_pair can be retreived by running AWS.key_pairs.get("test").  See get method below.
-        #
-
-        def initialize(attributes)
-          self.filters ||= {}
-          super
-        end
-
-        # Returns an array of all key pairs that have been created
-        #
-        # AWS.key_pairs.all
-        #
-        # ==== Returns
-        #
-        # <Fog::AWS::Compute::KeyPairs
-        #  key_name=nil
-        #  [
-        #    <Fog::AWS::Compute::KeyPair
-        #      name="test",
-        #      fingerprint="1f:26:3d:83:e7:4f:48:74:c3:1c:e6:b3:c7:f6:ec:d8:cb:09:b3:7f",
-        #      private_key=nil
-        #    >
-        #  ]
-        #>
-        #
-
-        def all(filters = filters)
-          unless filters.is_a?(Hash)
-            Formatador.display_line("[yellow][WARN] all with #{filters.class} param is deprecated, use all('key-name' => []) instead[/] [light_black](#{caller.first})[/]")
-            filters = {'key-name' => [*filters]}
-          end
-          self.filters = filters
-          data = connection.describe_key_pairs(filters).body
-          load(data['keySet'])
-        end
-
-        # Used to retreive a key pair that was created with the AWS.key_pairs.create method.
-        # The name is required to get the associated key_pair information.
-        #
-        # You can run the following command to get the details:
-        # AWS.key_pairs.get("test")
-        #
-        # ==== Returns
-        #
-        #>> AWS.key_pairs.get("test")
-        #  <Fog::AWS::Compute::KeyPair
-        #    name="test",
-        #    fingerprint="1f:26:3d:83:e7:4f:48:74:c3:1c:e6:b3:c7:f6:ec:d8:cb:09:b3:7f",
-        #    private_key=nil
-        #  >
-        #
-
-        def get(key_name)
-          if key_name
-            self.class.new(:connection => connection).all('key-name' => key_name).first
-          end
-        end
-
-      end
-
-    end
-  end
-end

data/lib/fog/compute/models/aws/security_group.rb

@@ -1,205 +0,0 @@
-require 'fog/core/model'
-
-module Fog
-  module AWS
-    class Compute
-
-      class SecurityGroup < Fog::Model
-
-        identity  :name,            :aliases => 'groupName'
-
-        attribute :description,     :aliases => 'groupDescription'
-        attribute :ip_permissions,  :aliases => 'ipPermissions'
-        attribute :owner_id,        :aliases => 'ownerId'
-
-        # Authorize access by another security group
-        #
-        #  >> g = AWS.security_groups.all(:description => "something").first
-        #  >> g.authorize_group_and_owner("some_group_name", "1234567890")
-        #
-        # == Parameters:
-        # group::
-        #   The name of the security group you're granting access to.
-        #
-        # owner::
-        #   The owner id for security group you're granting access to.
-        #
-        # == Returns:
-        #
-        # An excon response object representing the result
-        #
-        #  <Excon::Response:0x101fc2ae0
-        #    @status=200,
-        #    @body={"requestId"=>"some-id-string",
-        #           "return"=>true},
-        #    headers{"Transfer-Encoding"=>"chunked",
-        #            "Date"=>"Mon, 27 Dec 2010 22:12:57 GMT",
-        #            "Content-Type"=>"text/xml;charset=UTF-8",
-        #            "Server"=>"AmazonEC2"}
-        #
-
-        def authorize_group_and_owner(group, owner)
-          requires :name
-
-          connection.authorize_security_group_ingress(
-            name,
-            'SourceSecurityGroupName'     => group,
-            'SourceSecurityGroupOwnerId'  => owner
-          )
-        end
-
-        # Authorize a new port range for a security group
-        #
-        #  >> g = AWS.security_groups.all(:description => "something").first
-        #  >> g.authorize_port_range(20..21)
-        #
-        # == Parameters:
-        # range::
-        #   A Range object representing the port range you want to open up. E.g., 20..21
-        #
-        # options::
-        #   A hash that can contain any of the following keys:
-        #    :cidr_ip (defaults to "0.0.0.0/0")
-        #    :ip_protocol (defaults to "tcp")
-        #
-        # == Returns:
-        #
-        # An excon response object representing the result
-        #
-        #  <Excon::Response:0x101fc2ae0
-        #    @status=200,
-        #    @body={"requestId"=>"some-id-string",
-        #           "return"=>true},
-        #    headers{"Transfer-Encoding"=>"chunked",
-        #            "Date"=>"Mon, 27 Dec 2010 22:12:57 GMT",
-        #            "Content-Type"=>"text/xml;charset=UTF-8",
-        #            "Server"=>"AmazonEC2"}
-        #
-
-        def authorize_port_range(range, options = {})
-          requires :name
-
-          connection.authorize_security_group_ingress(
-            name,
-            'CidrIp'      => options[:cidr_ip] || '0.0.0.0/0',
-            'FromPort'    => range.min,
-            'ToPort'      => range.max,
-            'IpProtocol'  => options[:ip_protocol] || 'tcp'
-          )
-        end
-
-        # Removes an existing security group
-        #
-        # security_group.destroy
-        #
-        # ==== Returns
-        #
-        # True or false depending on the result
-        #
-
-        def destroy
-          requires :name
-
-          connection.delete_security_group(name)
-          true
-        end
-
-        # Revoke access by another security group
-        #
-        #  >> g = AWS.security_groups.all(:description => "something").first
-        #  >> g.revoke_group_and_owner("some_group_name", "1234567890")
-        #
-        # == Parameters:
-        # group::
-        #   The name of the security group you're revoking access to.
-        #
-        # owner::
-        #   The owner id for security group you're revoking access access to.
-        #
-        # == Returns:
-        #
-        # An excon response object representing the result
-        #
-        #  <Excon::Response:0x101fc2ae0
-        #    @status=200,
-        #    @body={"requestId"=>"some-id-string",
-        #           "return"=>true},
-        #    headers{"Transfer-Encoding"=>"chunked",
-        #            "Date"=>"Mon, 27 Dec 2010 22:12:57 GMT",
-        #            "Content-Type"=>"text/xml;charset=UTF-8",
-        #            "Server"=>"AmazonEC2"}
-        #
-
-        def revoke_group_and_owner(group, owner)
-          requires :name
-
-          connection.revoke_security_group_ingress(
-            name,
-            'SourceSecurityGroupName'     => group,
-            'SourceSecurityGroupOwnerId'  => owner
-          )
-        end
-
-        # Revoke an existing port range for a security group
-        #
-        #  >> g = AWS.security_groups.all(:description => "something").first
-        #  >> g.revoke_port_range(20..21)
-        #
-        # == Parameters:
-        # range::
-        #   A Range object representing the port range you want to open up. E.g., 20..21
-        #
-        # options::
-        #   A hash that can contain any of the following keys:
-        #    :cidr_ip (defaults to "0.0.0.0/0")
-        #    :ip_protocol (defaults to "tcp")
-        #
-        # == Returns:
-        #
-        # An excon response object representing the result
-        #
-        #  <Excon::Response:0x101fc2ae0
-        #    @status=200,
-        #    @body={"requestId"=>"some-id-string",
-        #           "return"=>true},
-        #    headers{"Transfer-Encoding"=>"chunked",
-        #            "Date"=>"Mon, 27 Dec 2010 22:12:57 GMT",
-        #            "Content-Type"=>"text/xml;charset=UTF-8",
-        #            "Server"=>"AmazonEC2"}
-        #
-
-        def revoke_port_range(range, options = {})
-          requires :name
-
-          connection.revoke_security_group_ingress(
-            name,
-            'CidrIp'      => options[:cidr_ip] || '0.0.0.0/0',
-            'FromPort'    => range.min,
-            'ToPort'      => range.max,
-            'IpProtocol'  => options[:ip_protocol] || 'tcp'
-          )
-        end
-
-        # Create a security group
-        #
-        #  >> g = AWS.security_groups.new(:name => "some_name", :description => "something")
-        #  >> g.save
-        #
-        # == Returns:
-        #
-        # True or an exception depending on the result. Keep in mind that this *creates* a new security group.
-        # As such, it yields an InvalidGroup.Duplicate exception if you attempt to save an existing group.
-        #
-
-        def save
-          requires :description, :name
-
-          data = connection.create_security_group(name, description).body
-          true
-        end
-
-      end
-
-    end
-  end
-end

data/lib/fog/compute/models/aws/security_groups.rb

@@ -1,95 +0,0 @@
-require 'fog/core/collection'
-require 'fog/compute/models/aws/security_group'
-
-module Fog
-  module AWS
-    class Compute
-
-      class SecurityGroups < Fog::Collection
-
-        attribute :filters
-
-        model Fog::AWS::Compute::SecurityGroup
-
-        # Creates a new security group
-        #
-        # AWS.security_groups.new
-        #
-        # ==== Returns
-        #
-        # Returns the details of the new image
-        #
-        #>> AWS.security_groups.new
-        #  <Fog::AWS::Compute::SecurityGroup
-        #    name=nil,
-        #    description=nil,
-        #    ip_permissions=nil,
-        #    owner_id=nil
-        #  >
-        #
-        
-        def initialize(attributes)
-          self.filters ||= {}
-          super
-        end
-        
-        # Returns an array of all security groups that have been created
-        #
-        # AWS.security_groups.all
-        #
-        # ==== Returns
-        #
-        # Returns an array of all security groups
-        #
-        #>> AWS.security_groups.all
-        #  <Fog::AWS::Compute::SecurityGroups
-        #    filters={}
-        #    [
-        #      <Fog::AWS::Compute::SecurityGroup
-        #        name="default",
-        #        description="default group",
-        #        ip_permissions=[{"groups"=>[{"groupName"=>"default", "userId"=>"312571045469"}], "fromPort"=>-1, "toPort"=>-1, "ipRanges"=>[], "ipProtocol"=>"icmp"}, {"groups"=>[{"groupName"=>"default", "userId"=>"312571045469"}], "fromPort"=>0, "toPort"=>65535, "ipRanges"=>[], "ipProtocol"=>"tcp"}, {"groups"=>[{"groupName"=>"default", "userId"=>"312571045469"}], "fromPort"=>0, "toPort"=>65535, "ipRanges"=>[], "ipProtocol"=>"udp"}],
-        #        owner_id="312571045469"
-        #      >
-        #    ]
-        #  >
-        #
-
-        def all(filters = filters)
-          unless filters.is_a?(Hash)
-            Formatador.display_line("[yellow][WARN] all with #{filters.class} param is deprecated, use all('group-name' => []) instead[/] [light_black](#{caller.first})[/]")
-            filters = {'group-name' => [*filters]}
-          end
-          self.filters = filters
-          data = connection.describe_security_groups(filters).body
-          load(data['securityGroupInfo'])
-        end
-
-        # Used to retreive a security group
-        # group name is required to get the associated flavor information.
-        #
-        # You can run the following command to get the details:
-        # AWS.security_groups.get("default")
-        #
-        # ==== Returns
-        #
-        #>> AWS.security_groups.get("default")
-        #  <Fog::AWS::Compute::SecurityGroup
-        #    name="default",
-        #    description="default group",
-        #    ip_permissions=[{"groups"=>[{"groupName"=>"default", "userId"=>"312571045469"}], "fromPort"=>-1, "toPort"=>-1, "ipRanges"=>[], "ipProtocol"=>"icmp"}, {"groups"=>[{"groupName"=>"default", "userId"=>"312571045469"}], "fromPort"=>0, "toPort"=>65535, "ipRanges"=>[], "ipProtocol"=>"tcp"}, {"groups"=>[{"groupName"=>"default", "userId"=>"312571045469"}], "fromPort"=>0, "toPort"=>65535, "ipRanges"=>[], "ipProtocol"=>"udp"}],
-        #    owner_id="312571045469"
-        #  > 
-        #
-        
-        def get(group_name)
-          if group_name
-            self.class.new(:connection => connection).all('group-name' => group_name).first
-          end
-        end
-
-      end
-
-    end
-  end
-end

data/lib/fog/compute/models/aws/server.rb

@@ -1,245 +0,0 @@
-require 'fog/core/model'
-
-module Fog
-  module AWS
-    class Compute
-
-      class Server < Fog::Model
-        extend Fog::Deprecation
-        deprecate :ip_address, :public_ip_address
-
-        identity  :id,                    :aliases => 'instanceId'
-
-        attr_accessor :architecture
-        attribute :ami_launch_index,      :aliases => 'amiLaunchIndex'
-        attribute :availability_zone,     :aliases => ['availabilityZone', 'placement'], :squash => 'availabilityZone'
-        attribute :block_device_mapping,  :aliases => 'blockDeviceMapping'
-        attribute :client_token,          :aliases => 'clientToken'
-        attribute :dns_name,              :aliases => 'dnsName'
-        attribute :groups
-        attribute :flavor_id,             :aliases => 'instanceType'
-        attribute :image_id,              :aliases => 'imageId'
-        attr_accessor :instance_initiated_shutdown_behavior
-        attribute :kernel_id,             :aliases => 'kernelId'
-        attribute :key_name,              :aliases => 'keyName'
-        attribute :created_at,            :aliases => 'launchTime'
-        attribute :monitoring,            :squash => 'state'
-        attribute :product_codes,         :aliases => 'productCodes'
-        attribute :private_dns_name,      :aliases => 'privateDnsName'
-        attribute :private_ip_address,    :aliases => 'privateIpAddress'
-        attribute :public_ip_address,     :aliases => 'ipAddress'
-        attribute :ramdisk_id,            :aliases => 'ramdiskId'
-        attribute :reason
-        attribute :root_device_name,      :aliases => 'rootDeviceName'
-        attribute :root_device_type,      :aliases => 'rootDeviceType'
-        attribute :state,                 :aliases => 'instanceState', :squash => 'name'
-        attribute :state_reason,          :aliases => 'stateReason'
-        attribute :subnet_id,             :aliases => 'subnetId'
-        attribute :tags,                  :aliases => 'tagSet'
-        attribute :user_data
-
-        attr_accessor :password
-        attr_writer   :private_key, :private_key_path, :public_key, :public_key_path, :username
-
-        def initialize(attributes={})
-          self.groups ||= ["default"] unless attributes[:subnet_id]
-          self.flavor_id ||= 'm1.small'
-          super
-        end
-
-        def addresses
-          requires :id
-
-          connection.addresses(:server => self)
-        end
-
-        def console_output
-          requires :id
-
-          connection.get_console_output(id)
-        end
-
-        def destroy
-          requires :id
-
-          connection.terminate_instances(id)
-          true
-        end
-
-        remove_method :flavor_id
-        def flavor_id
-          @flavor && @flavor.id || attributes[:flavor_id]
-        end
-
-        def flavor=(new_flavor)
-          @flavor = new_flavor
-        end
-
-        def flavor
-          @flavor ||= connection.flavors.all.detect {|flavor| flavor.id == flavor_id}
-        end
-
-        def key_pair
-          requires :key_name
-
-          connection.keypairs.all(key_name).first
-        end
-
-        def key_pair=(new_keypair)
-          self.key_name = new_keypair && new_keypair.name
-        end
-
-        def private_key_path
-          @private_key_path ||= Fog.credentials[:private_key_path]
-          @private_key_path &&= File.expand_path(@private_key_path)
-        end
-
-        def private_key
-          @private_key ||= private_key_path && File.read(private_key_path)
-        end
-
-        def public_key_path
-          @public_key_path ||= Fog.credentials[:public_key_path]
-          @public_key_path &&= File.expand_path(@public_key_path)
-        end
-
-        def public_key
-          @public_key ||= public_key_path && File.read(public_key_path)
-        end
-
-        def ready?
-          state == 'running'
-        end
-
-        def reboot
-          requires :id
-          connection.reboot_instances(id)
-          true
-        end
-
-        def save
-          raise Fog::Errors::Error.new('Resaving an existing object may create a duplicate') if identity
-          requires :image_id
-
-          options = {
-            'BlockDeviceMapping'          => block_device_mapping,
-            'ClientToken'                 => client_token,
-            'InstanceInitiatedShutdownBehavior' => instance_initiated_shutdown_behavior,
-            'InstanceType'                => flavor_id,
-            'KernelId'                    => kernel_id,
-            'KeyName'                     => key_name,
-            'Monitoring.Enabled'          => monitoring,
-            'Placement.AvailabilityZone'  => availability_zone,
-            'RamdiskId'                   => ramdisk_id,
-            'SecurityGroup'               => groups,
-            'SubnetId'                    => subnet_id,
-            'UserData'                    => user_data
-          }
-          options.delete_if {|key, value| value.nil?}
-
-          # If subnet is defined we are working on a virtual private cloud.
-          # subnet & security group cannot co-exist. I wish VPC just ignored
-          # the security group parameter instead, it would be much easier!
-          if subnet_id
-            options.delete('SecurityGroup')
-          else
-            options.delete('SubnetId')
-          end
-
-          data = connection.run_instances(image_id, 1, 1, options)
-          merge_attributes(data.body['instancesSet'].first)
-          true
-        end
-
-        def setup(credentials = {})
-          requires :identity, :ip_address, :username
-          require 'json'
-
-          commands = [
-            %{mkdir .ssh},
-            %{passwd -l #{username}},
-            %{echo "#{attributes.to_json}" >> ~/attributes.json}
-          ]
-          if public_key
-            commands << %{echo "#{public_key}" >> ~/.ssh/authorized_keys}
-          end
-          # allow some retries over the first 120 seconds because aws is weird
-          Timeout::timeout(120) do
-            begin
-              Timeout::timeout(4) do
-                Fog::SSH.new(ip_address, username, credentials).run(commands)
-              end
-            rescue Net::SSH::AuthenticationFailed, Timeout::Error
-              retry
-            end
-          end
-        rescue Errno::ECONNREFUSED => e
-          sleep(1)
-          retry
-        end
-
-        def ssh(commands)
-          requires :identity, :public_ip_address, :username
-
-          options = {}
-          options[:key_data] = [private_key] if private_key
-          Fog::SSH.new(public_ip_address, username, options).run(commands)
-        end
-
-        def scp(local_path, remote_path)
-          requires :public_ip_address, :username
-
-          options = {}
-          options[:key_data] = [private_key] if private_key
-          Fog::SCP.new(public_ip_address, username, options).upload(local_path, remote_path)
-        end
-
-        def start
-          requires :id
-          connection.start_instances(id)
-          true
-        end
-
-        def stop
-          requires :id
-          connection.stop_instances(id)
-          true
-        end
-
-        def username
-          @username ||= 'root'
-        end
-
-        def volumes
-          requires :id
-          connection.volumes(:server => self)
-        end
-
-        #I tried to call it monitoring= and be smart with attributes[]
-        #but in #save a merge_attribute is called after run_instance
-        #thus making an un-necessary request. Use this until finding a clever solution
-        def monitor=(boolean)
-
-          #we don't have a server yet. the status silently goes in the attributes for run_instances
-          if !identity
-            self.monitoring=boolean
-          end
-
-          case boolean
-            when true
-              response = connection.monitor_instances(identity)
-            when false
-              response = connection.unmonitor_instances(identity)
-            else
-              raise ArgumentError.new("only Boolean allowed here")
-          end
-
-          #set the attribute, there is only one instance_id here
-          response.body['instancesSet'][0]['monitoring'] == 'enabled' ? self.monitoring=true : self.monitoring=false
-        end
-
-      end
-
-    end
-  end
-end