phpfog-fog 0.4.1

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

@@ -0,0 +1,56 @@
+require 'fog/core/model'
+
+module Fog
+  module GoGrid
+    class Compute
+
+      class BlockInstantiationError < StandardError; end
+
+      class Server < Fog::Model
+
+        identity :id
+
+        attribute :name
+        attribute :image_id        # id or name
+        attribute :ip
+        attribute :memory       # server.ram
+        attribute :state
+        attribute :description  # Optional
+        attribute :sandbox      # Optional. Default: False
+
+        def initialize(attributes={})
+          super
+        end
+
+        def destroy
+          requires :id
+          connection.grid_server_destroy(id)
+          true
+        end
+
+        def image
+          requires :image_id
+          connection.grid_image_get(image_id)
+        end
+
+        def ready?
+          @state == 'On'
+        end
+
+        def save
+          raise Fog::Errors::Error.new('Resaving an existing object may create a duplicate') if identity
+          requires :name, :image_id, :ip, :memory
+          options['isSandbox'] = sandbox if sandbox
+          options['server.ram'] = memory
+          options['image'] = image_id
+          data = connection.grid_server_add(name, image, ip, options)
+          merge_attributes(data.body)
+          true
+        end
+
+      end
+
+    end
+
+  end
+end

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

@@ -0,0 +1,35 @@
+require 'fog/core/collection'
+require 'fog/go_grid/models/compute/server'
+
+module Fog
+  module GoGrid
+    class Compute
+
+      class Servers < Fog::Collection
+
+        model Fog::GoGrid::Compute::Server
+
+        def all
+          data = connection.grid_server_list.body['list']
+          load(data)
+        end
+
+        def bootstrap(new_attributes = {})
+          server = create(new_attributes)
+          server.wait_for { ready? }
+          server
+        end
+
+        def get(server_id)
+          if server_id && server = connection.grid_server_get(server_id).body['list']
+            new(server)
+          end
+        rescue Fog::GoGrid::Compute::NotFound
+          nil
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+require 'fog/core/model'
+
+module Fog
+  module Rackspace
+    class Compute
+
+      class Flavor < Fog::Model
+
+        identity :id
+
+        attribute :disk
+        attribute :name
+        attribute :ram
+
+        def bits
+          64
+        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
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+require 'fog/core/collection'
+require 'fog/compute/models/rackspace/flavor'
+
+module Fog
+  module Rackspace
+    class Compute
+
+      class Flavors < Fog::Collection
+
+        model Fog::Rackspace::Compute::Flavor
+
+        def all
+          data = connection.list_flavors_detail.body['flavors']
+          load(data)
+        end
+
+        def get(flavor_id)
+          data = connection.get_flavor_details(flavor_id).body['flavor']
+          new(data)
+        rescue Fog::Rackspace::Compute::NotFound
+          nil
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+require 'fog/core/model'
+
+module Fog
+  module Rackspace
+    class Compute
+
+      class Image < Fog::Model
+
+        identity :id
+
+        attribute :name
+        attribute :created_at,  :aliases => 'created'
+        attribute :updated_at,  :aliases => 'updated'
+        attribute :progress
+        attribute :status
+        attribute :server_id,   :aliases => 'serverId'
+
+        def server=(new_server)
+          requires :id
+
+          self.server_id = new_server.id
+        end
+
+        def destroy
+          requires :id
+
+          connection.delete_image(id)
+          true
+        end
+
+        def ready?
+          status == 'ACTIVE'
+        end
+
+        def save
+          raise Fog::Errors::Error.new('Resaving an existing object may create a duplicate') if identity
+          requires :server_id
+
+          data = connection.create_image(server_id, 'name' => name)
+          merge_attributes(data.body['image'])
+          true
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+require 'fog/core/collection'
+require 'fog/compute/models/rackspace/image'
+
+module Fog
+  module Rackspace
+    class Compute
+
+      class Images < Fog::Collection
+
+        model Fog::Rackspace::Compute::Image
+
+        attribute :server
+
+        def all
+          data = connection.list_images_detail.body['images']
+          load(data)
+          if server
+            self.replace(self.select {|image| image.server_id == server.id})
+          end
+        end
+
+        def get(image_id)
+          data = connection.get_image_details(image_id).body['image']
+          new(data)
+        rescue Fog::Rackspace::Compute::NotFound
+          nil
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,129 @@
+require 'fog/core/model'
+
+module Fog
+  module Rackspace
+    class Compute
+
+      class Server < Fog::Model
+
+        identity :id
+
+        attribute :addresses
+        attribute :flavor_id,   :aliases => 'flavorId'
+        attribute :host_id,     :aliases => 'hostId'
+        attribute :image_id,    :aliases => 'imageId'
+        attribute :metadata
+        attribute :name
+        attribute :personality
+        attribute :progress
+        attribute :status
+
+        attr_reader :password
+        attr_writer :private_key, :private_key_path, :public_key, :public_key_path, :username
+
+        def initialize(attributes={})
+          self.flavor_id ||= 1
+          super
+        end
+
+        def destroy
+          requires :id
+          connection.delete_server(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 images
+          requires :id
+          connection.images(:server => self)
+        end
+
+        def private_key_path
+          @private_key_path ||= Fog.credentials[:private_key_path]
+          @private_key_path &&= File.expand_path(@private_key_path)
+        end
+
+        def private_key
+          @private_key ||= private_key_path && File.read(private_key_path)
+        end
+
+        def public_key_path
+          @public_key_path ||= Fog.credentials[:public_key_path]
+          @public_key_path &&= File.expand_path(@public_key_path)
+        end
+
+        def public_key
+          @public_key ||= public_key_path && File.read(public_key_path)
+        end
+
+        def ready?
+          status == 'ACTIVE'
+        end
+
+        def reboot(type = 'SOFT')
+          requires :id
+          connection.reboot_server(id, type)
+          true
+        end
+
+        def save
+          raise Fog::Errors::Error.new('Resaving an existing object may create a duplicate') if identity
+          requires :flavor_id, :image_id
+          options = {
+            'metadata'    => metadata,
+            'name'        => name,
+            'personality' => personality
+          }
+          options = options.reject {|key, value| value.nil?}
+          data = connection.create_server(flavor_id, image_id, options)
+          merge_attributes(data.body['server'])
+          true
+        end
+
+        def setup(credentials = {})
+          requires :addresses, :identity, :public_key, :username
+          Fog::SSH.new(addresses['public'].first, username, credentials).run([
+            %{mkdir .ssh},
+            %{echo "#{public_key}" >> ~/.ssh/authorized_keys},
+            %{passwd -l root},
+            %{echo "#{attributes.to_json}" >> ~/attributes.json},
+            %{echo "#{metadata.to_json}" >> ~/metadata.json}
+          ])
+        rescue Errno::ECONNREFUSED
+          sleep(1)
+          retry
+        end
+
+        def ssh(commands)
+          requires :addresses, :identity, :username
+
+          options = {}
+          options[:key_data] = [private_key] if private_key
+          Fog::SSH.new(addresses['public'].first, username, options).run(commands)
+        end
+
+        def username
+          @username ||= 'root'
+        end
+
+        private
+
+        def adminPass=(new_admin_pass)
+          @password = new_admin_pass
+        end
+
+      end
+
+    end
+  end
+
+end

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

@@ -0,0 +1,36 @@
+require 'fog/core/collection'
+require 'fog/compute/models/rackspace/server'
+
+module Fog
+  module Rackspace
+    class Compute
+
+      class Servers < Fog::Collection
+
+        model Fog::Rackspace::Compute::Server
+
+        def all
+          data = connection.list_servers_detail.body['servers']
+          load(data)
+        end
+
+        def bootstrap(new_attributes = {})
+          server = create(new_attributes)
+          server.wait_for { ready? }
+          server.setup(:password => server.password)
+          server
+        end
+
+        def get(server_id)
+          if server = connection.get_server_details(server_id).body['server']
+            new(server)
+          end
+        rescue Fog::Rackspace::Compute::NotFound
+          nil
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+require 'fog/core/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/compute/models/slicehost/flavors.rb

@@ -0,0 +1,28 @@
+require 'fog/core/collection'
+require 'fog/compute/models/slicehost/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/compute/models/slicehost/image.rb

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

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

@@ -0,0 +1,27 @@
+require 'fog/core/collection'
+require 'fog/compute/models/slicehost/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/compute/models/slicehost/server.rb

@@ -0,0 +1,112 @@
+require 'fog/core/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 :progress
+        attribute :status
+
+        attr_accessor :password
+        alias_method :'root-password=', :password=
+        attr_writer :private_key, :private_key_path, :public_key, :public_key_path, :username
+
+        def initialize(attributes={})
+          self.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 private_key_path
+          @private_key_path ||= Fog.credentials[:private_key_path]
+          @private_key_path &&= File.expand_path(@private_key_path)
+        end
+
+        def private_key
+          @private_key ||= private_key_path && File.read(private_key_path)
+        end
+
+        def public_key_path
+          @public_key_path ||= Fog.credentials[:public_key_path]
+          @public_key_path &&= File.expand_path(@public_key_path)
+        end
+
+        def public_key
+          @public_key ||= public_key_path && File.read(public_key_path)
+        end
+
+        def ready?
+          status == 'active'
+        end
+
+        def reboot(type = 'SOFT')
+          requires :id
+          connection.reboot_slice(id, type)
+          true
+        end
+
+        def save
+          raise Fog::Errors::Error.new('Resaving an existing object may create a duplicate') if identity
+          requires :flavor_id, :image_id, :name
+
+          data = connection.create_slice(flavor_id, image_id, name)
+          merge_attributes(data.body)
+          true
+        end
+
+        def setup(credentials = {})
+          requires :addresses, :identity, :public_key, :username
+          Fog::SSH.new(addresses.first, username, credentials).run([
+            %{mkdir .ssh},
+            %{echo "#{public_key}" >> ~/.ssh/authorized_keys},
+            %{passwd -l root},
+            %{echo "#{attributes.to_json}" >> ~/attributes.json}
+          ])
+        rescue Errno::ECONNREFUSED
+          sleep(1)
+          retry
+        end
+
+        def ssh(commands)
+          requires :addresses, :identity, :username
+
+          options = {}
+          options[:key_data] = [private_key] if private_key
+          Fog::SSH.new(addresses.first, username, options).run(commands)
+        end
+
+        def username
+          @username ||= 'root'
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+require 'fog/core/collection'
+require 'fog/compute/models/slicehost/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 bootstrap(new_attributes = {})
+          server = create(new_attributes)
+          server.wait_for { ready? }
+          server.setup(:password => server.password)
+          server
+        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