phpfog-fog 0.4.1

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

@@ -0,0 +1,205 @@
+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(
+            'GroupName'                   => 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(
+            'CidrIp'      => options[:cidr_ip] || '0.0.0.0/0',
+            'FromPort'    => range.min,
+            'GroupName'   => name,
+            '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(
+            'GroupName'                   => 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(
+            'CidrIp'      => options[:cidr_ip] || '0.0.0.0/0',
+            'FromPort'    => range.min,
+            'GroupName'   => name,
+            '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

@@ -0,0 +1,95 @@
+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

@@ -0,0 +1,212 @@
+require 'fog/core/model'
+
+module Fog
+  module AWS
+    class Compute
+
+      class Server < Fog::Model
+
+        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 :ip_address,            :aliases => 'ipAddress'
+        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 :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 root},
+            %{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, :ip_address, :username
+
+          options = {}
+          options[:key_data] = [private_key] if private_key
+          Fog::SSH.new(ip_address, username, options).run(commands)
+        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
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,158 @@
+require 'fog/core/collection'
+require 'fog/compute/models/aws/server'
+
+module Fog
+  module AWS
+    class Compute
+
+      class Servers < Fog::Collection
+
+        attribute :filters
+
+        model Fog::AWS::Compute::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