fog 0.11.0 → 1.0.0

data/lib/fog/compute/go_grid.rb

@@ -1,112 +0,0 @@
-module Fog
-  module Compute
-    class GoGrid < Fog::Service
-
-      requires :go_grid_api_key, :go_grid_shared_secret
-      recognizes :host, :path, :port, :scheme, :persistent
-
-      model_path 'fog/compute/models/go_grid'
-      model         :image
-      collection    :images
-      model         :server
-      collection    :servers
-      model         :password
-      collection    :passwords
-
-      request_path 'fog/compute/requests/go_grid'
-      request :common_lookup_list
-      request :grid_image_get
-      request :grid_image_list
-      request :grid_ip_list
-      request :grid_loadbalancer_list
-      request :grid_server_add
-      request :grid_server_delete
-      request :grid_server_get
-      request :grid_server_list
-      request :grid_server_power
-      request :support_password_get
-      request :support_password_list
-
-      class Mock
-
-        def self.data
-          @data ||= Hash.new do |hash, key|
-            hash[key] = {}
-          end
-        end
-
-        def self.reset
-          @data = nil
-        end
-
-        def initialize(options={})
-          @go_grid_api_key = options[:go_grid_api_key]
-          @go_grid_shared_secret = options[:go_grid_shared_secret]
-        end
-
-        def data
-          self.class.data[@go_grid_api_key]
-        end
-
-        def reset_data
-          self.class.data.delete(@go_grid_api_key)
-        end
-
-      end
-
-      class Real
-
-        def initialize(options={})
-          require 'digest/md5'
-          require 'multi_json'
-          @go_grid_api_key = options[:go_grid_api_key]
-          @go_grid_shared_secret = options[:go_grid_shared_secret]
-          @host   = options[:host]    || "api.gogrid.com"
-          @path   = options[:path]    || "/api"
-          @port   = options[:port]    || 443
-          @scheme = options[:scheme]  || 'https'
-          @connection = Fog::Connection.new("#{@scheme}://#{@host}:#{@port}", options[:persistent])
-        end
-
-        def reload
-          @connection.reset
-        end
-
-        def request(params)
-          params = {
-            :expects  => 200,
-            :method   => 'GET'
-          }.merge!(params)
-
-          params[:query] ||= {}
-          params[:query].merge!({
-            'api_key' => @go_grid_api_key,
-            'format'  => 'json',
-            'sig'     => Digest::MD5.hexdigest("#{@go_grid_api_key}#{@go_grid_shared_secret}#{Time.now.to_i}"),
-            'v'       => '1.5'
-          })
-
-          begin
-            response = @connection.request(
-              params.merge!(:path => "#{@path}/#{params[:path]}")
-            )
-          rescue Excon::Errors::HTTPStatusError => error
-            raise case error
-            when Excon::Errors::NotFound
-              Fog::Compute::GoGrid::NotFound.slurp(error)
-            else
-              error
-            end
-          end
-
-          unless response.body.empty?
-            response.body = MultiJson.decode(response.body)
-          end
-
-          response
-        end
-
-      end
-    end
-  end
-end

data/lib/fog/compute/linode.rb

