fog 0.11.0 → 1.0.0

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

@@ -1,158 +0,0 @@
-require 'fog/core/collection'
-require 'fog/compute/models/aws/server'
-
-module Fog
-  module Compute
-    class AWS
-
-      class Servers < Fog::Collection
-
-        attribute :filters
-
-        model Fog::Compute::AWS::Server
-
-        # Creates a new server
-        #
-        # AWS.servers.new
-        #
-        # ==== Returns
-        #
-        # Returns the details of the new server
-        #
-        #>> AWS.servers.new
-        #  <Fog::AWS::Compute::Server
-        #    id=nil,
-        #    ami_launch_index=nil,
-        #    availability_zone=nil,
-        #    block_device_mapping=nil,
-        #    client_token=nil,
-        #    dns_name=nil,
-        #    groups=["default"],
-        #    flavor_id="m1.small",
-        #    image_id=nil,
-        #    ip_address=nil,
-        #    kernel_id=nil,
-        #    key_name=nil,
-        #    created_at=nil,
-        #    monitoring=nil,
-        #    product_codes=nil,
-        #    private_dns_name=nil,
-        #    private_ip_address=nil,
-        #    ramdisk_id=nil,
-        #    reason=nil,
-        #    root_device_name=nil,
-        #    root_device_type=nil,
-        #    state=nil,
-        #    state_reason=nil,
-        #    subnet_id=nil,
-        #    tags=nil,
-        #    user_data=nil
-        #  >
-        #
-        
-        def initialize(attributes)
-          self.filters ||= {}
-          super
-        end
-
-        def all(filters = self.filters)
-          unless filters.is_a?(Hash)
-            Formatador.display_line("[yellow][WARN] all with #{filters.class} param is deprecated, use all('instance-id' => []) instead[/] [light_black](#{caller.first})[/]")
-            filters = {'instance-id' => [*filters]}
-          end
-          self.filters = filters
-          data = connection.describe_instances(filters).body
-          load(
-            data['reservationSet'].map do |reservation|
-              reservation['instancesSet'].map do |instance|
-                instance.merge(:groups => reservation['groupSet'])
-              end
-            end.flatten
-          )
-        end
-
-        def bootstrap(new_attributes = {})
-          server = connection.servers.new(new_attributes)
-
-          unless new_attributes[:key_name]
-            # first or create fog_#{credential} keypair
-            name = Fog.respond_to?(:credential) && Fog.credential || :default
-            unless server.key_pair = connection.key_pairs.get("fog_#{name}")
-              server.key_pair = connection.key_pairs.create(
-                :name => "fog_#{name}",
-                :public_key => server.public_key
-              )
-            end
-          end
-
-          # make sure port 22 is open in the first security group
-          security_group = connection.security_groups.get(server.groups.first)
-          authorized = security_group.ip_permissions.detect do |ip_permission|
-            ip_permission['ipRanges'].first && ip_permission['ipRanges'].first['cidrIp'] == '0.0.0.0/0' &&
-            ip_permission['fromPort'] == 22 &&
-            ip_permission['ipProtocol'] == 'tcp' &&
-            ip_permission['toPort'] == 22
-          end
-          unless authorized
-            security_group.authorize_port_range(22..22)
-          end
-
-          server.save
-          server.wait_for { ready? }
-          server.setup(:key_data => [server.private_key])
-          server
-        end
-
-        # Used to retreive a server
-        #
-        # server_id is required to get the associated server information.
-        #
-        # You can run the following command to get the details:
-        # AWS.servers.get("i-5c973972")
-        #
-        # ==== Returns
-        #
-        #>> AWS.servers.get("i-5c973972")
-        #  <Fog::AWS::Compute::Server
-        #    id="i-5c973972",
-        #    ami_launch_index=0,
-        #    availability_zone="us-east-1b",
-        #    block_device_mapping=[],
-        #    client_token=nil,
-        #    dns_name="ec2-25-2-474-44.compute-1.amazonaws.com",
-        #    groups=["default"],
-        #    flavor_id="m1.small",
-        #    image_id="test",
-        #    ip_address="25.2.474.44",
-        #    kernel_id="aki-4e1e1da7",
-        #    key_name=nil,
-        #    created_at=Mon Nov 29 18:09:34 -0500 2010,
-        #    monitoring=false,
-        #    product_codes=[],
-        #    private_dns_name="ip-19-76-384-60.ec2.internal",
-        #    private_ip_address="19.76.384.60",
-        #    ramdisk_id="ari-0b3fff5c",
-        #    reason=nil,
-        #    root_device_name=nil,
-        #    root_device_type="instance-store",
-        #    state="running",
-        #    state_reason={},
-        #    subnet_id=nil,
-        #    tags={},
-        #    user_data=nil
-        #  >
-        #
-        
-        def get(server_id)
-          if server_id
-            self.class.new(:connection => connection).all('instance-id' => server_id).first
-          end
-        rescue Fog::Errors::NotFound
-          nil
-        end
-
-      end
-
-    end
-  end
-end

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

