bbcloud 0.8.1 → 0.8.2

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

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

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

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

@@ -1,77 +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'
-
-        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

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

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

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