phpfog-fog 0.4.1

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

@@ -0,0 +1,58 @@
+require 'fog/core/model'
+
+module Fog
+  module AWS
+    class Compute
+
+      class Snapshot < Fog::Model
+        extend Fog::Deprecation
+        deprecate(:status, :state)
+
+        identity  :id,          :aliases => 'snapshotId'
+
+        attribute :description
+        attribute :progress
+        attribute :created_at,  :aliases => 'startTime'
+        attribute :owner_id,    :aliases => 'ownerId'
+        attribute :state,       :aliases => 'status'
+        attribute :tags,        :aliases => 'tagSet'
+        attribute :volume_id,   :aliases => 'volumeId'
+        attribute :volume_size, :aliases => 'volumeSize'
+
+        def destroy
+          requires :id
+
+          connection.delete_snapshot(id)
+          true
+        end
+
+        def ready?
+          state == 'completed'
+        end
+
+        def save
+          raise Fog::Errors::Error.new('Resaving an existing object may create a duplicate') if identity
+          requires :volume_id
+
+          data = connection.create_snapshot(volume_id, description).body
+          new_attributes = data.reject {|key,value| key == 'requestId'}
+          merge_attributes(new_attributes)
+          true
+        end
+
+        def volume
+          requires :id
+          connection.describe_volumes(volume_id)
+        end
+
+        private
+
+        def volume=(new_volume)
+          self.volume_id = new_volume.volume_id
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+require 'fog/core/collection'
+require 'fog/compute/models/aws/snapshot'
+
+module Fog
+  module AWS
+    class Compute
+
+      class Snapshots < Fog::Collection
+
+        attribute :filters
+        attribute :volume
+
+        model Fog::AWS::Compute::Snapshot
+
+        def initialize(attributes)
+          self.filters ||= { 'RestorableBy' => 'self' }
+          super
+        end
+
+        def all(filters = filters, options = {})
+          unless filters.is_a?(Hash)
+            Formatador.display_line("[yellow][WARN] all with #{filters.class} param is deprecated, use all('snapshot-id' => []) instead[/] [light_black](#{caller.first})[/]")
+            filters = {'snapshot-id' => [*filters]}
+          end
+          self.filters = filters
+          data = connection.describe_snapshots(filters.merge!(options)).body
+          load(data['snapshotSet'])
+          if volume
+            self.replace(self.select {|snapshot| snapshot.volume_id == volume.id})
+          end
+          self
+        end
+        
+        def get(snapshot_id)
+          if snapshot_id
+            self.class.new(:connection => connection).all('snapshot-id' => snapshot_id).first
+          end
+        end
+
+        def new(attributes = {})
+          if volume
+            super({ 'volumeId' => volume.id }.merge!(attributes))
+          else
+            super
+          end
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+require 'fog/core/model'
+
+module Fog
+  module AWS
+    class Compute
+
+      class Tag < Fog::Model
+
+        identity  :key
+
+        attribute :value
+        attribute :resource_id,           :aliases => 'resourceId'
+        attribute :resource_type,         :aliases => 'resourceType'        
+
+        def initialize(attributes = {})
+          super
+        end
+
+        def destroy
+          requires :key, :resource_id
+          connection.delete_tags(resource_id, key)
+          true
+        end
+
+        def save
+          requires :key, :resource_id
+          connection.create_tags(resource_id, key => value)
+          true
+        end
+
+        private
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+require 'fog/core/collection'
+require 'fog/compute/models/aws/tag'
+
+module Fog
+  module AWS
+    class Compute
+
+      class Tags < Fog::Collection
+
+        attribute :filters
+
+        model Fog::AWS::Compute::Tag
+
+        def initialize(attributes)
+          self.filters ||= {}
+          super
+        end
+
+        def all(filters = filters)
+          self.filters = filters
+          data = connection.describe_tags(filters).body
+          load(data['tagSet'])
+        end
+        
+        def get(key)
+          if key
+            self.class.new(:connection => connection).all('key' => key)
+          end
+        end
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,109 @@
+require 'fog/core/model'
+
+module Fog
+  module AWS
+    class Compute
+
+      class Volume < Fog::Model
+        extend Fog::Deprecation
+        deprecate(:status, :state)
+
+        identity  :id,                    :aliases => 'volumeId'
+
+        attribute :attached_at,           :aliases => 'attachTime'
+        attribute :availability_zone,     :aliases => 'availabilityZone'
+        attribute :created_at,            :aliases => 'createTime'
+        attribute :delete_on_termination, :aliases => 'deleteOnTermination'
+        attribute :device
+        attribute :server_id,             :aliases => 'instanceId'
+        attribute :size
+        attribute :snapshot_id,           :aliases => 'snapshotId'
+        attribute :state,                 :aliases => 'status'
+        attribute :tags,                  :aliases => 'tagSet'
+
+        def initialize(attributes = {})
+          # assign server first to prevent race condition with new_record?
+          self.server = attributes.delete(:server)
+          super
+        end
+
+        def destroy
+          requires :id
+
+          connection.delete_volume(id)
+          true
+        end
+
+        def ready?
+          state == 'available'
+        end
+
+        def save
+          raise Fog::Errors::Error.new('Resaving an existing object may create a duplicate') if identity
+          requires :availability_zone, :size
+
+          data = connection.create_volume(availability_zone, size, snapshot_id).body
+          new_attributes = data.reject {|key,value| key == 'requestId'}
+          merge_attributes(new_attributes)
+          if @server
+            self.server = @server
+          end
+          true
+        end
+
+        def server=(new_server)
+          if new_server
+            attach(new_server)
+          else
+            detach
+          end
+        end
+
+        def snapshots
+          requires :id
+          connection.snapshots(:volume => self)
+        end
+
+        private
+
+        def attachmentSet=(new_attachment_set)
+          merge_attributes(new_attachment_set.first || {})
+        end
+
+        def attach(new_server)
+          if new_record?
+            @server = new_server
+            self.availability_zone = new_server.availability_zone
+          elsif new_server
+            requires :device
+            @server = nil
+            self.server_id = new_server.id
+            connection.attach_volume(server_id, id, device)
+            reload
+          end
+        end
+
+        def detach
+          @server = nil
+          self.server_id = nil
+          unless new_record?
+            connection.detach_volume(id)
+            reload
+          end
+        end
+
+        def force_detach
+          @server = nil
+          self.server_id = nil
+          unless new_record?
+            connection.detach_volume(id, 'Force' => true)
+            reload
+          end
+        end
+
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,121 @@
+require 'fog/core/collection'
+require 'fog/compute/models/aws/volume'
+
+module Fog
+  module AWS
+    class Compute
+
+      class Volumes < Fog::Collection
+
+        attribute :filters
+        attribute :server
+
+        model Fog::AWS::Compute::Volume
+
+        # Used to create a volume.  There are 3 arguments and availability_zone and size are required.  You can generate a new key_pair as follows:
+        # AWS.volumes.create(:availability_zone => 'us-east-1a', :size => 't1.micro')
+        #
+        # ==== Returns
+        #
+        #<Fog::AWS::Compute::Volume
+        #  id="vol-1e2028b9",
+        #  attached_at=nil,
+        #  availability_zone="us-east-1a",
+        #  created_at=Tue Nov 23 23:30:29 -0500 2010,
+        #  delete_on_termination=nil,
+        #  device=nil,
+        #  server_id=nil,
+        #  size="t1.micro",
+        #  snapshot_id=nil,
+        #  state="creating",
+        #  tags=nil
+        #>
+        #
+        # The volume can be retreived by running AWS.volumes.get("vol-1e2028b9").  See get method below.
+        #
+
+        def initialize(attributes)
+          self.filters ||= {}
+          super
+        end
+
+        # Used to return all volumes.
+        # AWS.volumes.all
+        #
+        # ==== Returns
+        #
+        #>>AWS.volumes.all
+        #<Fog::AWS::Compute::Volume
+        #  id="vol-1e2028b9",
+        #  attached_at=nil,
+        #  availability_zone="us-east-1a",
+        #  created_at=Tue Nov 23 23:30:29 -0500 2010,
+        #  delete_on_termination=nil,
+        #  device=nil,
+        #  server_id=nil,
+        #  size="t1.micro",
+        #  snapshot_id=nil,
+        #  state="creating",
+        #  tags=nil
+        #>
+        #
+        # The volume can be retreived by running AWS.volumes.get("vol-1e2028b9").  See get method below.
+        #
+
+        def all(filters = filters)
+          unless filters.is_a?(Hash)
+            Formatador.display_line("[yellow][WARN] all with #{filters.class} param is deprecated, use all('volume-id' => []) instead[/] [light_black](#{caller.first})[/]")
+            filters = {'volume-id' => [*filters]}
+          end
+          self.filters = filters
+          data = connection.describe_volumes(filters).body
+          load(data['volumeSet'])
+          if server
+            self.replace(self.select {|volume| volume.server_id == server.id})
+          end
+          self
+        end
+
+        # Used to retreive a volume
+        # volume_id is required to get the associated volume information.
+        #
+        # You can run the following command to get the details:
+        # AWS.volumes.get("vol-1e2028b9")
+        #
+        # ==== Returns
+        #
+        #>> AWS.volumes.get("vol-1e2028b9")
+        # <Fog::AWS::Compute::Volume
+        #    id="vol-1e2028b9",
+        #    attached_at=nil,
+        #    availability_zone="us-east-1a",
+        #    created_at=Tue Nov 23 23:30:29 -0500 2010,
+        #    delete_on_termination=nil,
+        #    device=nil,
+        #    server_id=nil,
+        #    size="t1.micro",
+        #    snapshot_id=nil,
+        #    state="available",
+        #    tags={}
+        #  >
+        #
+
+        def get(volume_id)
+          if volume_id
+            self.class.new(:connection => connection).all('volume-id' => volume_id).first
+          end
+        end
+
+        def new(attributes = {})
+          if server
+            super({ :server => server }.merge!(attributes))
+          else
+            super
+          end
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+require 'fog/core/model'
+
+module Fog
+  module Bluebox
+    class Compute
+
+      class Flavor < Fog::Model
+
+        identity :id
+
+        attribute :name
+        attribute :cost
+        attribute :description
+
+        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/bluebox/flavors.rb

