fog 0.2.30 → 0.3.0

data/lib/fog/slicehost.rb

@@ -1,92 +1,18 @@
 module Fog
   module Slicehost
-    extend Fog::Service
 
-    requires :slicehost_password
+    extend Fog::Provider
 
-    model_path 'fog/slicehost/models'
-    model 'flavor'
-    model 'flavors'
-    model 'image'
-    model 'images'
-    model 'server'
-    model 'servers'
-
-    request_path 'fog/slicehost/requests'
-    request 'create_slice'
-    request 'delete_slice'
-    request 'get_backups'
-    request 'get_flavor'
-    request 'get_flavors'
-    request 'get_image'
-    request 'get_images'
-    request 'get_slice'
-    request 'get_slices'
-    request 'reboot_slice'
-
-    class Mock
-      include Collections
-
-      def self.data
-        @data ||= Hash.new do |hash, key|
-          hash[key] = {}
-        end
-      end
-
-      def self.reset_data(keys=data.keys)
-        for key in [*keys]
-          data.delete(key)
-        end
-      end
-
-      def initialize(options={})
-        @slicehost_password = options[:slicehost_password]
-        @data = self.class.data[@slicehost_password]
-      end
+    service_path 'fog/slicehost'
+    service :compute
 
+    def self.new(attributes = {})
+      location = caller.first
+      warning = "[yellow][WARN] Fog::Slicehost#new is deprecated, use Fog::Bluebox::Compute#new instead[/]"
+      warning << " [light_black](" << location << ")[/] "
+      Formatador.display_line(warning)
+      Fog::Slicehost::Compute.new(attributes)
     end
 
-    class Real
-      include Collections
-
-      def initialize(options={})
-        @slicehost_password = options[:slicehost_password]
-        @host   = options[:host]    || "api.slicehost.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[:headers] ||= {}
-        params[:headers].merge!({
-          'Authorization' => "Basic #{Base64.encode64(@slicehost_password).delete("\r\n")}"
-        })
-        case params[:method]
-        when 'DELETE', 'GET', 'HEAD'
-          params[:headers]['Accept'] = 'application/xml'
-        when 'POST', 'PUT'
-          params[:headers]['Content-Type'] = 'application/xml'
-        end
-
-        begin
-          response = @connection.request(params.merge!({:host => @host}))
-        rescue Excon::Errors::Error => error
-          raise case error
-          when Excon::Errors::NotFound
-            Fog::Slicehost::NotFound.slurp(error)
-          else
-            error
-          end
-        end
-
-        response
-      end
-
-    end
   end
 end

data/lib/fog/slicehost/bin.rb

@@ -1,42 +1,25 @@
-module Slicehost
+class Slicehost < Fog::Bin
   class << self
-    if Fog.credentials[:slicehost_password]
 
-      def initialized?
-        true
-      end
-
-      def [](service)
-        @@connections ||= Hash.new do |hash, key|
-          credentials = Fog.credentials.reject do |k,v|
-            ![:slicehost_password].include?(k)
-          end
-          hash[key] = case key
-          when :slices
-            Fog::Slicehost.new(credentials)
-          end
+    def [](service)
+      @@connections ||= Hash.new do |hash, key|
+        hash[key] = case key
+        when :compute
+          Fog::Slicehost::Compute.new
+        when :slices
+          location = caller.first
+          warning = "[yellow][WARN] Slicehost[:blocks] is deprecated, use Bluebox[:compute] instead[/]"
+          warning << " [light_black](" << location << ")[/] "
+          Formatador.display_line(warning)
+          Fog::Slicehost::Compute.new
         end
-        @@connections[service]
-      end
-
-      def flavors
-        self[:slices].flavors
-      end
-
-      def images
-        self[:slices].images
-      end
-
-      def servers
-        self[:slices].servers
-      end
-
-    else
-
-      def initialized?
-        false
       end
+      @@connections[service]
+    end
 
+    def services
+      [:compute]
     end
+
   end
 end

data/lib/fog/slicehost/compute.rb

