fog-cosmic 0.1.0

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

@@ -0,0 +1,73 @@
+module Fog
+  module Cosmic
+    class Compute
+      class Network < Fog::Model
+        identity  :id,                      :aliases => 'id'
+        attribute :name,                    :aliases => 'name'
+        attribute :display_text,            :aliases => 'displaytext'
+
+        attribute :broadcast_domain_type,   :aliases => 'broadcastdomaintype'
+        attribute :traffic_type,            :aliases => 'traffictype'
+        attribute :gateway,                 :aliases => 'gateway'
+        attribute :cidr,                    :aliases => 'cidr'
+        attribute :zone_id,                 :aliases => 'zoneid'
+        attribute :zone_name,               :aliases => 'zonename'
+
+        attribute :network_offering_id,            :aliases => 'networkofferingid'
+        attribute :network_offering_name,          :aliases => 'networkofferingname'
+        attribute :network_offering_display_text,  :aliases => 'networkofferingdisplaytext'
+        attribute :network_offering_conserve_mode, :aliases => 'networkofferingconservemode'
+        attribute :network_offering_availability,  :aliases => 'networkofferingavailability'
+        attribute :is_system,               :aliases => 'issystem', :type => :boolean
+        attribute :state,                   :aliases => 'state'
+
+        attribute :related,                 :aliases => 'related'
+        attribute :dns1,                    :aliases => 'dns1'
+        attribute :dns2,                    :aliases => 'dns2'
+        attribute :type,                    :aliases => 'type'
+        attribute :acl_type,                :aliases => 'acltype'
+        attribute :project_id,              :aliases => 'projectid'
+        attribute :domain_id,               :aliases => 'domainid'
+        attribute :domain,                  :aliases => 'domain'
+
+        # attribute :service,                 :aliases => 'service'
+        attribute :network_domain,          :aliases => 'domain'
+        attribute :physical_network_id,     :aliases => 'physicalnetworkid'
+        attribute :restart_required,        :aliases => 'restartrequired'
+        attribute :specify_ip_ranges,       :aliases => 'specifyipranges'
+        attribute :canuse_for_deploy,       :aliases => 'canusefordeploy'
+        attribute :is_persistent,           :aliases => 'ispersistent', :type => :boolean
+        attribute :display_network,         :aliases => 'displaynetwork'
+        attribute :is_default,              :aliases => 'isdefault', :type => :boolean
+
+        # restart network - will return a job
+        def restart(options={})
+            response = service.restart_network( options.merge({'id'=> self.id}))
+            service.jobs.new(response['restartnetworkresponse'])
+        end
+
+        # create a new network
+        def save
+          requires :display_text, :name, :network_offering_id, :zone_id
+
+          options = {
+            'displaytext'           => display_text,
+            'name'                  => name,
+            'zoneid'                => zone_id,
+            'networkofferingid'     => network_offering_id
+          }
+
+          response = service.create_network(options)
+          merge_attributes(response['createnetworkresponse']['network'])
+        end
+
+        # delete given network - will return a job
+        def destroy(options={})
+          response = service.delete_network(options.merge({'id'=> self.id}))
+          service.jobs.new(response["deletenetworkresponse"])
+        end
+
+      end # Network
+    end # Cosmic
+  end # Compute
+end # Fog

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

@@ -0,0 +1,25 @@
+module Fog
+  module Cosmic
+    class Compute
+      class NetworkOffering < Fog::Model
+        identity  :id,                      :aliases => 'id'
+        attribute :name,                    :aliases => 'name'
+        attribute :display_text,            :aliases => 'displaytext'
+        attribute :traffic_type,            :aliases => 'traffictype'
+        attribute :is_default,              :aliases => 'isdefault', :type => :boolean
+        attribute :specify_vlan,            :aliases => 'specifyvlan'
+        attribute :conserve_mode,           :aliases => 'conservemode'
+        attribute :specify_ip_ranges,       :aliases => 'specifyipranges'
+        attribute :availability,            :aliases => 'availability'
+        attribute :network_rate,            :aliases => 'networkrate'
+        attribute :state,                   :aliases => 'state'
+        attribute :guest_ip_type,           :aliases => 'guestiptype'
+        attribute :service_offering_id,     :aliases => 'serviceofferingid'
+        attribute :service,                 :aliases => 'service'
+        attribute :for_vpc,                 :aliases => 'forvpc'
+        attribute :is_persistent,           :aliases => 'ispersistent', :type => :boolean
+        attribute :egress_default_policy,   :aliases => 'egressdefaultpolicy'
+      end # NetworkOffering
+    end # Cosmic
+  end # Compute
+end # Fog

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

