fog 0.8.1 → 0.8.2

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

@@ -17,7 +17,7 @@ module Fog
         attribute :image_id
         attribute :ips
         attribute :memory
-        attribute :status
+        attribute :state,       :aliases => :status
         attribute :storage
         attribute :template
 
@@ -73,7 +73,7 @@ module Fog
         end
 
         def ready?
-          status == 'running'
+          self.state == 'running'
         end
 
         def reboot(type = 'SOFT')
@@ -89,7 +89,7 @@ module Fog
 
           if identity.nil?  # new record
             raise(ArgumentError, "password or public_key is required for this operation") if !password && !public_key
-            options['ssh_public_key'] = public_key if @public_key
+            options['ssh_public_key'] = public_key if public_key
             options['password'] = password if @password
           end
 

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

@@ -10,19 +10,19 @@ module Fog
 
         attribute :url
         attribute :name
-        attribute :status
+        attribute :state,       :aliases => 'status'
         attribute :hostname
-        attribute :created_at, :type => :time
-        attribute :deleted_at, :type => :time
-        attribute :started_at, :type => :time
+        attribute :created_at,  :type => :time
+        attribute :deleted_at,  :type => :time
+        attribute :started_at,  :type => :time
         attribute :user_data
 
         attribute :resource_type
 
-        attribute :account_id, :aliases => "account", :squash => "id"
-        attribute :image_id, :aliases => "image", :squash => "id"
-        attribute :flavor_id, :aliases => "server_type", :squash => "id"
-        attribute :zone_id, :aliases => "zone", :squash => "id"
+        attribute :account_id,  :aliases => "account",      :squash => "id"
+        attribute :image_id,    :aliases => "image",        :squash => "id"
+        attribute :flavor_id,   :aliases => "server_type",  :squash => "id"
+        attribute :zone_id,     :aliases => "zone",         :squash => "id"
 
         attribute :snapshots
         attribute :cloud_ips
@@ -86,7 +86,7 @@ module Fog
         end
 
         def ready?
-          status == 'active'
+          self.state == 'active'
         end
 
         def activate_console

data/lib/fog/compute/models/linode/data_center.rb

@@ -0,0 +1,12 @@
+require 'fog/core/model'
+
+module Fog
+  module Linode
+    class Compute
+      class DataCenter < Fog::Model
+        identity :id
+        attribute :location
+      end
+    end
+  end
+end

data/lib/fog/compute/models/linode/data_centers.rb

@@ -0,0 +1,26 @@
+require 'fog/core/collection'
+require 'fog/compute/models/linode/data_center'
+
+module Fog
+  module Linode
+    class Compute
+      class DataCenters < Fog::Collection
+        model Fog::Linode::Compute::DataCenter
+
+        def all
+          load datacenters
+        end
+
+        private
+        def datacenters(id=nil)
+          connection.avail_datacenters.body['DATA'].map { |datacenter| map_datacenter datacenter }
+        end
+        
+        def map_datacenter(datacenter)
+          datacenter = datacenter.each_with_object({}) { |(k, v), h| h[k.downcase.to_sym] = v  }
+          datacenter.merge! :id => datacenter[:datacenterid], :name => datacenter[:location]
+        end
+      end
+    end
+  end
+end

data/lib/fog/compute/models/linode/disk.rb

@@ -0,0 +1,62 @@
+require 'fog/core/model'
+
+module Fog
+  module Linode
+    class Compute
+      class Disk < Fog::Model
+        identity :id
+        attribute :name
+        attribute :type
+
+        def save
+          requires :server
+          raise Fog::Errors::Error.new('Resaving an existing object may create a duplicate') if identity
+          @type, @image, @stack_script, @name, @password, @size =
+            attributes.values_at :type, :image, :stack_script, :name, :password, :size
+          create_disk
+        end        
+
+        def destroy
+          requires :identity, :server
+          connection.linode_disk_delete server.id, id
+        end
+
+        def server
+          @server
+        end
+
+        private
+        def server=(server)
+          @server = server
+        end
+
+        def create_disk
+          case
+          when @image && @stack_script then create_disk_from_stack_script
+          when @image then create_disk_from_image
+          when @type then create_disk_type
+          else raise 'disk cannot be created'
+          end
+        end
+
+        def create_disk_type
+          self.id = connection.linode_disk_create(server.id, "#{@name}_#{@type}", @type, @size).body['DATA']['DiskID']
+          reload
+        end
+
+        def create_disk_from_image
+          disk = connection.linode_disk_createfromdistribution server.id, @image.id, "#{@name}_main", @size, @password
+          self.id = disk.body['DATA']['DiskID']
+          reload
+        end        
+
+        def create_disk_from_stack_script
+          disk = connection.linode_disk_createfromstackscript(server.id, @stack_script.id, @image.id,
+                                                              "#{@name}_main", @size, @password, @stack_script.options)
+          self.id = disk.body['DATA']['DiskID']
+          reload
+        end
+      end
+    end
+  end
+end

