Merge pull request #328 from kingdomsite/linode

Linode

lib/fog/compute/linode.rb

@@ -7,6 +7,22 @@ module Fog
       recognizes :provider # remove post deprecation
 
       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
@@ -14,14 +30,24 @@ module Fog
       request :avail_kernels
       request :avail_linodeplans
       request :avail_stackscripts
-      # request :linode_boot
+      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_resize
-      # request :linode_shutdown
-      # request :linode_update
+      request :linode_shutdown
+      request :linode_update
+      request :stackscript_list
+      # request :linode_resize      
 
       class Mock
 

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

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

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

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

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

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

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

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

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

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

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

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

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

lib/fog/compute/models/linode/servers.rb

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

lib/fog/compute/models/linode/stack_script.rb

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

lib/fog/compute/models/linode/stack_scripts.rb

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

lib/fog/compute/requests/linode/avail_datacenters.rb

@@ -2,7 +2,7 @@ module Fog
   module Linode
     class Compute
       class Real
-
+        
         # Get available data centers
         #
         # ==== Returns
@@ -16,7 +16,6 @@ module Fog
             :query    => { :api_action => 'avail.datacenters' }
           )
         end
-
       end
     end
   end

lib/fog/compute/requests/linode/avail_distributions.rb

@@ -11,7 +11,7 @@ module Fog
         # ==== Returns
         # * response<~Excon::Response>:
         #   * body<~Array>:
-        # TODO: docs
+        # TODO: docs        
         def avail_distributions(distribution_id=nil)
           options = {}
           if distribution_id
@@ -23,7 +23,6 @@ module Fog
             :query    => { :api_action => 'avail.distributions' }.merge!(options)
           )
         end
-
       end
     end
   end

lib/fog/compute/requests/linode/avail_kernels.rb

@@ -6,22 +6,23 @@ module Fog
         # Get available kernels
         #
         # ==== Parameters
-        # * options<~Hash>:
-        #   * kernelId<~Integer>: id to limit results to
-        #   * isXen<~Integer>: if 1 limits results to only zen
+        # * kernelId<~Integer>: id to limit results to
         #
         # ==== Returns
         # * response<~Excon::Response>:
         #   * body<~Array>:
         # TODO: docs
-        def avail_kernels(options={})
+        def avail_kernels(kernel_id=nil)
+          options = {}
+          if kernel_id
+            options.merge!(:kernelId => kernel_id)
+          end          
           request(
             :expects  => 200,
             :method   => 'GET',
             :query    => { :api_action => 'avail.kernels' }.merge!(options)
           )
         end
-
       end
     end
   end

lib/fog/compute/requests/linode/avail_linodeplans.rb

@@ -5,22 +5,28 @@ module Fog
 
         # Get available plans
         #
+        # ==== Parameters
+        # * linodeplanId<~Integer>: id to limit results to
+        #
         # ==== Returns
         # * response<~Excon::Response>:
         #   * body<~Array>:
-        # TODO: docs
+        # TODO: docs        
         def avail_linodeplans(linodeplan_id = nil)
           options = {}
           if linodeplan_id
             options.merge!(:planId => linodeplan_id)
           end