@@ -0,0 +1,39 @@
+
+
+require 'fog/core/collection'
+require 'fog/cosmic/models/compute/network_offering'
+
+module Fog
+  module Cosmic
+    class Compute
+      class NetworkOfferings < Fog::Collection
+        model Fog::Cosmic::Compute::NetworkOffering
+
+        def all(filters={})
+          options = get_filter_options(filters)
+          data = service.list_network_offerings(options)["listnetworkofferingsresponse"]["networkoffering"] || []
+          load(data)
+        end
+
+        def get(network_offering_id, filters={})
+          filter_option = get_filter_options(filters)
+          options = filter_option.merge('id' => network_offering_id)
+          if data = service.list_network_offerings(options)["listnetworkofferingsresponse"]["networkoffering"].first
+            new(data)
+          end
+        rescue Fog::Cosmic::Compute::BadRequest
+          nil
+        end
+
+        private
+
+        def get_filter_options(filters)
+          default_filter = {
+              'projectfilter' => 'self'
+          }
+          default_filter.merge(filters)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+
+require 'fog/core/collection'
+require 'fog/cosmic/models/compute/network'
+
+module Fog
+  module Cosmic
+    class Compute
+      class Networks < Fog::Collection
+        model Fog::Cosmic::Compute::Network
+
+        def all(filters={})
+          options = get_filter_options(filters)
+          data = service.list_networks(options)["listnetworksresponse"]["network"] || []
+          load(data)
+        end
+
+        def get(network_id, filters={})
+          filter_option = get_filter_options(filters)
+          options = filter_option.merge('id' => network_id)
+          if data = service.list_networks(options)["listnetworksresponse"]["network"].first
+            new(data)
+          end
+        rescue Fog::Cosmic::Compute::BadRequest
+          nil
+        end
+
+        private
+
+        def get_filter_options(filters)
+          default_filter = {
+              'projectfilter' => 'self'
+          }
+          default_filter.merge(filters)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+module Fog
+  module Cosmic
+    class Compute
+      class PortForwardingRule < Fog::Model
+        identity  :id,                      :aliases => 'id'
+
+        attribute :private_port,              :aliases => 'privateport'
+        attribute :private_end_port,          :aliases => 'privateendport'
+        attribute :protocol,                  :aliases => 'protocol'
+        attribute :public_port,               :aliases => 'publicport'
+        attribute :public_end_port,           :aliases => 'publicendport'
+        attribute :virtual_machine_id,        :aliases => 'virtualmachineid'
+        attribute :virtualmachinename,        :aliases => 'virtualmachinename'
+        attribute :virtualmachinedisplayname, :aliases => 'virtualmachinedisplayname'
+        attribute :ipaddressid,               :aliases => 'ipaddressid'
+        attribute :ipaddress,                 :aliases => 'ipaddress'
+        attribute :state,                     :aliases => 'state'
+        attribute :cidrlist,                  :aliases => 'cidrlist'
+        attribute :vmguestip,                 :aliases => 'vmguestip'
+        attribute :networkid,                 :aliases => 'networkid'
+        attribute :tags,                      :type => :array
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+require 'fog/core/collection'
+require 'fog/cosmic/models/compute/port_forwarding_rule'
+
+module Fog
+  module Cosmic
+    class Compute
+      class PortForwardingRules < Fog::Collection
+        model Fog::Cosmic::Compute::PortForwardingRule
+
+        def all(options = {})
+          response = service.list_port_forwarding_rules(options)
+          port_forwarding_rules = response["listportforwardingrulesresponse"]["portforwardingrule"] || []
+          load(port_forwarding_rules)
+        end
+
+        def get(address_id)
+          options = { 'id' => address_id }
+          response = service.list_port_forwarding_rules(options)
+          port_forwarding_rules = response["listportforwardingrulesresponse"]["portforwardingrule"].first
+          new(port_forwarding_rules)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+module Fog
+  module Cosmic
+    class Compute
+      class Project < Fog::Model
+        identity  :id,                  :aliases => 'id'
+        attribute :name,                :aliases => 'name'
+        attribute :display_text,        :aliases => 'displaytext'
+        attribute :domain_id,           :aliases => 'domainid'
+        attribute :domain,              :aliases => 'domain'
+        attribute :account,             :aliases => 'account'
+        attribute :state,               :aliases => 'state'
+        attribute :tags,                :aliases => 'tags'
+        attribute :network_limit,       :aliases => 'networklimit'
+        attribute :network_total,       :aliases => 'networktotal', :type => :integer
+        attribute :network_available,   :aliases => 'networkavailable'
+        attribute :vpc_limit,           :aliases => 'vpclimit'
+        attribute :vpc_total,           :aliases => 'vpctotal', :type => :integer
+        attribute :vpc_available,       :aliases => 'vpcavailable'
+        attribute :cpu_limit,           :aliases => 'cpulimit'
+        attribute :cpu_total,           :aliases => 'cputotal', :type => :integer
+        attribute :cpu_available,       :aliases => 'cpuavailable'
+        attribute :memory_limit,        :aliases => 'memorylimit'
+        attribute :memory_total,        :aliases => 'memorytotal', :type => :integer
+        attribute :memory_available,            :aliases => 'memoryavailable'
+        attribute :primary_storage_limit,       :aliases => 'primarystoragelimit'
+        attribute :primary_storage_total,       :aliases => 'primarystoragetotal', :type => :integer
+        attribute :primary_storage_available,   :aliases => 'primarystorageavailable'
+        attribute :secondary_storage_limit,     :aliases => 'secondarystoragelimit'
+        attribute :secondary_storage_total,     :aliases => 'secondarystoragetotal', :type => :integer
+        attribute :secondary_storage_available, :aliases => 'secondarystorageavailable'
+        attribute :vm_limit,                    :aliases => 'vmlimit'
+        attribute :vm_total,                    :aliases => 'vmtotal', :type => :integer
+        attribute :vm_available,                :aliases => 'vmavailable'
+        attribute :ip_limit,                    :aliases => 'iplimit'
+        attribute :ip_total,                    :aliases => 'iptotal', :type => :integer
+        attribute :ip_available,                :aliases => 'ipavailable'
+        attribute :volume_limit,                :aliases => 'volumelimit'
+        attribute :volume_total,                :aliases => 'volumetotal', :type => :integer
+        attribute :volume_available,            :aliases => 'volumeavailable'
+        attribute :snapshot_limit,              :aliases => 'snapshotlimit'
+        attribute :snapshot_total,              :aliases => 'snapshottotal', :type => :integer
+        attribute :snapshot_available,          :aliases => 'snapshotavailable'
+        attribute :template_limit,              :aliases => 'templatelimit'
+        attribute :template_total,              :aliases => 'templatetotal', :type => :integer
+        attribute :template_available,          :aliases => 'templateavailable'
+
+        def save
+          raise Fog::Errors::Error.new('Creating a project is not supported')
+        end
+
+        def destroy
+          raise Fog::Errors::Error.new('Destroying a project is not supported')
+        end
+
+      end # Project
+    end # Cosmic
+  end # Compute
+end # Fog

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

