fog 0.2.30 → 0.3.0

data/lib/fog/aws/models/ec2/flavors.rb

@@ -1,43 +0,0 @@
-require 'fog/collection'
-require 'fog/aws/models/ec2/flavor'
-
-module Fog
-  module AWS
-    module EC2
-
-      module Collections
-        def flavors
-          Fog::AWS::EC2::Flavors.new(:connection => self)
-        end
-      end
-
-      class Flavors < Fog::Collection
-
-        model Fog::AWS::EC2::Flavor
-
-        def all
-          data = [
-            { :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},
-          ]
-          load(data)
-          self
-        end
-
-        def get(flavor_id)
-          all.detect {|flavor| flavor.id == flavor_id}
-        end
-
-      end
-
-    end
-  end
-end

data/lib/fog/aws/models/ec2/image.rb

@@ -1,44 +0,0 @@
-require 'fog/model'
-
-module Fog
-  module AWS
-    module EC2
-
-      class Image < Fog::Model
-
-        identity :id,                    'imageId'
-
-        attribute :architecture
-        attribute :block_device_mapping, 'blockDeviceMapping'
-        attribute :location,             'imageLocation'
-        attribute :owner_id,             'imageOwnerId'
-        attribute :state,                'imageState'
-        attribute :type,                 'imageType'
-        attribute :is_public,            'isPublic'
-        attribute :kernel_id,            'kernelId'
-        attribute :platform
-        attribute :product_codes,        'productCodes'
-        attribute :ramdisk_id,           'ramdiskId'
-        attribute :root_device_type,     'rootDeviceType'
-        attribute :root_device_name,     'rootDeviceName'
-
-        def deregister(delete_snapshot = false)
-          connection.deregister_image(@id)
-
-          if(delete_snapshot && @root_device_type=="ebs")
-            @block_device_mapping.each do |block_device|
-              next if block_device["deviceName"] != @root_device_name
-              snapshot_id = block_device["snapshotId"]
-              snapshot = @connection.snapshots.get(snapshot_id)
-              return snapshot.destroy
-            end
-          end
-
-          return true
-        end
-
-      end
-
-    end
-  end
-end

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

@@ -1,34 +0,0 @@
-require 'fog/model'
-
-module Fog
-  module AWS
-    module EC2
-
-      class KeyPair < Fog::Model
-
-        identity  :name,        'keyName'
-
-        attribute :fingerprint, 'keyFingerprint'
-        attribute :material,    'keyMaterial'
-
-        def destroy
-          requires :name
-
-          connection.delete_key_pair(@name)
-          true
-        end
-
-        def save
-          requires :name
-
-          data = connection.create_key_pair(@name).body
-          new_attributes = data.reject {|key,value| !['keyFingerprint', 'keyMaterial', 'keyName'].include?(key)}
-          merge_attributes(new_attributes)
-          true
-        end
-
-      end
-
-    end
-  end
-end

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

@@ -1,49 +0,0 @@
-require 'fog/collection'
-require 'fog/aws/models/ec2/server'
-
-module Fog
-  module AWS
-    module EC2
-
-      module Collections
-        def servers
-          Fog::AWS::EC2::Servers.new(:connection => self)
-        end
-      end
-
-      class Servers < Fog::Collection
-
-        attribute :server_id
-
-        model Fog::AWS::EC2::Server
-
-        def initialize(attributes)
-          @server_id ||= []
-          super
-        end
-
-        def all(server_id = @server_id)
-          @server_id = server_id
-          data = connection.describe_instances(server_id).body
-          load(
-            data['reservationSet'].map do |reservation|
-              reservation['instancesSet'].map do |instance|
-                instance.merge(:groups => reservation['groupSet'])
-              end
-            end.flatten
-          )
-        end
-
-        def get(server_id)
-          if server_id
-            all(server_id).first
-          end
-        rescue Fog::Errors::NotFound
-          nil
-        end
-
-      end
-
-    end
-  end
-end

data/lib/fog/bluebox/models/flavor.rb

@@ -1,43 +0,0 @@
-require 'fog/model'
-
-module Fog
-  module Bluebox
-
-    class Flavor < Fog::Model
-
-      identity :id
-
-      attribute :name
-      attribute :cost
-      attribute :description
-
-      def bits
-        # 64
-        raise StandardError.new("Figure me out!?!")
-      end
-
-      def cores
-        # # 2 quad-cores >= 2Ghz = 8 cores
-        # 8 * case ram
-        # when 256
-        #   1/64.0
-        # when 512
-        #   1/32.0
-        # when 1024
-        #   1/16.0
-        # when 2048
-        #   1/8.0
-        # when 4096
-        #   1/4.0
-        # when 8192
-        #   1/2.0
-        # when 15872
-        #   1
-        # end
-        raise StandardError.new("Figure me out!?!")
-      end
-
-    end
-
-  end
-end

data/lib/fog/bluebox/models/flavors.rb

