fog-cosmic 0.1.0

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

@@ -0,0 +1,151 @@
+require 'fog/compute/models/server'
+
+module Fog
+  module Cosmic
+    class Compute
+      class Server < Fog::Compute::Server
+        identity  :id,                                      :aliases => 'id'
+        attribute :name
+        attribute :account_name,                            :aliases => 'account'
+        attribute :domain_name,                             :aliases => 'domain'
+        attribute :created,              :type => :time
+        attribute :state
+        attribute :haenable
+        attribute :memory
+        attribute :display_name,                            :aliases => 'displayname'
+        attribute :domain_id,                               :aliases => 'domainid'
+        attribute :host_id,                                 :aliases => 'hostid'
+        attribute :host_name,                               :aliases => 'hostname'
+        attribute :project_id,                              :aliases => 'projectid'
+        attribute :zone_id,                                 :aliases => 'zoneid'
+        attribute :zone_name,                               :aliases => 'zonename'
+        attribute :image_id,                                :aliases => ['templateid', :template_id]
+        attribute :image_name,                              :aliases => ['templatename', :template_name]
+        attribute :templated_display_text,                  :aliases => 'templatedisplaytext'
+        attribute :password_enabled,                        :aliases => 'passwordenabled'
+        attribute :flavor_id,                               :aliases => ['serviceofferingid', :service_offering_id]
+        attribute :flavor_name,                             :aliases => ['serviceofferingname', :service_offering_name]
+        attribute :affinity_group_ids,                      :aliases => 'affinitygroupids'
+        attribute :affinity_group_names,                    :aliases => 'affinitygroupnames'
+        attribute :cpu_number,                              :aliases => 'cpunumber'
+        attribute :cpu_speed,                               :aliases => 'cpuspeed'
+        attribute :cpu_used,                                :aliases => 'cpuused'
+        attribute :network_kbs_read,                        :aliases => 'networkkbsread'
+        attribute :network_kbs_write,                       :aliases => 'networkkbswrite'
+        attribute :guest_os_id,                             :aliases => 'guestosid'
+        attribute :root_device_id,                          :aliases => 'rootdeviceid'
+        attribute :root_device_type,                        :aliases => 'rootdevicetype'
+        attribute :group
+        attribute :key_name,                                :aliases => 'keypair'
+        attribute :user_data,                                :aliases => 'userdata'
+        attribute :nics,                   :type => :array, :aliases => 'nic'
+        attribute :job_id,                                  :aliases => 'jobid'   # only on create
+        attribute :size,                   :type => :integer
+        attribute :root_disk_size,         :type => :integer
+
+        attr_accessor :network_ids, :disk_offering_id, :ip_address, :ip_to_network_list
+
+        alias_method :public_ip_address, :ip_address
+        alias_method :public_ip_address=, :ip_address=
+
+        def addresses
+          nics.map{|nic| Address.new(nic)}
+        end
+
+        def ip_addresses
+          addresses.map(&:ip_address)
+        end
+
+        def volumes
+          requires :id
+          service.volumes.all('virtualmachineid' => id)
+        end
+
+        def reset_password
+          requires :id
+          data = service.reset_password_for_virtual_machine(id)
+          service.jobs.new(data['resetpasswordforvirtualmachineresponse'])
+        end
+
+        def public_ip_addresses
+          if public_ip_address.nil? then [public_ip_address] else [] end
+        end
+
+        def private_ip_addresses
+          ip_addresses - public_ip_addresses
+        end
+
+        def private_ip_address
+          private_ip_addresses.first
+        end
+
+        def destroy(options={})
+          requires :id
+          data = service.destroy_virtual_machine(options.merge({'id'=> self.id}))
+          service.jobs.new(data["destroyvirtualmachineresponse"])
+        end
+
+        def flavor
+          service.flavors.get(self.flavor_id)
+        end
+
+        def ready?
+          state == 'Running'
+        end
+
+        def reboot
+          requires :id
+          data = service.reboot_virtual_machine('id' => self.id) # FIXME: does this ever fail?
+          service.jobs.new(data["rebootvirtualmachineresponse"])
+        end
+
+        def save
+          requires :image_id, :flavor_id, :zone_id
+
+          options = {
+            'templateid'        => image_id,
+            'serviceofferingid' => flavor_id,
+            'zoneid'            => zone_id,
+            'networkids'        => network_ids,
+            'diskofferingid'    => disk_offering_id,
+            'name'              => name,
+            'displayname'       => display_name,
+            'group'             => group,
+            'domainid'          => domain_id,
+            'hostid'            => host_id,
+            'ipaddress'         => ip_address,
+            'iptonetworklist'   => ip_to_network_list,
+            'projectid'         => project_id,
+            'keypair'           => key_name,
+            'userdata'          => user_data,
+            'size'              => size,
+          }
+
+          options.merge!('affinitygroupids' => affinity_group_ids) if affinity_group_ids
+          options.merge!('affinitygroupnames' => affinity_group_names) if affinity_group_names
+          options.merge!('rootdisksize' => root_disk_size) if root_disk_size
+          options.merge!('networkids' => network_ids) if network_ids
+
+          data = service.deploy_virtual_machine(options)
+          merge_attributes(data['deployvirtualmachineresponse'])
+        end
+
+        def start
+          requires :id
+          data = service.start_virtual_machine("id" => self.id)
+          service.jobs.new(data["startvirtualmachineresponse"])
+        end
+
+        def stop(options={})
+          requires :id
+          unless options.is_a?(Hash)
+            Fog::Logger.deprecation("Passing force as a boolean option has been deprecated. Please pass a hash with 'force' => (true|false)")
+            options = {'force' => options}
+          end
+          data = service.stop_virtual_machine(options.merge({'id' => self.id}))
+          service.jobs.new(data["stopvirtualmachineresponse"])
+        end
+      end # Server
+    end # Cosmic
+  end # Compute
+end # Fog

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