-          request(
+          result = request(
             :expects  => 200,
             :method   => 'GET',
             :query    => { :api_action => 'avail.linodeplans' }.merge!(options)
           )
+          
+          #hack for plans not filtering by id like they should above, remove when they fix it.
+          result.body["DATA"] = result.body["DATA"].select { |item| item['PLANID'] == linodeplan_id } if linodeplan_id
+          result
         end
-
       end
     end
   end

lib/fog/compute/requests/linode/avail_stackscripts.rb

@@ -2,27 +2,15 @@ module Fog
   module Linode
     class Compute
       class Real
-
-        # Get available stack scripts
-        #
-        # ==== Parameters
-        # * options<~Hash>:
-        #   * distributionId<~Integer>: Limit the results to Stackscripts that can be applied to this distribution id
-        #   * distributionVendor<~String>: Debian, Ubuntu, Fedora, etc.
-        #   * keywords<~String>: Search terms
-        #
-        # ==== Returns
-        # * response<~Excon::Response>:
-        #   * body<~Array>:
-        # TODO: docs
         def avail_stackscripts(options={})
-          request(
+          result = request(
             :expects  => 200,
             :method   => 'GET',
             :query    => { :api_action => 'avail.stackscripts' }.merge!(options)
           )
+          result.body['DATA'].each { |r| r['DISTRIBUTIONIDLIST'] = r['DISTRIBUTIONIDLIST'].to_s }
+          result
         end
-
       end
     end
   end

lib/fog/compute/requests/linode/linode_boot.rb

@@ -0,0 +1,15 @@
+module Fog
+  module Linode
+    class Compute
+      class Real
+        def linode_boot(linode_id, config_id)
+          request(
+            :expects => 200,
+            :method => 'GET',
+            :query => { :api_action => 'linode.boot', :linodeId => linode_id, :configId => config_id }
+          )
+        end
+      end
+    end
+  end
+end

lib/fog/compute/requests/linode/linode_config_create.rb

@@ -0,0 +1,21 @@
+module Fog
+  module Linode
+    class Compute
+      class Real
+        def linode_config_create(linode_id, kernel_id, name, disk_list)
+          request(
+            :expects  => 200,
+            :method   => 'GET',
+            :query    => {
+              :api_action => 'linode.config.create',
+              :linodeId => linode_id,
+              :kernelId => kernel_id,
+              :label => name,
+              :diskList => disk_list
+            }
+          )
+        end
+      end
+    end
+  end
+end

lib/fog/compute/requests/linode/linode_config_list.rb

@@ -0,0 +1,18 @@
+module Fog
+  module Linode
+    class Compute
+      class Real
+        def linode_config_list(linode_id, config_id=nil, options={})
+          if config_id
+            options.merge!(:configid => config_id)
+          end
+          request(
+            :expects  => 200,
+            :method   => 'GET',
+            :query    => { :api_action => 'linode.config.list', :linodeId => linode_id }.merge!(options)
+          )
+        end
+      end
+    end
+  end
+end

lib/fog/compute/requests/linode/linode_create.rb

@@ -5,16 +5,16 @@ module Fog
 
         # Creates a linode and assigns you full privileges
         #
-        # ==== Parameters
+        # ==== Parameters 	
         # * datacenter_id<~Integer>: id of datacenter to place new linode in
+        # * plan_id<~Integer>: id of plan to boot new linode with        
         # * payment_term<~Integer>: Subscription term in months, in [1, 12, 24]
-        # * plan_id<~Integer>: id of plan to boot new linode with
         #
         # ==== Returns
         # * response<~Excon::Response>:
         #   * body<~Array>:
         # TODO: docs
-        def linode_create(datacenter_id, payment_term, plan_id)
+        def linode_create(datacenter_id, plan_id, payment_term)
           request(
             :expects  => 200,
             :method   => 'GET',
@@ -26,7 +26,6 @@ module Fog
             }
           )
         end
-
       end
     end
   end

lib/fog/compute/requests/linode/linode_delete.rb

@@ -21,7 +21,6 @@ module Fog
             :query    => { :api_action => 'linode.delete', :linodeId => linode_id }.merge!(options)
           )
         end
-
       end
     end
   end

lib/fog/compute/requests/linode/linode_disk_create.rb

@@ -0,0 +1,21 @@
+module Fog
+  module Linode
+    class Compute
+      class Real
+        def linode_disk_create(linode_id, name, type, size)
+          request(
+            :expects  => 200,
+            :method   => 'GET',
+            :query    => {
+              :api_action => 'linode.disk.create',
+              :linodeId => linode_id,
+              :label => name,
+              :type => type,
+              :size => size
+            }
+          )
+        end
+      end
+    end
+  end
+end

lib/fog/compute/requests/linode/linode_disk_createfromdistribution.rb

