fog-cosmic 0.1.0

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

@@ -0,0 +1,17 @@
+module Fog
+  module Cosmic
+    class Compute
+      class Address < Fog::Model
+        identity  :id,            :aliases => 'id'
+        attribute :network_id,    :aliases => 'networkid'
+        attribute :ip_address,    :aliases => 'ipaddress'
+        attribute :traffic_type,  :aliases => 'traffictype'
+        attribute :is_default,    :aliases => 'isdefault'
+        attribute :mac_address,   :aliases => 'macaddress'
+        attribute :netmask
+        attribute :gateway
+        attribute :type
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+module Fog
+  module Cosmic
+    class Compute
+      class DiskOffering < Fog::Model
+        identity  :id,              :aliases => 'id'
+        attribute :created
+        attribute :disk_size,       :aliases => 'disk_size'
+        attribute :display_text,    :aliases => 'display_text'
+        attribute :domain
+        attribute :domain_id,       :aliases => 'domainid'
+        attribute :is_customized,   :aliases => 'iscustomized'
+        attribute :name
+        attribute :storage_type,    :aliases => 'storagetype'
+        attribute :tags
+
+        def save
+          requires :display_text, :name
+
+          options = {
+            'displaytext' => display_text,
+            'name'        => name,
+            'customized'  => is_customized,
+            'disksize'    => disk_size,
+            'domain_id'   => domain_id,
+            'storagetype' => storage_type,
+            'tags'        => tags
+          }
+
+          response = service.create_disk_offering(options)
+          merge_attributes(response['creatediskofferingresponse'])
+        end
+
+        def destroy
+          requires :id
+
+          response = service.delete_disk_offering('id' => id )
+          success_status = response['deletediskofferingresponse']['success']
+
+          success_status == 'true'
+        end
+      end # DiskOffering
+    end # Cosmic
+  end # Compute
+end # Fog

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

@@ -0,0 +1,24 @@
+require 'fog/core/collection'
+require 'fog/cosmic/models/compute/disk_offering'
+
+module Fog
+  module Cosmic
+    class Compute
+      class DiskOfferings < Fog::Collection
+        model Fog::Cosmic::Compute::DiskOffering
+
+        def all(options = {})
+          response = service.list_disk_offerings(options)
+          disk_offerings_data = response["listdiskofferingsresponse"]["diskoffering"] || []
+          load(disk_offerings_data)
+        end
+
+        def get(disk_offering_id)
+          response = service.list_disk_offerings('id' => disk_offering_id)
+          disk_offering_data = response["listdiskofferingsresponse"]["diskoffering"].first
+          new(disk_offering_data)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+module Fog
+  module Cosmic
+    class Compute
+      class EgressFirewallRule < Fog::Model
+        identity  :id,                    :aliases => 'id'
+        attribute :protocol,              :aliases => 'protocol'
+        attribute :network_id,            :aliases => 'networkid'
+        attribute :state,                 :aliases => 'state'
+        attribute :cidr_list,             :aliases => 'cidrlist'
+        attribute :tags,                  :type => :array
+        attribute :job_id,                :aliases => 'jobid'   # only on create
+
+        def save
+          requires :protocol, :network_id
+
+          options = {
+            'protocol'    => protocol,
+            'networkid'   => network_id,
+            'cidrlist'    => cidr_list,
+          }
+
+          response = service.create_egress_firewall_rule(options)
+          merge_attributes(response['createegressfirewallruleresponse'])
+        end
+
+        def destroy
+          requires :id
+
+          response = service.delete_egress_firewall_rule('id' => id )
+          success_status = response['deleteegressfirewallruleresponse']['success']
+
+          success_status == 'true'
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+require 'fog/core/collection'
+require 'fog/cosmic/models/compute/egress_firewall_rule'
+
+module Fog
+  module Cosmic
+    class Compute
+      class EgressFirewallRules < Fog::Collection
+        model Fog::Cosmic::Compute::EgressFirewallRule
+
+        def all(options = {})
+          response = service.list_egress_firewall_rules(options)
+          egress_firewall_rules = response["listegressfirewallrulesresponse"]["firewallrule"] || []
+          load(egress_firewall_rules)
+        end
+
+        def get(address_id)
+          options = { 'id' => address_id }
+          response = service.list_egress_firewall_rules(options)
+          egress_firewall_rules = response["listegressfirewallrulesresponse"]["firewallrule"].first
+          new(egress_firewall_rules)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+module Fog
+  module Cosmic
+    class Compute
+      class FirewallRule < Fog::Model
+        identity  :id,                    :aliases => 'id'
+        attribute :cidr_list,             :aliases => 'cidrlist'
+        attribute :start_port,            :aliases => 'startport', :type => :integer
+        attribute :end_port,              :aliases => 'endport', :type => :integer
+        attribute :icmp_code,             :aliases => 'icmpcode'
+        attribute :icmp_type,             :aliases => 'icmptype'
+        attribute :ip_address,            :aliases => 'ipaddress'
+        attribute :ip_address_id,         :aliases => 'ipaddressid'
+        attribute :network_id,            :aliases => 'networkid'
+        attribute :protocol
+        attribute :state
+        attribute :tags,                  :type => :array
+
+        # def save
+        # end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+require 'fog/core/collection'
+require 'fog/cosmic/models/compute/firewall_rule'
+
+module Fog
+  module Cosmic
+    class Compute
+      class FirewallRules < Fog::Collection
+        model Fog::Cosmic::Compute::FirewallRule
+
+        def all(options = {})
+          response = service.list_firewall_rules(options)
+          firewall_rules = response["listfirewallrulesresponse"]["firewallrule"] || []
+          load(firewall_rules)
+        end
+
+        def get(address_id)
+          options = { 'id' => address_id }
+          response = service.list_firewall_rules(options)
+          firewall_rules = response["listfirewallrulesresponse"]["firewallrule"].first
+          new(firewall_rules)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+module Fog
+  module Cosmic
+    class Compute
+      class Flavor < Fog::Model
+        identity  :id,              :aliases => 'id'
+        attribute :cpu_number,      :aliases => 'cpunumber'
+        attribute :cpu_speed,       :aliases => 'cpuspeed'
+        attribute :created,         :type => :time
+        attribute :default_use,     :aliases => 'defaultuse'
+        attribute :display_text,    :aliases => 'display_text'
+        attribute :domain
+        attribute :host_tags,       :aliases => 'host_tags'
+        attribute :is_system,       :aliases => 'issystem', :type => :boolean
+        attribute :is_volatile,     :aliases => 'isvolatile', :type => :boolean
+        attribute :is_customized,   :aliases => 'iscustomized', :type => :boolean
+        attribute :limit_cpu_use,   :aliases => 'limitcpuuse'
+        attribute :tags
+        attribute :system_vm_type,  :aliases => 'systemvm'
+        attribute :storage_type,    :aliases => 'storagetype'
+        attribute :offer_ha,        :aliases => 'offerha'
+        attribute :network_rate,    :aliases => 'networkrate'
+        attribute :name
+        attribute :memory
+
+        def save
+          raise Fog::Errors::Error.new('Creating a flavor is not supported')
+        end
+
+        def destroy
+          raise Fog::Errors::Error.new('Destroying a flavor is not supported')
+        end
+
+      end # Flavor
+    end # Cosmic
+  end # Compute
+end # Fog

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

