bbcloud 0.8 → 0.8.1

data/lib/bbcloud/vendor/fog-0.3.23/lib/fog/aws/models/compute/addresses.rb

@@ -0,0 +1,56 @@
+require 'fog/core/collection'
+require 'fog/aws/models/compute/address'
+
+module Fog
+  module AWS
+    class Compute
+
+      class Addresses < Fog::Collection
+
+        attribute :filters
+        attribute :server
+
+        model Fog::AWS::Compute::Address
+
+        def initialize(attributes)
+          self.filters ||= {}
+          super
+        end
+
+        def all(filters = filters)
+          unless filters.is_a?(Hash)
+            Formatador.display_line("[yellow][WARN] all with #{filters.class} param is deprecated, use all('public-ip' => []) instead[/] [light_black](#{caller.first})[/]")
+            filters = {'public-ip' => [*filters]}
+          end
+          self.filters = filters
+          data = connection.describe_addresses(filters).body
+          load(
+            data['addressesSet'].map do |address|
+              address.reject {|key, value| value.nil? || value.empty? }
+            end
+          )
+          if server
+            self.replace(self.select {|address| address.server_id == server.id})
+          end
+          self
+        end
+
+        def get(public_ip)
+          if public_ip
+            self.class.new(:connection => connection).all('public-ip' => public_ip).first
+          end
+        end
+
+        def new(attributes = {})
+          if server
+            super({ :server => server }.merge!(attributes))
+          else
+            super(attributes)
+          end
+        end
+
+      end
+
+    end
+  end
+end

data/lib/bbcloud/vendor/fog-0.3.23/lib/fog/aws/models/compute/flavor.rb

@@ -0,0 +1,21 @@
+require 'fog/core/model'
+
+module Fog
+  module AWS
+    class Compute
+
+      class Flavor < Fog::Model
+
+        identity :id
+
+        attribute :bits
+        attribute :cores
+        attribute :disk
+        attribute :name
+        attribute :ram
+
+      end
+
+    end
+  end
+end

data/lib/bbcloud/vendor/fog-0.3.23/lib/fog/aws/models/compute/flavors.rb

@@ -0,0 +1,42 @@
+require 'fog/core/collection'
+require 'fog/aws/models/compute/flavor'
+
+module Fog
+  module AWS
+    class Compute
+
+      class Flavors < Fog::Collection
+
+        model Fog::AWS::Compute::Flavor
+
+        def all
+          data = [
+            { :bits => 0,  :cores =>   2,  :disk => 0,    :id =>  't1.micro',   :name => 'Micro Instance',       :ram => 613},
+
+            { :bits => 32, :cores =>   1,  :disk => 160,  :id =>  'm1.small',   :name => 'Small Instance',       :ram => 1740.8},
+            { :bits => 64, :cores =>   4,  :disk => 850,  :id =>  'm1.large',   :name => 'Large Instance',       :ram => 7680},
+            { :bits => 64, :cores =>   8,  :disk => 1690, :id =>  'm1.xlarge',  :name => 'Extra Large Instance', :ram => 15360},
+
+            { :bits => 32, :cores =>   5,  :disk => 350,  :id =>  'c1.medium',  :name => 'High-CPU Medium',      :ram => 1740.8},
+            { :bits => 64, :cores =>  20,  :disk => 1690, :id =>  'c1.xlarge',  :name => 'High-CPU Extra Large', :ram => 7168},
+
+            { :bits => 64, :cores =>  6.5, :disk => 420,  :id =>  'm2.xlarge',  :name => 'High-Memory Extra Large',           :ram => 17510.4},
+            { :bits => 64, :cores =>   13, :disk => 850,  :id =>  'm2.2xlarge', :name => 'High Memory Double Extra Large',    :ram => 35020.8},
+            { :bits => 64, :cores =>   26, :disk => 1690, :id =>  'm2.4xlarge', :name => 'High Memory Quadruple Extra Large', :ram => 70041.6},
+
+            { :bits => 64, :cores => 33.5, :disk => 1690, :id => 'cc1.4xlarge', :name => 'Cluster Compute Quadruple Extra Large', :ram => 23552},
+            { :bits => 64, :cores => 33.5, :disk => 1690, :id => 'cg1.4xlarge', :name => 'Cluster GPU Quadruple Extra Large',     :ram => 22528}
+          ]
+          load(data)
+          self
+        end
+
+        def get(flavor_id)
+          self.class.new(:connection => connection).all.detect {|flavor| flavor.id == flavor_id}
+        end
+
+      end
+
+    end
+  end
+end

data/lib/bbcloud/vendor/fog-0.3.23/lib/fog/aws/models/compute/image.rb