@@ -1,32 +0,0 @@
-require 'fog/collection'
-require 'fog/bluebox/models/flavor'
-
-module Fog
-  module Bluebox
-
-    module Collections
-      def flavors
-        Fog::Bluebox::Flavors.new(:connection => self)
-      end
-    end
-
-    class Flavors < Fog::Collection
-
-      model Fog::Bluebox::Flavor
-
-      def all
-        data = connection.get_products.body
-        load(data)
-      end
-
-      def get(product_id)
-        response = connection.get_product(product_id)
-        new(response.body)
-      rescue Fog::Bluebox::NotFound
-        nil
-      end
-
-    end
-
-  end
-end

data/lib/fog/bluebox/models/image.rb

@@ -1,17 +0,0 @@
-require 'fog/model'
-
-module Fog
-  module Bluebox
-
-    class Image < Fog::Model
-
-      identity :id
-
-      attribute :description
-      attribute :public
-      attribute :created_at, 'created'
-
-    end
-
-  end
-end

data/lib/fog/bluebox/models/images.rb

@@ -1,34 +0,0 @@
-require 'fog/collection'
-require 'fog/bluebox/models/image'
-
-module Fog
-  module Bluebox
-
-    module Collections
-      def images(attributes = {})
-        Fog::Bluebox::Images.new({
-          :connection => self
-        }.merge!(attributes))
-      end
-    end
-
-    class Images < Fog::Collection
-
-      model Fog::Bluebox::Image
-
-      def all
-        data = connection.get_templates.body
-        load(data)
-      end
-
-      def get(template_id)
-        response = connection.get_template(template_id)
-        new(response.body)
-      rescue Fog::Bluebox::NotFound
-        nil
-      end
-
-    end
-
-  end
-end

data/lib/fog/bluebox/models/server.rb

@@ -1,79 +0,0 @@
-require 'fog/model'
-
-module Fog
-  module Bluebox
-
-    class BlockInstantiationError < StandardError; end
-
-    class Server < Fog::Model
-
-      identity :id
-
-      attribute :memory
-      attribute :storage
-      attribute :hostname
-      attribute :cpu
-      attribute :ips
-      attribute :status
-      attribute :flavor_id
-      # attribute :image_id
-
-      attr_accessor :image_id
-      attribute :template
-
-      # Not reported by the API, but used at create time
-      attr_accessor :password, :ssh_key, :user
-
-      def destroy
-        requires :id
-        connection.destroy_block(@id)
-        true
-      end
-
-      def flavor
-        requires :flavor_id
-        connection.flavors.get(@flavor_id)
-      end
-
-      def image
-        requires :image_id
-        connection.images.get(@image_id)
-      end
-
-      def ready?
-        @status == 'running'
-      end
-
-      def reboot(type = 'SOFT')
-        requires :id
-        connection.reboot_block(@id, type)
-        true
-      end
-
-      def save
-        requires :flavor_id, :image_id
-        options = if !@password && !@ssh_key
-          raise(ArgumentError, "password or ssh_key is required for this operation")
-        elsif @ssh_key
-          {'ssh_key' => @ssh_key}
-        elsif @password
-          {'password' => @password}
-        end
-        if @user
-          options['user'] = @user
-        end
-        data = connection.create_block(@flavor_id, @image_id, options)
-        merge_attributes(data.body)
-        true
-      end
-
-      private
-
-      def product=(new_product)
-        @flavor_id = new_product['id']
-      end
-
-    end
-
-  end
-end

data/lib/fog/bluebox/models/servers.rb

@@ -1,33 +0,0 @@
-require 'fog/collection'
-require 'fog/bluebox/models/server'
-
-module Fog
-  module Bluebox
-
-    module Collections
-      def servers
-        Fog::Bluebox::Servers.new(:connection => self)
-      end
-    end
-
-    class Servers < Fog::Collection
-
-      model Fog::Bluebox::Server
-
-      def all
-        data = connection.get_blocks.body
-        load(data)
-      end
-
-      def get(server_id)
-        if server_id && server = connection.get_block(server_id).body
-          new(server)
-        end
-      rescue Fog::Bluebox::NotFound
-        nil
-      end
-
-    end
-
-  end
-end

data/lib/fog/bluebox/requests/create_block.rb

@@ -1,39 +0,0 @@
-module Fog
-  module Bluebox
-    class Real
-
-      # Create a new block
-      #
-      # ==== Parameters
-      # * product_id<~Integer> - Id of product to create block with
-      # * template_id<~Integer> - Id of template to create block with
-      # * options<~Hash>:
-      #     * password<~String> - Password for block
-      #   or
-      #     * ssh_key<~String> - ssh public key
-      #   * username<~String> - optional, defaults to deploy
-      #
-      # ==== Returns
-      # * response<~Excon::Response>:
-      #   * body<~Hash>:
-      # TODO
-      def create_block(product_id, template_id, options = {})
-        request(
-          :expects  => 200,
-          :method   => 'POST',
-          :path     => '/api/blocks.json',
-          :query    => {'product' => product_id, 'template' => template_id}.merge!(options)
-        )
-      end
-
-    end
-
-    class Mock
-
-      def create_block(product_id, template_id, name, password)
-        Fog::Mock.not_implemented
-      end
-
-    end
-  end
-end