@@ -0,0 +1,25 @@
+require 'fog/core/collection'
+require 'fog/cosmic/models/compute/flavor'
+
+module Fog
+  module Cosmic
+    class Compute
+      class Flavors < Fog::Collection
+        model Fog::Cosmic::Compute::Flavor
+
+        def all
+          data = service.list_service_offerings["listserviceofferingsresponse"]["serviceoffering"] || []
+          load(data)
+        end
+
+        def get(flavor_id)
+          if flavor = service.list_service_offerings('id' => flavor_id)["listserviceofferingsresponse"]["serviceoffering"].first
+            new(flavor)
+          end
+        rescue Fog::Cosmic::Compute::BadRequest
+          nil
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,72 @@
+module Fog
+  module Cosmic
+    class Compute
+      class Image < Fog::Model
+        identity  :id,                 :aliases => 'id'
+        attribute :account
+        attribute :account_id,         :aliases => 'accountid'
+        attribute :bootable
+        attribute :checksum
+        attribute :created,            :type => :time
+        attribute :cross_zones,        :aliases => 'crossZones'
+        attribute :details
+        attribute :display_text,       :aliases => 'displaytext'
+        attribute :domain
+        attribute :domain_id,          :aliases => 'domainid'
+        attribute :format
+        attribute :host_id,            :aliases => 'hostid'
+        attribute :host_name,          :aliases => 'hostname'
+        attribute :hypervisor
+        attribute :job_id,             :aliases => 'jobid'
+        attribute :job_status,         :aliases => 'jobstatus'
+        attribute :is_extractable,     :aliases => 'isextractable', :type => :boolean
+        attribute :is_featured,        :aliases => 'isfeatured', :type => :boolean
+        attribute :is_public,          :aliases => 'ispublic', :type => :boolean
+        attribute :is_ready,           :aliases => 'isready', :type => :boolean
+        attribute :name
+        attribute :os_type_id,         :aliases => 'ostypeid'
+        attribute :os_type_name,       :aliases => 'ostypename'
+        attribute :password_enabled,   :aliases => 'passwordenabled'
+        attribute :project
+        attribute :project_id,         :aliases => 'projectid'
+        attribute :removed
+        attribute :size
+        attribute :source_template_id, :aliases => 'sourcetemplateid'
+        attribute :status
+        attribute :template_tag,       :aliases => 'templatetag'
+        attribute :template_type,      :aliases => 'templatetype'
+        attribute :zone_id,            :aliases => 'zoneid'
+        attribute :zone_name,          :aliases => 'zonename'
+
+        attr_accessor :bits, :requires_hvm, :snapshot_id, :url, :virtual_machine_id, :volume_id
+
+        def save
+          options = {
+            'displaytext'      => display_text,
+            'name'             => name,
+            'ostypeid'         => os_type_id,
+            'bits'             => bits,
+            'details'          => details,
+            'isfeatured'       => is_featured,
+            'ispublic'         => is_public,
+            'passwordenabled'  => password_enabled,
+            'requireshvm'      => requires_hvm,
+            'snapshotid'       => snapshot_id,
+            'templatetag'      => template_tag,
+            'url'              => url,
+            'virtualmachineid' => virtual_machine_id,
+            'volumeid'         => volume_id
+          }
+          data = service.create_template(options)
+          merge_attributes(data['createtemplateresponse'])
+        end
+
+        def destroy
+          requires :id
+          service.delete_template('id' => self.id)
+          true
+        end
+      end # Server
+    end # Cosmic
+  end # Compute
+end # Fog

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