@@ -0,0 +1,22 @@
+module Fog
+  module Linode
+    class Compute
+      class Real
+        def linode_disk_createfromdistribution(linode_id, distro_id, name, size, password)
+          request(
+            :expects  => 200,
+            :method   => 'GET',
+            :query    => {
+              :api_action => 'linode.disk.createfromdistribution',
+              :linodeId => linode_id,
+              :distributionId => distro_id,
+              :label => name,
+              :size => size,
+              :rootPass => password
+            }
+          )
+        end
+      end
+    end
+  end
+end

lib/fog/compute/requests/linode/linode_disk_createfromstackscript.rb

@@ -0,0 +1,24 @@
+module Fog
+  module Linode
+    class Compute
+      class Real
+        def linode_disk_createfromstackscript(linode_id, script_id, distro_id, name, size, password, options={})
+          request(
+            :expects  => 200,
+            :method   => 'GET',
+            :query    => {
+              :api_action => 'linode.disk.createfromstackscript',
+              :linodeId => linode_id,
+              :stackScriptID => script_id,
+              :distributionId => distro_id,
+              :label => name,
+              :size => size,
+              :rootPass => password,
+              :stackScriptUDFResponses => options.to_json
+            }
+          )
+        end
+      end
+    end
+  end
+end

lib/fog/compute/requests/linode/linode_disk_delete.rb

@@ -0,0 +1,19 @@
+module Fog
+  module Linode
+    class Compute
+      class Real
+        def linode_disk_delete(linode_id, disk_id)
+          request(
+            :expects  => 200,
+            :method   => 'GET',
+            :query    => {
+              :api_action => 'linode.disk.delete',
+              :linodeId => linode_id,
+              :diskId => disk_id
+            }
+          )
+        end
+      end
+    end
+  end
+end

lib/fog/compute/requests/linode/linode_disk_list.rb

@@ -0,0 +1,19 @@
+module Fog
+  module Linode
+    class Compute
+      class Real
+        def linode_disk_list(linode_id, disk_id=nil)
+          options = {}
+          if disk_id
+            options.merge!(:diskId => disk_id)
+          end          
+          request(
+            :expects  => 200,
+            :method   => 'GET',
+            :query    => { :api_action => 'linode.disk.list', :linodeId => linode_id }.merge!(options)
+          )
+        end
+      end
+    end
+  end
+end

lib/fog/compute/requests/linode/linode_ip_addprivate.rb

@@ -0,0 +1,15 @@
+module Fog
+  module Linode
+    class Compute
+      class Real
+        def linode_ip_addprivate(linode_id)
+          request(
+            :expects  => 200,
+            :method   => 'GET',
+            :query    => { :api_action => 'linode.ip.addprivate', :linodeId => linode_id }
+          )
+        end
+      end
+    end
+  end
+end

lib/fog/compute/requests/linode/linode_ip_list.rb

@@ -0,0 +1,19 @@
+module Fog
+  module Linode
+    class Compute
+      class Real
+        def linode_ip_list(linode_id, ip_id=nil)
+          options = {}
+          if ip_id
+            options.merge!(:ipaddressId => ip_id)
+          end
+          request(
+            :expects  => 200,
+            :method   => 'GET',
+            :query    => { :api_action => 'linode.ip.list', :linodeId => linode_id }.merge!(options)
+          )
+        end
+      end
+    end
+  end
+end

lib/fog/compute/requests/linode/linode_list.rb

@@ -23,7 +23,6 @@ module Fog
             :query    => { :api_action => 'linode.list' }.merge!(options)
           )
         end
-
       end
     end
   end

lib/fog/compute/requests/linode/linode_reboot.rb

@@ -13,7 +13,7 @@ module Fog
         # ==== Returns
         # * response<~Excon::Response>:
         #   * body<~Array>:
-        # TODO: docs
+        # TODO: docs        
         def linode_reboot(linode_id, options={})
           request(
             :expects  => 200,
@@ -21,7 +21,6 @@ module Fog
             :query    => { :api_action => 'linode.reboot', :linodeId => linode_id }.merge!(options)
           )
         end
-
       end
     end
   end

lib/fog/compute/requests/linode/linode_shutdown.rb