@@ -0,0 +1,39 @@
+require 'fog/core/collection'
+require 'fog/cosmic/models/compute/server'
+
+module Fog
+  module Cosmic
+    class Compute
+      class Servers < Fog::Collection
+        model Fog::Cosmic::Compute::Server
+
+        def all(attributes={})
+          # add project id if we have one
+          response = service.list_virtual_machines(attributes)
+          data = response["listvirtualmachinesresponse"]["virtualmachine"] || []
+          load(data)
+        end
+
+        def bootstrap(new_attributes = {})
+          server = create(new_attributes)
+          server.wait_for { ready? }
+          server
+        end
+
+        def get(server_id)
+          attributes = {'id' => server_id}
+          # add project id if we have one
+          servers = service.list_virtual_machines(attributes)["listvirtualmachinesresponse"]["virtualmachine"]
+          if servers.nil? || servers.empty?
+            servers = service.list_virtual_machines('id' => server_id, 'projectid' => '-1')["listvirtualmachinesresponse"]["virtualmachine"]
+          end
+          unless servers.nil? || servers.empty?
+            new(servers.first)
+          end
+        rescue Fog::Cosmic::Compute::BadRequest
+          nil
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+module Fog
+  module Cosmic
+    class Compute
+      class Snapshot < Fog::Model
+        identity  :id,                         :aliases => 'id'
+
+        attribute :name,                       :aliases => 'name'
+        attribute :volume_type,                :aliases => 'volumetype'
+        attribute :volume_name,                :aliases => 'volumename'
+        attribute :volume_id,                  :aliases => 'volumeid'
+        attribute :created,                    :aliases => 'created'
+        attribute :state,                      :aliases => 'state'
+        attribute :account,                    :aliases => 'account'
+        attribute :domain_id,                  :aliases => 'domainid'
+        attribute :domain,                     :aliases => 'domain'
+        attribute :snapshot_type,              :aliases => 'snapshot_type'
+        attribute :interval_type,              :aliases => 'interval_type'
+
+        def save
+          requires :volume_id
+
+          options = {
+            'volumeid'      => volume_id,
+            'domainid'      => domain_id
+          }
+          data = service.create_snapshot(options)
+          merge_attributes(data['createsnapshotresponse'])
+        end
+
+        def ready?
+          state == 'BackedUp'
+        end
+
+        def volume
+          service.volumes.get(volume_id) if volume_id
+        end
+
+        def destroy
+          requires :id
+          service.delete_snapshot('id' => id)
+          true
+        end
+      end # Snapshot
+    end # Cosmic
+  end # Compute
+end # Fog

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