@@ -0,0 +1,28 @@
+require 'fog/core/collection'
+require 'fog/compute/models/bluebox/flavor'
+
+module Fog
+  module Bluebox
+    class Compute
+
+      class Flavors < Fog::Collection
+
+        model Fog::Bluebox::Compute::Flavor
+
+        def all
+          data = connection.get_products.body
+          load(data)
+        end
+
+        def get(product_id)
+          response = connection.get_product(product_id)
+          new(response.body)
+        rescue Fog::Bluebox::Compute::NotFound
+          nil
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+require 'fog/core/model'
+
+module Fog
+  module Bluebox
+    class Compute
+
+      class Image < Fog::Model
+
+        identity :id
+
+        attribute :description
+        attribute :public
+        attribute :created_at, :aliases => 'created'
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+require 'fog/core/collection'
+require 'fog/compute/models/bluebox/image'
+
+module Fog
+  module Bluebox
+    class Compute
+
+      class Images < Fog::Collection
+
+        model Fog::Bluebox::Compute::Image
+
+        def all
+          data = connection.get_templates.body
+          load(data)
+        end
+
+        def get(template_id)
+          response = connection.get_template(template_id)
+          new(response.body)
+        rescue Fog::Bluebox::Compute::NotFound
+          nil
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,126 @@
+require 'fog/core/model'
+
+module Fog
+  module Bluebox
+    class Compute
+
+      class BlockInstantiationError < StandardError; end
+
+      class Server < Fog::Model
+        extend Fog::Deprecation
+        deprecate(:ssh_key, :public_key)
+        deprecate(:ssh_key=, :public_key=)
+        deprecate(:user, :username)
+        deprecate(:user=, :username=)
+
+        identity :id
+
+        attribute :cpu
+        attribute :description
+        attribute :flavor_id,   :aliases => :product, :squash => 'id'
+        attribute :hostname
+        attribute :image_id
+        attribute :ips
+        attribute :memory
+        attribute :status
+        attribute :storage
+        attribute :template
+
+        attr_accessor :password
+        attr_writer :private_key, :private_key_path, :public_key, :public_key_path, :username
+
+        def initialize(attributes={})
+          self.flavor_id ||= '94fd37a7-2606-47f7-84d5-9000deda52ae'
+          super
+        end
+
+        def destroy
+          requires :id
+          connection.destroy_block(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 == 'running'
+        end
+
+        def reboot(type = 'SOFT')
+          requires :id
+          connection.reboot_block(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 = if !password && !public_key
+            raise(ArgumentError, "password or public_key is required for this operation")
+          elsif public_key
+            {'ssh_public_key' => public_key}
+          elsif @password
+            {'password' => password}
+          end
+          options['username'] = username
+          data = connection.create_block(flavor_id, image_id, options)
+          merge_attributes(data.body)
+          true
+        end
+
+        def setup(credentials = {})
+          requires :identity, :ips, :public_key, :username
+          Fog::SSH.new(ips.first['address'], 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 :identity, :ips, :username
+
+          options = {}
+          options[:key_data] = [private_key] if private_key
+          Fog::SSH.new(ips.first['address'], username, options).run(commands)
+        end
+
+        def username
+          @username ||= 'deploy'
+        end
+
+      end
+
+    end
+  end
+end

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

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