@@ -0,0 +1,15 @@
+module Fog
+  module Linode
+    class Compute
+      class Real
+        def linode_shutdown(linode_id)
+          request(
+            :expects => 200,
+            :method => 'GET',
+            :query => { :api_action => 'linode.shutdown', :linodeId => linode_id }
+          )
+        end
+      end
+    end
+  end
+end

lib/fog/compute/requests/linode/linode_update.rb

@@ -0,0 +1,15 @@
+module Fog
+  module Linode
+    class Compute
+      class Real
+        def linode_update(linode_id, options={})
+          request(
+            :expects  => 200,
+            :method   => 'GET',
+            :query    => { :api_action => 'linode.update', :linodeId => linode_id }.merge!(options)
+          )
+        end
+      end
+    end
+  end
+end

lib/fog/compute/requests/linode/stackscript_list.rb

@@ -0,0 +1,31 @@
+module Fog
+  module Linode
+    class Compute
+      class Real
+
+        # Get available stack scripts
+        #
+        # ==== Parameters
+        # * scriptId<~Integer>: id to limit results to
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Array>:
+        # TODO: docs        
+        def stackscript_list(script_id=nil)
+          options = {}
+          if script_id
+            options.merge!(:stackScriptID => script_id)
+          end          
+          result = request(
+            :expects  => 200,
+            :method   => 'GET',
+            :query    => { :api_action => 'stackscript.list' }.merge!(options)
+          )
+          result.body['DATA'].each { |r| r['DISTRIBUTIONIDLIST'] = r['DISTRIBUTIONIDLIST'].to_s }
+          result
+        end
+      end
+    end
+  end
+end

lib/fog/providers/linode.rb

@@ -2,12 +2,9 @@ require 'fog/core'
 
 module Fog
   module Linode
-
     extend Fog::Provider
-
     service(:compute, 'compute/linode')
     service(:dns,     'dns/linode')
-
   end
 end
 

tests/compute/requests/linode/kernel_tests.rb

@@ -0,0 +1,27 @@
+Shindo.tests('Linode::Compute | kernel requests', ['linode']) do
+
+  @kernels_format = Linode::Compute::Formats::BASIC.merge({
+    'DATA' => [{ 
+      'LABEL'               => String,
+      'ISXEN'               => Integer,
+      'ISPVOPS'             => Integer,
+      'KERNELID'            => Integer
+    }]
+  })
+
+  tests('success') do
+    @kernel_id = nil
+
+    tests('#avail_kernels').formats(@kernels_format) do
+      pending if Fog.mocking?
+      data = Linode[:compute].avail_kernels.body
+      @kernel_id = data['DATA'].first['KERNELID']
+      data
+    end
+
+    tests("@avail_kernels(#{@kernel_id})").formats(@kernels_format) do
+      pending if Fog.mocking?
+      Linode[:compute].avail_kernels(@kernel_id).body
+    end
+  end
+end

tests/compute/requests/linode/linode_tests.rb

@@ -35,6 +35,28 @@ Shindo.tests('Linode::Compute | linode requests', ['linode']) do
     'DATA' => { 'JobID' => Integer }
   })
 
+  @ip_format = Linode::Compute::Formats::BASIC.merge({
+    'DATA' => { 'IPAddressID' => Integer }
+  })
+
+  @disks_format = Linode::Compute::Formats::BASIC.merge({
+    'DATA' => [{
+      "UPDATE_DT"  => String,
+      "DISKID"     => Integer,
+      "LABEL"      => String,
+      "TYPE"       => String,
+      "LINODEID"   => Integer,
+      "ISREADONLY" => Integer,
+      "STATUS"     => Integer,
+      "CREATE_DT"  => String,
+      "SIZE"       => Integer
+    }]
+  })
+
+  @disk_format = Linode::Compute::Formats::BASIC.merge({
+    'DATA' => { 'JobID' => Integer, 'DiskID' => Integer }
+  })  
+
   tests('success') do
 
     @linode_id = nil
@@ -53,16 +75,52 @@ Shindo.tests('Linode::Compute | linode requests', ['linode']) do
     end
 
     tests('#linode_list').formats(@linodes_format) do