data/lib/fog/compute/models/linode/disks.rb

@@ -0,0 +1,40 @@
+require 'fog/core/collection'
+require 'fog/compute/models/linode/disk'
+
+module Fog
+  module Linode
+    class Compute
+      class Disks < Fog::Collection
+        model Fog::Linode::Compute::Disk
+        attribute :server
+
+        def all
+          requires :server
+          load disks(server.id)
+        end
+
+        def get(id)
+          requires :server
+          new disks(server.id, id).first
+        rescue Fog::Linode::Compute::NotFound
+          nil
+        end
+
+        def new(attributes = {})
+          requires :server
+          super({ :server => server }.merge!(attributes))
+        end
+
+        private
+        def disks(linode_id, id=nil)
+          connection.linode_disk_list(linode_id, id).body['DATA'].map { |disk| map_disk disk }
+        end
+        
+        def map_disk(disk)
+          disk = disk.each_with_object({}) { |(k, v), h| h[k.downcase.to_sym] = v  }
+          disk.merge! :id => disk[:diskid], :name => disk[:label], :server_id => disk[:linodeid]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+require 'fog/core/model'
+
+module Fog
+  module Linode
+    class Compute
+      class Flavor < Fog::Model
+        identity :id
+        attribute :disk
+        attribute :name
+        attribute :ram
+        attribute :price
+        
+        def cores
+          4 # linode always has 4 cores
+        end
+        
+        def bits
+          0 # these are determined by images you select not the hardware
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+require 'fog/core/collection'
+require 'fog/compute/models/linode/flavor'
+
+module Fog
+  module Linode
+    class Compute
+      class Flavors < Fog::Collection
+        model Fog::Linode::Compute::Flavor
+
+        def all
+          load flavors
+        end
+
+        def get(id)
+          new flavors(id).first
+        rescue Fog::Linode::Compute::NotFound
+          nil
+        end
+
+        private
+        def flavors(id=nil)
+          connection.avail_linodeplans(id).body['DATA'].map { |flavor| map_flavor flavor }
+        end
+        
+        def map_flavor(flavor)
+          flavor = flavor.each_with_object({}) { |(k, v), h| h[k.downcase.to_sym] = v  }
+          flavor.merge! :id => flavor[:planid], :name => flavor[:label]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+require 'fog/core/model'
+
+module Fog
+  module Linode
+    class Compute
+      class Image < Fog::Model
+        identity :id
+        attribute :name
+        attribute :bits
+        attribute :image_size
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+require 'fog/core/collection'
+require 'fog/compute/models/linode/image'
+
+module Fog
+  module Linode
+    class Compute
+      class Images < Fog::Collection
+        model Fog::Linode::Compute::Image
+
+        def all
+          load images
+        end
+
+        def get(id)
+          new images(id).first
+        rescue Fog::Linode::Compute::NotFound
+          nil
+        end
+
+        private
+        def images(id=nil)
+          connection.avail_distributions(id).body['DATA'].map { |image| map_image image }
+        end
+        
+        def map_image(image)
+          image = image.each_with_object({}) { |(k, v), h| h[k.downcase.to_sym] = v  }
+          image.merge!(:id => image[:distributionid], :name => image[:label], :image_size => image[:minimagesize],
+                       :kernel_id => image[:requirespvopskernel], :bits => ((image[:is64bit] == 1) ? 64 : 32 ))
+        end
+      end
+    end
+  end
+end

data/lib/fog/compute/models/linode/ip.rb

@@ -0,0 +1,30 @@
+require 'fog/core/model'
+
+module Fog
+  module Linode
+    class Compute
+      class Ip < Fog::Model
+        identity :id
+        attribute :ip
+        attribute :public
+
+        def save
+          requires :server
+          raise Fog::Errors::Error.new('Resaving an existing object may create a duplicate') if identity
+          
+          connection.linode_ip_addprivate server.id
+          server.ips.all.find { |ip| !ip.public }
+        end
+
+        def server
+          @server
+        end
+
+        private
+        def server=(server)
+          @server = server
+        end
+      end
+    end
+  end
+end

data/lib/fog/compute/models/linode/ips.rb