@@ -0,0 +1,41 @@
+require 'fog/core/model'
+
+module Fog
+  module AWS
+    class Compute
+
+      class Image < Fog::Model
+
+        identity :id,                     :aliases => 'imageId'
+
+        attribute :architecture
+        attribute :block_device_mapping,  :aliases => 'blockDeviceMapping'
+        attribute :location,              :aliases => 'imageLocation'
+        attribute :owner_id,              :aliases => 'imageOwnerId'
+        attribute :state,                 :aliases => 'imageState'
+        attribute :type,                  :aliases => 'imageType'
+        attribute :is_public,             :aliases => 'isPublic'
+        attribute :kernel_id,             :aliases => 'kernelId'
+        attribute :platform
+        attribute :product_codes,         :aliases => 'productCodes'
+        attribute :ramdisk_id,            :aliases => 'ramdiskId'
+        attribute :root_device_type,      :aliases => 'rootDeviceType'
+        attribute :root_device_name,      :aliases => 'rootDeviceName'
+        attribute :tags,                  :aliases => 'tagSet'
+
+        def deregister(delete_snapshot = false)
+          connection.deregister_image(id)
+
+          if(delete_snapshot && root_device_type == "ebs")
+            block_device = block_device_mapping.select {|block_device| block_device['deviceName'] == root_device_name}
+            @connection.snapshots.new(:id => block_device['snapshotId']).destroy
+          else
+            true
+          end
+        end
+
+      end
+
+    end
+  end
+end

data/lib/bbcloud/vendor/fog-0.3.23/lib/fog/aws/models/compute/images.rb

@@ -0,0 +1,34 @@
+require 'fog/core/collection'
+require 'fog/aws/models/compute/image'
+
+module Fog
+  module AWS
+    class Compute
+
+      class Images < Fog::Collection
+
+        attribute :filters
+
+        model Fog::AWS::Compute::Image
+
+        def initialize(attributes)
+          self.filters ||= {}
+          super
+        end
+
+        def all(filters = @filters)
+          self.filters = filters
+          data = connection.describe_images(filters).body
+          load(data['imagesSet'])
+        end
+
+        def get(image_id)
+          if image_id
+            self.class.new(:connection => connection).all('image-id' => image_id).first
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/bbcloud/vendor/fog-0.3.23/lib/fog/aws/models/compute/key_pair.rb

@@ -0,0 +1,44 @@
+require 'fog/core/model'
+
+module Fog
+  module AWS
+    class Compute
+
+      class KeyPair < Fog::Model
+        extend Fog::Deprecation
+        deprecate(:material, :private_key)
+
+        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/bbcloud/vendor/fog-0.3.23/lib/fog/aws/models/compute/key_pairs.rb

@@ -0,0 +1,40 @@
+require 'fog/core/collection'
+require 'fog/aws/models/compute/key_pair'
+
+module Fog
+  module AWS
+    class Compute
+
+      class KeyPairs < Fog::Collection
+
+        attribute :filters
+        attribute :key_name
+
+        model Fog::AWS::Compute::KeyPair
+
+        def initialize(attributes)
+          self.filters ||= {}
+          super
+        end
+
+        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
+
+        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/bbcloud/vendor/fog-0.3.23/lib/fog/aws/models/compute/security_group.rb

@@ -0,0 +1,77 @@
+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'
+
+        def authorize_group_and_owner(group, owner)
+          requires :name
+
+          connection.authorize_security_group_ingress(
+            'GroupName'                   => name,
+            'SourceSecurityGroupName'     => group,
+            'SourceSecurityGroupOwnerId'  => owner
+          )
+        end
+
+        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
+
+        def destroy
+          requires :name
+
+          connection.delete_security_group(name)
+          true
+        end
+
+        def revoke_group_and_owner(group, owner)
+          requires :name
+
+          connection.revoke_security_group_ingress(
+            'GroupName'                   => name,
+            'SourceSecurityGroupName'     => group,
+            'SourceSecurityGroupOwnerId'  => owner
+          )
+        end
+
+        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
+
+        def save
+          requires :description, :name
+
+          data = connection.create_security_group(name, description).body
+          true
+        end
+
+      end
+
+    end
+  end
+end

data/lib/bbcloud/vendor/fog-0.3.23/lib/fog/aws/models/compute/security_groups.rb

@@ -0,0 +1,39 @@
+require 'fog/core/collection'
+require 'fog/aws/models/compute/security_group'
+
+module Fog
+  module AWS
+    class Compute
+
+      class SecurityGroups < Fog::Collection
+
+        attribute :filters
+
+        model Fog::AWS::Compute::SecurityGroup
+
+        def initialize(attributes)
+          self.filters ||= {}
+          super
+        end
+
+        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
+
+        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/bbcloud/vendor/fog-0.3.23/lib/fog/aws/models/compute/server.rb

@@ -0,0 +1,199 @@
+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)
+          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
+          sleep(10) # takes a bit before EC2 instances will play nice
+          commands = [
+            %{mkdir .ssh},
+            %{passwd -l root},
+            %{echo "#{attributes.to_json}" >> ~/attributes.json}
+          ]
+          if public_key
+            commands << %{echo "#{public_key}" >> ~/.ssh/authorized_keys}
+          end
+          Fog::SSH.new(ip_address, username, credentials).run(commands)
+        rescue Errno::ECONNREFUSED => e
+          sleep(1)
+          retry
+        end
+
+        def ssh(commands)
+          requires :identity, :ip_address, :private_key, :username
+          Fog::SSH.new(ip_address, username, :key_data => [private_key]).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/bbcloud/vendor/fog-0.3.23/lib/fog/aws/models/compute/servers.rb

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