@@ -1,116 +0,0 @@
-module Fog
-  module Compute
-    class Linode < Fog::Service
-
-      requires :linode_api_key
-      recognizes :port, :scheme, :persistent
-
-      model_path 'fog/compute/models/linode'
-      model :flavor
-      collection :flavors
-      model :image
-      collection :images
-      model :server
-      collection :servers
-      model :kernel
-      collection :kernels
-      model :data_center
-      collection :data_centers
-      model :stack_script
-      collection :stack_scripts
-      model :ip
-      collection :ips
-      model :disk
-      collection :disks
-
-      request_path 'fog/compute/requests/linode'
-      request :avail_datacenters
-      request :avail_distributions
-      request :avail_kernels
-      request :avail_linodeplans
-      request :avail_stackscripts
-      request :linode_disk_create
-      request :linode_disk_list
-      request :linode_disk_delete
-      request :linode_disk_createfromdistribution
-      request :linode_disk_createfromstackscript     
-      request :linode_ip_list
-      request :linode_ip_addprivate
-      request :linode_config_list
-      request :linode_config_create
-      request :linode_create
-      request :linode_delete
-      request :linode_list
-      request :linode_boot
-      request :linode_reboot
-      request :linode_shutdown
-      request :linode_update
-      request :stackscript_list
-      # request :linode_resize      
-
-      class Mock
-
-        def self.data
-          @data ||= Hash.new do |hash, key|
-            hash[key] = {}
-          end
-        end
-
-        def self.reset
-          @data = nil
-        end
-
-        def initialize(options={})
-          @linode_api_key = options[:linode_api_key]
-        end
-
-        def data
-          self.class.data[@linode_api_key]
-        end
-
-        def reset_data
-          self.class.data.delete(@linode_api_key)
-        end
-
-      end
-
-      class Real
-
-        def initialize(options={})
-          require 'multi_json'
-          @linode_api_key = options[:linode_api_key]
-          @host   = options[:host]    || "api.linode.com"
-          @port   = options[:port]    || 443
-          @scheme = options[:scheme]  || 'https'
-          @connection = Fog::Connection.new("#{@scheme}://#{@host}:#{@port}", options[:persistent])
-        end
-
-        def reload
-          @connection.reset
-        end
-
-        def request(params)
-          params[:query] ||= {}
-          params[:query].merge!(:api_key => @linode_api_key)
-
-          response = @connection.request(params.merge!({:host => @host}))
-
-          unless response.body.empty?
-            response.body = MultiJson.decode(response.body)
-            if data = response.body['ERRORARRAY'].first
-              error = case data['ERRORCODE']
-              when 5
-                Fog::Compute::Linode::NotFound
-              else
-                Fog::Compute::Linode::Error
-              end
-              raise error.new(data['ERRORMESSAGE'])
-            end
-          end
-          response
-        end
-
-      end
-    end
-  end
-end

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

@@ -1,100 +0,0 @@
-require 'fog/core/collection'
-require 'fog/compute/models/aws//address'
-
-module Fog
-  module Compute
-    class AWS
-
-      class Addresses < Fog::Collection
-
-        attribute :filters
-        attribute :server
-
-        model Fog::Compute::AWS::Address
-
-        # Used to create an IP address
-        #
-        # ==== Returns
-        #
-        #>> AWS.addresses.create
-        #  <Fog::AWS::Compute::Address
-        #    public_ip="4.88.524.95",
-        #    server_id=nil
-        #  >
-        #
-        # The IP address can be retreived by running AWS.addresses.get("test").  See get method below.
-        #
-
-        def initialize(attributes)
-          self.filters ||= {}
-          super
-        end
-
-        # AWS.addresses.all
-        #
-        # ==== Returns
-        #
-        # Returns an array of all IP addresses
-        #
-        #>> AWS.addresses.all
-        #  <Fog::AWS::Compute::Addresses
-        #    filters={},
-        #    server=nil
-        #    [
-        #      <Fog::AWS::Compute::Address
-        #        public_ip="76.7.46.54",
-        #        server_id=nil
-        #      >,
-        #      .......
-        #      <Fog::AWS::Compute::Address
-        #        public_ip="4.88.524.95",
-        #        server_id=nil
-        #      >
-        #    ]
-        #  >
-        #>>
-
-        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
-
-        # Used to retreive an IP address
-        #
-        # public_ip is required to get the associated IP information.
-        #
-        # You can run the following command to get the details:
-        # AWS.addresses.get("76.7.46.54")
-
-        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/fog/compute/models/aws/flavors.rb