@@ -0,0 +1,40 @@
+require 'fog/core/collection'
+require 'fog/compute/models/linode/ip'
+
+module Fog
+  module Linode
+    class Compute
+      class Ips < Fog::Collection
+        model Fog::Linode::Compute::Ip
+        attribute :server
+
+        def all
+          requires :server
+          load ips(server.id)
+        end
+
+        def get(id)
+          requires :server
+          new ips(server.id, id).first
+        rescue Fog::Linode::Compute::NotFound
+          nil
+        end
+
+        def new(attributes = {})
+          requires :server
+          super({ :server => server }.merge!(attributes))
+        end
+
+        private
+        def ips(linode_id, id=nil)
+          connection.linode_ip_list(linode_id, id).body['DATA'].map { |ip| map_ip ip }
+        end
+        
+        def map_ip(ip)
+          ip = ip.each_with_object({}) { |(k, v), h| h[k.downcase.to_sym] = v  }
+          ip.merge! :id => ip[:ipaddressid], :ip => ip[:ipaddress], :public => ip[:ispublic]==1
+        end
+      end
+    end
+  end
+end

data/lib/fog/compute/models/linode/kernel.rb

@@ -0,0 +1,12 @@
+require 'fog/core/model'
+
+module Fog
+  module Linode
+    class Compute
+      class Kernel < Fog::Model
+        identity :id
+        attribute :name
+      end
+    end
+  end
+end

data/lib/fog/compute/models/linode/kernels.rb

@@ -0,0 +1,32 @@
+require 'fog/core/collection'
+require 'fog/compute/models/linode/kernel'
+
+module Fog
+  module Linode
+    class Compute
+      class Kernels < Fog::Collection
+        model Fog::Linode::Compute::Kernel
+
+        def all
+          load kernels
+        end
+
+        def get(id)
+          new kernels(id).first
+        rescue Fog::Linode::Compute::NotFound
+          nil
+        end
+
+        private
+        def kernels(id=nil)
+          connection.avail_kernels(id).body['DATA'].map { |kernel| map_kernel kernel }
+        end
+        
+        def map_kernel(kernel)
+          kernel = kernel.each_with_object({}) { |(k, v), h| h[k.downcase.to_sym] = v  }
+          kernel.merge! :id => kernel[:kernelid], :name => kernel[:label]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,88 @@
+require 'fog/core/model'
+
+module Fog
+  module Linode
+    class Compute
+      class Server < Fog::Model
+        attr_reader :stack_script
+        identity :id
+        attribute :name
+        attribute :status
+
+        def ips
+          Fog::Linode::Compute::Ips.new :server => self, :connection => connection
+        end
+
+        def disks
+          Fog::Linode::Compute::Disks.new :server => self, :connection => connection
+        end
+
+        def disks?
+          not disks.empty?
+        end
+
+        def reboot
+          connection.linode_reboot id
+        end
+
+        def shutdown
+          connection.linode_shutdown id
+        end
+
+        def boot
+          connection.linode_boot id, config
+        end        
+
+        def save
+          raise Fog::Errors::Error.new('Resaving an existing object may create a duplicate') if identity
+          @data_center, @flavor, @image, @kernel, @type, @payment_terms, @stack_script, @name, @password, @callback =
+            attributes.values_at :data_center, :flavor, :image, :kernel, :type, :payment_terms, :stack_script, :name, :password, :callback
+
+          create_linode
+          @callback.call self if @callback
+          create_disks
+          create_config
+          boot_linode
+          self
+        rescue Exception => ex
+          destroy if id
+          raise ex
+        end
+
+        def destroy
+          requires :identity
+          connection.linode_shutdown id
+          disks.each { |disk| disk.destroy }
+          wait_for { not disks? }
+          connection.linode_delete id
+        end
+
+        private
+        def config
+          connection.linode_config_list(id).body['DATA'].first['ConfigID']
+        end
+        
+        def create_linode
+          self.id = connection.linode_create(@data_center.id, @flavor.id, @payment_terms).body['DATA']['LinodeID']
+          connection.linode_update id, :label => @name
+          ips.create
+          reload
+        end
+        
+        def create_disks
+          @swap = disks.create :type => :swap, :name => @name, :size => @flavor.ram
+          @disk = disks.create(:type => @type, :image => @image, :stack_script => @stack_script,
+                               :password => @password, :name => @name, :size => (@flavor.disk*1024)-@flavor.ram)
+        end
+
+        def create_config
+          @config = connection.linode_config_create(id, @kernel.id, @name, "#{@disk.id},#{@swap.id},,,,,,,").body['DATA']['ConfigID']
+        end
+
+        def boot_linode
+          connection.linode_boot id, @config
+        end
+      end
+    end
+  end
+end