@@ -0,0 +1,37 @@
+require 'fog/core/collection'
+require 'fog/cosmic/models/compute/image'
+
+module Fog
+  module Cosmic
+    class Compute
+      class Images < Fog::Collection
+        model Fog::Cosmic::Compute::Image
+
+        def all(filters={})
+          options = get_filter_options(filters)
+          data = service.list_templates(options)["listtemplatesresponse"]["template"] || []
+          load(data)
+        end
+
+        def get(template_id, filters={})
+          filter_option = get_filter_options(filters)
+          options = filter_option.merge('id' => template_id)
+          if template = service.list_templates(options)["listtemplatesresponse"]["template"].first
+            new(template)
+          end
+        rescue Fog::Cosmic::Compute::BadRequest
+          nil
+        end
+
+        private
+
+        def get_filter_options(filters)
+          default_filter = {
+              'templatefilter' => 'self'
+          }
+          default_filter.merge(filters)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+module Fog
+  module Cosmic
+    class Compute
+      class Job < Fog::Model
+        identity  :id,              :aliases => 'jobid'
+        attribute :user_id,         :aliases => 'userid'
+        attribute :account_id,      :aliases => 'accountid'
+        attribute :cmd
+        attribute :job_status,      :aliases => 'jobstatus',     :type => :integer
+        attribute :job_result_type, :aliases => 'jobresulttype'
+        attribute :job_result_code, :aliases => 'jobresultcode', :type => :integer
+        attribute :job_proc_status, :aliases => 'jobprocstatus', :type => :integer
+
+        attribute :created_at,      :aliases => 'created',       :type => :time
+        attribute :job_result,      :aliases => 'jobresult'
+
+        def reload
+          requires :id
+          merge_attributes(service.query_async_job_result('jobid' => self.id)['queryasyncjobresultresponse'])
+        end
+
+        def ready?
+          self.job_status != 0
+        end
+
+        def successful?
+          self.job_result_code == 0
+        end
+
+        # so dirty
+        def result
+          if successful? && model = Fog::Cosmic::Compute.constants.find{|c| c.to_s.downcase == self.job_result.keys.first.to_s}.to_s
+            collection = model.gsub(/.[A-Z]/){|w| "#{w[0,1]}_#{w[1,1].downcase}"}.downcase + "s" # cheap underscorize, assume simple pluralization
+            service.send(collection).new(self.job_result.values.first)
+          else self.job_result
+          end
+        end
+
+        def save
+          raise Fog::Errors::Error.new('Creating a job is not supported')
+        end
+
+        def destroy
+          raise Fog::Errors::Error.new('Destroying a job is not supported')
+        end
+
+
+      end # Job
+    end # Cosmic
+  end # Compute
+end # Fog

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

@@ -0,0 +1,25 @@
+require 'fog/core/collection'
+require 'fog/cosmic/models/compute/job'
+
+module Fog
+  module Cosmic
+    class Compute
+      class Jobs < Fog::Collection
+        model Fog::Cosmic::Compute::Job
+
+        def all
+          data = service.list_async_jobs["listasyncjobsresponse"]["asyncjobs"] || []
+          load(data)
+        end
+
+        def get(job_id)
+          if job = service.query_async_job_result('jobid' => job_id)["queryasyncjobresultresponse"]
+            new(job)
+          end
+        rescue Fog::Cosmic::Compute::BadRequest
+          nil
+        end
+      end
+    end
+  end
+end