@@ -1,52 +0,0 @@
-require 'fog/core/collection'
-require 'fog/compute/models/aws/snapshot'
-
-module Fog
-  module Compute
-    class AWS
-
-      class Snapshots < Fog::Collection
-
-        attribute :filters
-        attribute :volume
-
-        model Fog::Compute::AWS::Snapshot
-
-        def initialize(attributes)
-          self.filters ||= { 'RestorableBy' => 'self' }
-          super
-        end
-
-        def all(filters = filters, options = {})
-          unless filters.is_a?(Hash)
-            Formatador.display_line("[yellow][WARN] all with #{filters.class} param is deprecated, use all('snapshot-id' => []) instead[/] [light_black](#{caller.first})[/]")
-            filters = {'snapshot-id' => [*filters]}
-          end
-          self.filters = filters
-          data = connection.describe_snapshots(filters.merge!(options)).body
-          load(data['snapshotSet'])
-          if volume
-            self.replace(self.select {|snapshot| snapshot.volume_id == volume.id})
-          end
-          self
-        end
-        
-        def get(snapshot_id)
-          if snapshot_id
-            self.class.new(:connection => connection).all('snapshot-id' => snapshot_id).first
-          end
-        end
-
-        def new(attributes = {})
-          if volume
-            super({ 'volumeId' => volume.id }.merge!(attributes))
-          else
-            super
-          end
-        end
-
-      end
-
-    end
-  end
-end

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

@@ -1,48 +0,0 @@
-require 'fog/core/collection'
-require 'fog/compute/models/aws/spot_request'
-
-module Fog
-  module Compute
-    class AWS
-      class SpotRequests < Fog::Collection
-      
-        attribute :filters
-        
-        model Fog::Compute::AWS::SpotRequest
-
-        def initialize(attributes)
-          self.filters ||= {}
-          super
-        end
-
-        def all(filters = self.filters)
-          unless filters.is_a?(Hash)
-            Formatador.display_line("[yellow][WARN] all with #{filters.class} param is deprecated, use all('spot-instance-request-id' => []) instead[/] [light_black](#{caller.first})[/]")
-            filters = {'spot-instance-request-id' => [*filters]}
-          end
-          self.filters = filters
-          data = connection.describe_spot_instance_requests(filters).body
-          load(
-            data['spotInstanceRequestSet'].map do |spot_instance_request|
-              spot_instance_request['LaunchSpecification.Placement.AvailabilityZone'] = spot_instance_request['launchedAvailabilityZone']
-              spot_instance_request['launchSpecification'].each do |name,value|
-                spot_instance_request['LaunchSpecification.' + name[0,1].upcase + name[1..-1]] = value
-              end
-              spot_instance_request.merge(:groups => spot_instance_request['LaunchSpecification.GroupSet'])
-              spot_instance_request 
-            end.flatten
-          )
-        end
-
-        def get(spot_request_id)
-          if spot_request_id
-            self.class.new(:connection => connection).all('spot-instance-request-id' => spot_request_id).first
-          end
-        rescue Fog::Errors::NotFound
-          nil
-        end
-
-      end
-    end
-  end
-end

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

@@ -1,34 +0,0 @@
-require 'fog/core/collection'
-require 'fog/compute/models/aws/tag'
-
-module Fog
-  module Compute
-    class AWS
-
-      class Tags < Fog::Collection
-
-        attribute :filters
-
-        model Fog::Compute::AWS::Tag
-
-        def initialize(attributes)
-          self.filters ||= {}
-          super
-        end
-
-        def all(filters = filters)
-          self.filters = filters
-          data = connection.describe_tags(filters).body
-          load(data['tagSet'])
-        end
-        
-        def get(key)
-          if key
-            self.class.new(:connection => connection).all('key' => key)
-          end
-        end
-      end
-
-    end
-  end
-end

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