@@ -0,0 +1,39 @@
+require 'fog/core/collection'
+require 'fog/cosmic/models/compute/project'
+
+module Fog
+  module Cosmic
+    class Compute
+      class Projects < Fog::Collection
+        model Fog::Cosmic::Compute::Project
+
+        def all(filters={})
+          options = get_filter_options(filters)
+
+          data = service.list_projects(options)["listprojectsresponse"]["project"] || []
+          load(data)
+        end
+
+        def get(project_id, filters={})
+          filter_option = get_filter_options(filters)
+          options = filter_option.merge('id' => project_id)
+
+          if template = service.list_projects(options)["listprojectsresponse"]["project"].first
+            new(template)
+          end
+        rescue Fog::Cosmic::Compute::BadRequest
+          nil
+        end
+
+        private
+
+        def get_filter_options(filters)
+          default_filter = {
+              'projectfilter' => 'self'
+          }
+          default_filter.merge(filters)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,96 @@
+module Fog
+  module Cosmic
+    class Compute
+      class PublicIpAddress < Fog::Model
+        identity  :id
+
+        attribute :account
+        attribute :allocated,               :type => :time
+        attribute :associated_network_id,                      :aliases => 'associatednetworkid'
+        attribute :associated_network_name,                    :aliases => 'associatednetworkname'
+        attribute :domain
+        attribute :domain_id,                                  :aliases => 'domainid'
+        attribute :for_virtual_network,     :type => :boolean, :aliases => 'forvirtualnetwork'
+        attribute :ip_address,                                 :aliases => 'ipaddress'
+        attribute :is_portable,             :type => :boolean, :aliases => 'isportable'
+        attribute :is_source_nat,           :type => :boolean, :aliases => 'issourcenat'
+        attribute :is_static_nat,           :type => :boolean, :aliases => 'isstaticnat'
+        attribute :is_system,               :type => :boolean, :aliases => 'issystem'
+        attribute :network_id,              :type => :boolean, :aliases => 'networkid'
+        attribute :physical_network_id,                        :aliases => 'physicalnetworkid'
+        attribute :project
+        attribute :project_id,                                 :aliases => 'projectid'
+        attribute :purpose
+        attribute :state
+        attribute :server_display_name,                        :aliases => 'virtualmachinedisplayname'
+        attribute :server_id,                                  :aliases => 'virtualmachineid'
+        attribute :server_name,                                :aliases => 'virtualmachinename'
+        attribute :vlan_id,                                    :aliases => 'vlanid'
+        attribute :vlan_name,                                  :aliases => 'vlanname'
+        attribute :server_ip_address,                          :aliases => 'vmipaddress'
+        attribute :vpc_id,                                     :aliases => 'vpcid'
+        attribute :zone_id,                                    :aliases => 'zoneid'
+        attribute :zone_name,                                  :aliases => 'zonename'
+        attribute :tags,                    :type => :array
+        attribute :job_id,                                     :aliases => 'jobid'   # only on associate
+
+        def initialize(attributes = {})
+          # assign server first to prevent race condition with persisted?
+          self.server = attributes.delete(:server)
+          super
+        end
+
+        def ready?
+          state == 'Allocated'
+        end
+
+        def destroy
+          requires :identity
+          service.disassociate_ip_address('id' => id)
+          true
+        end
+
+        def server=(new_server)
+          @server = new_server
+          if persisted?
+            if !server_id.nil? && (new_server.nil? || server_id != new_server.id)
+              service.disable_static_nat('ipaddressid' => id)
+              self.server_display_name = nil
+              self.server_id = nil
+              self.server_name = nil
+              self.server_ip_address = nil
+              self.is_static_nat = false
+            end
+            unless new_server.nil?
+              service.enable_static_nat(
+                'ipaddressid' => id, 'virtualmachineid' => new_server.id)
+            end
+          end
+        end
+
+        def server
+          service.servers.get(server_id)
+        end
+
+        def save
+          raise Fog::Errors::Error.new('Resaving an existing object may create a duplicate') if persisted?
+          options = {
+            'account'    => account,
+            'domainid'   => domain_id,
+            'isportable' => is_portable,
+            'networkid'  => network_id,
+            'projectid'  => project_id,
+            'vpcid'      => vpc_id,
+            'zoneid'     => zone_id,
+          }
+          response = service.associate_ip_address(options)
+          merge_attributes(response['associateipaddressresponse'])
+          if @server
+            self.server = @server
+          end
+          true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+require 'fog/core/collection'
+require 'fog/cosmic/models/compute/public_ip_address'
+
+module Fog
+  module Cosmic
+    class Compute
+      class PublicIpAddresses < Fog::Collection
+        model Fog::Cosmic::Compute::PublicIpAddress
+
+        def all(options = {})
+          response = service.list_public_ip_addresses(options)
+          public_ip_addresses = response["listpublicipaddressesresponse"]["publicipaddress"] || []
+          load(public_ip_addresses)
+        end
+
+        def get(address_id)
+          response = service.list_public_ip_addresses('id' => address_id)
+          if public_ip_address = response["listpublicipaddressesresponse"]["publicipaddress"].first
+            new(public_ip_address)
+          end
+        rescue Fog::Cosmic::Compute::BadRequest
+          nil
+        end
+      end
+    end
+  end
+end