-      pending if Fog.mocking?
+      pending if Fog.mocking?      
       Linode[:compute].linode_list.body
     end
 
+    tests('#linode_update').formats(@linode_format) do
+      pending if Fog.mocking?
+      Linode[:compute].linode_update(@linode_id, :label => 'testing').body
+    end
+
+    tests('#linode_ip_addprivate').formats(@ip_format) do
+      pending if Fog.mocking?
+      Linode[:compute].linode_ip_addprivate(@linode_id).body
+    end
+
+    tests('#linode_disk_create').formats(@disk_format) do
+      pending if Fog.mocking?
+      data = Linode[:compute].linode_disk_create(@linode_id, 'test1', 'ext3', 1).body
+      @disk1_id = data['DATA']['DiskID']
+      data
+    end    
+
+    tests('#linode_disk_createfromdistribution').formats(@disk_format) do
+      pending if Fog.mocking?
+      data = Linode[:compute].linode_disk_createfromdistribution(@linode_id, 73, 'test1', 600, 'P@SSW)RD').body
+      @disk2_id = data['DATA']['DiskID']
+      data
+    end
+
+    tests('#linode_disk_list').formats(@disks_format) do
+      pending if Fog.mocking?
+      Linode[:compute].linode_disk_list(@linode_id).body
+    end
+
     # tests("#linode_reboot(#{@linode_id})").formats(@reboot_format) do
     #   Linode[:compute].linode_reboot(@linode_id).body
-    # end
+    # end    
+
+    tests('#linode_disk_delete').formats(@disk_format) do
+      pending if Fog.mocking?
+      Linode[:compute].linode_disk_delete(@linode_id, @disk1_id).body
+      Linode[:compute].linode_disk_delete(@linode_id, @disk2_id).body
+    end
 
     tests('#linode_delete(#{@linode_id})').succeeds do
       pending if Fog.mocking?
+      sleep 1 until Linode[:compute].linode_disk_list(@linode_id).body['DATA'].size == 0
       Linode[:compute].linode_delete(@linode_id)
     end
 
@@ -72,12 +130,12 @@ Shindo.tests('Linode::Compute | linode requests', ['linode']) do
 
     tests('#linode_reboot(0)').raises(Fog::Linode::Compute::NotFound) do
       pending if Fog.mocking?
-      Linode[:compute].linode_reboot(0)
+      Linode[:compute].linode_reboot(1)
     end
 
     tests('#linode_delete(0)').raises(Fog::Linode::Compute::NotFound) do
       pending if Fog.mocking?
-      Linode[:compute].linode_delete(0)
+      Linode[:compute].linode_delete(1)
     end
 
   end

tests/compute/requests/linode/stackscripts_tests.rb

@@ -0,0 +1,35 @@
+Shindo.tests('Linode::Compute | stack_script requests', ['linode']) do
+
+  @stack_scripts_format = Linode::Compute::Formats::BASIC.merge({
+    'DATA' => [{ 
+      'STACKSCRIPTID'       => Integer,
+      'SCRIPT'              => String,
+      'DESCRIPTION'         => String,
+      'DISTRIBUTIONIDLIST'  => String,
+      'LABEL'               => String,
+      'DEPLOYMENTSTOTAL'    => Integer,
+      'LATESTREV'           => Integer,
+      'CREATE_DT'           => String,
+      'DEPLOYMENTSACTIVE'   => Integer,
+      'REV_NOTE'            => String,
+      'REV_DT'              => String,
+      'ISPUBLIC'            => Integer,
+      'USERID'              => Integer
+    }]
+  })  
+
+  tests('success') do
+
+    tests('#avail_stackscripts').formats(@stack_scripts_format) do
+      pending if Fog.mocking?
+      Linode[:compute].avail_stackscripts.body
+    end    
+    
+    tests('#stackscript_list').formats(@stack_scripts_format) do
+      pending if Fog.mocking?
+      Linode[:compute].stackscript_list.body
+    end
+
+  end
+
+end