@@ -1,107 +0,0 @@
-require 'fog/core/model'
-
-module Fog
-  module Compute
-    class AWS
-
-      class Volume < Fog::Model
-
-        identity  :id,                    :aliases => 'volumeId'
-
-        attribute :attached_at,           :aliases => 'attachTime'
-        attribute :availability_zone,     :aliases => 'availabilityZone'
-        attribute :created_at,            :aliases => 'createTime'
-        attribute :delete_on_termination, :aliases => 'deleteOnTermination'
-        attribute :device
-        attribute :server_id,             :aliases => 'instanceId'
-        attribute :size
-        attribute :snapshot_id,           :aliases => 'snapshotId'
-        attribute :state,                 :aliases => 'status'
-        attribute :tags,                  :aliases => 'tagSet'
-
-        def initialize(attributes = {})
-          # assign server first to prevent race condition with new_record?
-          self.server = attributes.delete(:server)
-          super
-        end
-
-        def destroy
-          requires :id
-
-          connection.delete_volume(id)
-          true
-        end
-
-        def ready?
-          state == 'available'
-        end
-
-        def save
-          raise Fog::Errors::Error.new('Resaving an existing object may create a duplicate') if identity
-          requires :availability_zone
-          requires_one :size, :snapshot_id
-
-          data = connection.create_volume(availability_zone, size, snapshot_id).body
-          new_attributes = data.reject {|key,value| key == 'requestId'}
-          merge_attributes(new_attributes)
-          if @server
-            self.server = @server
-          end
-          true
-        end
-
-        def server
-          requires :server_id
-          connection.servers('instance-id' => server_id)
-        end
-
-        def server=(new_server)
-          if new_server
-            attach(new_server)
-          else
-            detach
-          end
-        end
-
-        def snapshots
-          requires :id
-          connection.snapshots(:volume => self)
-        end
-
-        def force_detach
-          detach(true)
-        end
-
-        private
-
-        def attachmentSet=(new_attachment_set)
-          merge_attributes(new_attachment_set.first || {})
-        end
-
-        def attach(new_server)
-          if new_record?
-            @server = new_server
-            self.availability_zone = new_server.availability_zone
-          elsif new_server
-            requires :device
-            @server = nil
-            self.server_id = new_server.id
-            connection.attach_volume(server_id, id, device)
-            reload
-          end
-        end
-
-        def detach(force = false)
-          @server = nil
-          self.server_id = nil
-          unless new_record?
-            connection.detach_volume(id, 'Force' => force)
-            reload
-          end
-        end
-
-      end
-
-    end
-  end
-end

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

@@ -1,121 +0,0 @@
-require 'fog/core/collection'
-require 'fog/compute/models/aws/volume'
-
-module Fog
-  module Compute
-    class AWS
-
-      class Volumes < Fog::Collection
-
-        attribute :filters
-        attribute :server
-
-        model Fog::Compute::AWS::Volume
-
-        # Used to create a volume.  There are 3 arguments and availability_zone and size are required.  You can generate a new key_pair as follows:
-        # AWS.volumes.create(:availability_zone => 'us-east-1a', :size => 10)
-        #
-        # ==== Returns
-        #
-        #<Fog::AWS::Compute::Volume
-        #  id="vol-1e2028b9",
-        #  attached_at=nil,
-        #  availability_zone="us-east-1a",
-        #  created_at=Tue Nov 23 23:30:29 -0500 2010,
-        #  delete_on_termination=nil,
-        #  device=nil,
-        #  server_id=nil,
-        #  size=10,
-        #  snapshot_id=nil,
-        #  state="creating",
-        #  tags=nil
-        #>
-        #
-        # The volume can be retreived by running AWS.volumes.get("vol-1e2028b9").  See get method below.
-        #
-
-        def initialize(attributes)
-          self.filters ||= {}
-          super
-        end
-
-        # Used to return all volumes.
-        # AWS.volumes.all
-        #
-        # ==== Returns
-        #
-        #>>AWS.volumes.all
-        #<Fog::AWS::Compute::Volume
-        #  id="vol-1e2028b9",
-        #  attached_at=nil,
-        #  availability_zone="us-east-1a",
-        #  created_at=Tue Nov 23 23:30:29 -0500 2010,
-        #  delete_on_termination=nil,
-        #  device=nil,
-        #  server_id=nil,
-        #  size=10,
-        #  snapshot_id=nil,
-        #  state="creating",
-        #  tags=nil
-        #>
-        #
-        # The volume can be retreived by running AWS.volumes.get("vol-1e2028b9").  See get method below.
-        #
-
-        def all(filters = filters)
-          unless filters.is_a?(Hash)
-            Formatador.display_line("[yellow][WARN] all with #{filters.class} param is deprecated, use all('volume-id' => []) instead[/] [light_black](#{caller.first})[/]")
-            filters = {'volume-id' => [*filters]}
-          end
-          self.filters = filters
-          data = connection.describe_volumes(filters).body
-          load(data['volumeSet'])
-          if server
-            self.replace(self.select {|volume| volume.server_id == server.id})
-          end
-          self
-        end
-
-        # Used to retreive a volume
-        # volume_id is required to get the associated volume information.
-        #
-        # You can run the following command to get the details:
-        # AWS.volumes.get("vol-1e2028b9")
-        #
-        # ==== Returns
-        #
-        #>> AWS.volumes.get("vol-1e2028b9")
-        # <Fog::AWS::Compute::Volume
-        #    id="vol-1e2028b9",
-        #    attached_at=nil,
-        #    availability_zone="us-east-1a",
-        #    created_at=Tue Nov 23 23:30:29 -0500 2010,
-        #    delete_on_termination=nil,
-        #    device=nil,
-        #    server_id=nil,
-        #    size=10,
-        #    snapshot_id=nil,
-        #    state="available",
-        #    tags={}
-        #  >
-        #
-
-        def get(volume_id)
-          if volume_id
-            self.class.new(:connection => connection).all('volume-id' => volume_id).first
-          end
-        end
-
-        def new(attributes = {})
-          if server
-            super({ :server => server }.merge!(attributes))
-          else
-            super
-          end
-        end
-
-      end
-
-    end
-  end
-end