@@ -0,0 +1,91 @@
+module Fog
+  module Slicehost
+    class Compute < Fog::Service
+
+      requires :slicehost_password
+
+      model_path 'fog/slicehost/models/compute'
+      model       :flavor
+      collection  :flavors
+      model       :image
+      collection  :images
+      model       :server
+      collection  :servers
+
+      request_path 'fog/slicehost/requests/compute'
+      request :create_slice
+      request :delete_slice
+      request :get_backups
+      request :get_flavor
+      request :get_flavors
+      request :get_image
+      request :get_images
+      request :get_slice
+      request :get_slices
+      request :reboot_slice
+
+      class Mock
+
+        def self.data
+          @data ||= Hash.new do |hash, key|
+            hash[key] = {}
+          end
+        end
+
+        def self.reset_data(keys=data.keys)
+          for key in [*keys]
+            data.delete(key)
+          end
+        end
+
+        def initialize(options={})
+          @slicehost_password = options[:slicehost_password]
+          @data = self.class.data[@slicehost_password]
+        end
+
+      end
+
+      class Real
+
+        def initialize(options={})
+          @slicehost_password = options[:slicehost_password]
+          @host   = options[:host]    || "api.slicehost.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[:headers] ||= {}
+          params[:headers].merge!({
+            'Authorization' => "Basic #{Base64.encode64(@slicehost_password).delete("\r\n")}"
+          })
+          case params[:method]
+          when 'DELETE', 'GET', 'HEAD'
+            params[:headers]['Accept'] = 'application/xml'
+          when 'POST', 'PUT'
+            params[:headers]['Content-Type'] = 'application/xml'
+          end
+
+          begin
+            response = @connection.request(params.merge!({:host => @host}))
+          rescue Excon::Errors::Error => error
+            raise case error
+            when Excon::Errors::NotFound
+              Fog::Slicehost::Compute::NotFound.slurp(error)
+            else
+              error
+            end
+          end
+
+          response
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/slicehost/models/compute/flavor.rb

@@ -0,0 +1,45 @@
+require 'fog/model'
+
+module Fog
+  module Slicehost
+    class Compute
+
+      class Flavor < Fog::Model
+
+        identity :id
+
+        attribute :name
+        attribute :price
+        attribute :ram
+
+        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
+end

data/lib/fog/slicehost/models/compute/flavors.rb

@@ -0,0 +1,28 @@
+require 'fog/collection'
+require 'fog/slicehost/models/compute/flavor'
+
+module Fog
+  module Slicehost
+    class Compute
+
+      class Flavors < Fog::Collection
+
+        model Fog::Slicehost::Compute::Flavor
+
+        def all
+          data = connection.get_flavors.body['flavors']
+          load(data)
+        end
+
+        def get(flavor_id)
+          data = connection.get_flavor(flavor_id).body
+          new(data)
+        rescue Excon::Errors::Forbidden
+          nil
+        end
+
+      end
+
+    end
+  end
+end

data/lib/fog/slicehost/models/compute/image.rb

@@ -0,0 +1,17 @@
+require 'fog/model'
+
+module Fog
+  module Slicehost
+    class Compute
+
+      class Image < Fog::Model
+
+        identity :id
+
+        attribute :name
+
+      end
+
+    end
+  end
+end

data/lib/fog/slicehost/models/compute/images.rb

@@ -0,0 +1,27 @@
+require 'fog/collection'
+require 'fog/slicehost/models/compute/image'
+
+module Fog
+  module Slicehost
+    class Compute
+
+      class Images < Fog::Collection
+
+        model Fog::Slicehost::Compute::Image
+
+        def all
+          data = connection.get_images.body['images']
+          load(data)
+        end
+
+        def get(image_id)
+          connection.get_image(image_id)
+        rescue Excon::Errors::Forbidden
+          nil
+        end
+
+      end
+
+    end
+  end
+end

data/lib/fog/slicehost/models/compute/server.rb

@@ -0,0 +1,64 @@
+require 'fog/model'
+
+module Fog
+  module Slicehost
+    class Compute
+
+      class Server < Fog::Model
+
+        identity :id
+
+        attribute :addresses
+        attribute :backup_id,     :aliases => 'backup-id'
+        attribute :bandwidth_in,  :aliases => 'bw-in'
+        attribute :bandwidth_out, :aliases => 'bw-out'
+        attribute :flavor_id,     :aliases => 'flavor-id'
+        attribute :image_id,      :aliases => 'image-id'
+        attribute :name
+        attribute :password,      :aliases => 'root-password'
+        attribute :progress
+        attribute :status
+
+        def initialize(attributes={})
+          @flavor_id ||= 1
+          super
+        end
+
+        def destroy
+          requires :id
+          connection.delete_slice(@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 == 'active'
+        end
+
+        def reboot(type = 'SOFT')
+          requires :id
+          connection.reboot_slice(@id, type)
+          true
+        end
+
+        def save
+          requires :flavor_id, :image_id, :name
+          data = connection.create_slice(@flavor_id, @image_id, @name)
+          merge_attributes(data.body)
+          true
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+require 'fog/collection'
+require 'fog/slicehost/models/compute/server'
+
+module Fog
+  module Slicehost
+    class Compute
+
+      class Servers < Fog::Collection
+
+        model Fog::Slicehost::Compute::Server
+
+        def all
+          data = connection.get_slices.body['slices']
+          load(data)
+        end
+
+        def get(server_id)
+          if server_id && server = connection.get_slice(server_id).body
+            new(server)
+          elsif !server_id
+            nil
+          end
+        rescue Excon::Errors::Forbidden
+          nil
+        end
+
+      end
+
+    end
+  end
+end