@@ -1,167 +0,0 @@
-require 'fog/core/collection'
-require 'fog/compute/models/aws/flavor'
-
-module Fog
-  module Compute
-    class AWS
-
-      FLAVORS = [
-        { :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}
-      ]
-
-      class Flavors < Fog::Collection
-
-        model Fog::Compute::AWS::Flavor
-
-        # Returns an array of all flavors that have been created
-        #
-        # AWS.flavors.all
-        #
-        # ==== Returns
-        #
-        # Returns an array of all available instance sizes
-        #
-        #>> AWS.flavors.all
-        #  <Fog::AWS::Compute::Flavors
-        #    [
-        #      <Fog::AWS::Compute::Flavor
-        #        id="t1.micro",
-        #        bits=0,
-        #        cores=2,
-        #        disk=0,
-        #        name="Micro Instance",
-        #        ram=613
-        #      >,
-        #      <Fog::AWS::Compute::Flavor
-        #        id="m1.small",
-        #        bits=32,
-        #        cores=1,
-        #        disk=160,
-        #        name="Small Instance",
-        #        ram=1740.8
-        #      >,
-        #      <Fog::AWS::Compute::Flavor
-        #        id="m1.large",
-        #        bits=64,
-        #        cores=4,
-        #        disk=850,
-        #        name="Large Instance",
-        #        ram=7680
-        #      >,
-        #      <Fog::AWS::Compute::Flavor
-        #        id="m1.xlarge",
-        #        bits=64,
-        #        cores=8,
-        #        disk=1690,
-        #        name="Extra Large Instance",
-        #        ram=15360
-        #      >,
-        #      <Fog::AWS::Compute::Flavor
-        #        id="c1.medium",
-        #        bits=32,
-        #        cores=5,
-        #        disk=350,
-        #        name="High-CPU Medium",
-        #        ram=1740.8
-        #      >,
-        #      <Fog::AWS::Compute::Flavor
-        #        id="c1.xlarge",
-        #        bits=64,
-        #        cores=20,
-        #        disk=1690,
-        #        name="High-CPU Extra Large",
-        #        ram=7168
-        #      >,
-        #      <Fog::AWS::Compute::Flavor
-        #        id="m2.xlarge",
-        #        bits=64,
-        #        cores=6.5,
-        #        disk=420,
-        #        name="High-Memory Extra Large",
-        #        ram=17510.4
-        #      >,
-        #      <Fog::AWS::Compute::Flavor
-        #        id="m2.2xlarge",
-        #        bits=64,
-        #        cores=13,
-        #        disk=850,
-        #        name="High Memory Double Extra Large",
-        #        ram=35020.8
-        #      >,
-        #      <Fog::AWS::Compute::Flavor
-        #        id="m2.4xlarge",
-        #        bits=64,
-        #        cores=26,
-        #        disk=1690,
-        #        name="High Memory Quadruple Extra Large",
-        #        ram=70041.6
-        #      >,
-        #      <Fog::AWS::Compute::Flavor
-        #        id="cc1.4xlarge",
-        #        bits=64,
-        #        cores=33.5,
-        #        disk=1690,
-        #        name="Cluster Compute Quadruple Extra Large",
-        #        ram=23552
-        #      >,
-        #      <Fog::AWS::Compute::Flavor
-        #        id="cg1.4xlarge",
-        #        bits=64,
-        #        cores=33.5,
-        #        disk=1690,
-        #        name="Cluster GPU Quadruple Extra Large",
-        #        ram=22528
-        #      >
-        #    ]
-        #  >
-        #
-
-        def all
-          load(Fog::Compute::AWS::FLAVORS)
-          self
-        end
-
-        # Used to retreive a flavor
-        # flavor_id is required to get the associated flavor information.
-        # flavors available currently:
-        # 't1.micro', 'm1.small', 'm1.large', 'm1.xlarge', 'c1.medium', 'c1.xlarge', 'm2.xlarge', 'm2.2xlarge', 'm2.4xlarge', 'cc1.4xlarge', 'cg1.4xlarge'
-        #
-        # You can run the following command to get the details:
-        # AWS.flavors.get("t1.micro")
-        #
-        # ==== Returns
-        #
-        #>> AWS.flavors.get("t1.micro")
-        # <Fog::AWS::Compute::Flavor
-        #  id="t1.micro",
-        #  bits=0,
-        #  cores=2,
-        #  disk=0,
-        #  name="Micro Instance",
-        #  ram=613
-        #>
-        #
-
-        def get(flavor_id)
-          self.class.new(:connection => connection).all.detect {|flavor| flavor.id == flavor_id}
-        end
-
-      end
-
-    end
-  end
-end