@@ -0,0 +1,23 @@
+require 'fog/core/collection'
+require 'fog/cosmic/models/compute/snapshot'
+
+module Fog
+  module Cosmic
+    class Compute
+      class Snapshots < Fog::Collection
+        model Fog::Cosmic::Compute::Snapshot
+
+        def all(attributes = {})
+          response = service.list_snapshots(attributes)
+          data = response["listsnapshotsresponse"]["snapshot"] || []
+          load(data)
+        end
+
+        def get(snapshot_id)
+          snapshot = service.list_snapshots('id' => snapshot_id)["listsnapshotsresponse"]["snapshot"].first
+          new(snapshot) if snapshot
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,121 @@
+module Fog
+  module Cosmic
+    class Compute
+      class Volume < Fog::Model
+        identity  :id,                         :aliases => 'id'
+
+        attribute :name,                       :aliases => 'name'
+        attribute :zone_id,                    :aliases => 'zoneid'
+        attribute :zone_name,                  :aliases => 'zonename'
+        attribute :type,                       :aliases => 'type'
+        attribute :size,                       :aliases => 'size'
+        attribute :created,                    :aliases => 'created'
+        attribute :state,                      :aliases => 'state'
+        attribute :account,                    :aliases => 'account'
+        attribute :domain_id,                  :aliases => 'domainid'
+        attribute :domain,                     :aliases => 'domain'
+        attribute :storage_type,               :aliases => 'storagetype'
+        attribute :hypervisor,                 :aliases => 'hypervisor'
+        attribute :disk_offering_id,           :aliases => 'diskofferingid'
+        attribute :disk_offering_name,         :aliases => 'diskofferingname'
+        attribute :disk_offering_display_text, :aliases => 'diskofferingdisplaytext'
+        attribute :storage,                    :aliases => 'storage'
+        attribute :destroyed,                  :aliases => 'destroyed'
+        attribute :is_extractable,             :aliases => 'isextractable', :type => :boolean
+        attribute :server_id,                  :aliases => 'virtualmachineid'
+        attribute :server_name,                :aliases => 'vmname'
+        attribute :server_display_name,        :aliases => 'vmdisplayname'
+        attribute :job_id,                     :aliases => 'jobid'   # only on create
+
+        attr_accessor :snapshot_id, :project_id
+
+        def save
+          requires :name, :disk_offering_id, :zone_id
+
+          options = {
+            'size'           => size,
+            'name'           => name,
+            'diskofferingid' => disk_offering_id,
+            'zoneid'         => zone_id,
+            'snapshotid'     => snapshot_id,
+            'projectid'      => project_id
+          }
+
+          data = service.create_volume(options)
+          merge_attributes(data['createvolumeresponse'])
+        end
+
+        def ready?
+          state == 'Allocated' || state == 'Ready'
+        end
+
+        def flavor
+          service.disk_offerings.get(self.disk_offering_id)
+        end
+        alias_method :disk_offering, :flavor
+
+        def server
+          if server_id
+            service.servers.get(server_id)
+          end
+        end
+
+        def snapshots
+          requires :id
+          service.snapshots.all('volumeid' => id)
+        end
+
+        def reload
+          requires :identity
+
+          return unless data = begin
+                                 collection.get(identity)
+                               rescue Excon::Errors::SocketError
+                                 nil
+                               end
+
+          new_attributes = {
+            'virtualmachineid' => nil,
+            'vmname' => nil,
+            'vmdisplayname' => nil
+          }.merge(data.attributes)
+
+          merge_attributes(new_attributes)
+          self
+        end
+
+        def attach(instance_or_id, mountpoint=nil)
+          requires :id
+          instance_id = instance_or_id.is_a?(Server) ? instance_or_id.id : instance_or_id
+          unless instance_id
+            raise ArgumentError, "Missing required argument: instance_or_id"
+          end
+
+          options = {
+            'id'               => id,
+            'virtualmachineid' => instance_id,
+          }
+          options.merge!('deviceid' => mountpoint) if mountpoint
+
+          data = service.attach_volume(options)
+
+					service.jobs.new(data["attachvolumeresponse"])
+        end
+
+        def detach
+          requires :id
+
+          data = service.detach_volume('id' => id)
+
+          service.jobs.new(data["detachvolumeresponse"])
+        end
+
+        def destroy
+          requires :id
+          service.delete_volume('id' => id)
+          true
+        end
+      end # Volume
+    end # Cosmic
+  end # Compute
+end # Fog

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

@@ -0,0 +1,26 @@
+require 'fog/core/collection'
+require 'fog/cosmic/models/compute/volume'
+
+module Fog
+  module Cosmic
+    class Compute
+      class Volumes < Fog::Collection
+        model Fog::Cosmic::Compute::Volume
+
+        def all(attributes = {})
+          response = service.list_volumes(attributes)
+          data = response["listvolumesresponse"]["volume"] || []
+          load(data)
+        end
+
+        def get(volume_id)
+          if volume = service.list_volumes('id' => volume_id)["listvolumesresponse"]["volume"].first
+            new(volume)
+          end
+        rescue Fog::Cosmic::Compute::BadRequest
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/fog/cosmic/models/compute/zone.rb

@@ -0,0 +1,36 @@
+module Fog
+  module Cosmic
+    class Compute
+      class Zone < Fog::Model
+        identity  :id,                          :aliases => 'id'
+        attribute :name
+        attribute :domain_id,                   :aliases => 'domainid'
+        attribute :domain_name,                 :aliases => ['domainname', 'domain']
+        attribute :network_type,                :aliases => 'networktype'
+        attribute :allocation_state,            :aliases => 'allocationstate'
+        attribute :zone_token,                  :aliases => 'zonetoken'
+        attribute :dhcp_provider,               :aliases => 'dhcpprovider'
+
+        attr_accessor :dns1, :dns2, :internaldns1, :internaldns2, :guest_cidr_address
+
+        def save
+          options = {
+            'dns1'                  => dns1,
+            'internaldns1'          => internaldns1,
+            'name'                  => name,
+            'networktype'           => network_type,
+            'allocationstate'       => allocation_state,
+            'dns2'                  => dns2,
+            'domain'                => domain_name,
+            'domainid'              => domain_id,
+            'guestcidraddress'      => guest_cidr_address,
+            'internaldns2'          => internaldns2,
+          }
+          data = service.create_zone(options)
+          merge_attributes(data['createzoneresponse'])
+        end
+
+      end # Zone
+    end # Cosmic
+  end # Compute
+end # Fog