fog 1.38.0 → 1.39.0

data/lib/fog/ninefold/core.rb

@@ -1,11 +0,0 @@
-require 'fog/core'
-require 'fog/json'
-
-module Fog
-  module Ninefold
-    extend Fog::Provider
-
-    service(:compute, 'Compute')
-    service(:storage, 'Storage')
-  end
-end

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

@@ -1,100 +0,0 @@
-require 'fog/core/model'
-
-module Fog
-  module Compute
-    class Ninefold
-      class Address < Fog::Model
-        identity  :id
-
-        attribute :account
-        attribute :allocated
-        attribute :associatednetworkid
-        attribute :domain
-        attribute :domainid
-        attribute :forvirtualnetwork
-        attribute :ipaddress
-        attribute :issourcenat
-        attribute :isstaticnat
-        attribute :jobid
-        attribute :jobstatus
-        attribute :networkid
-        attribute :state
-        attribute :virtualmachinedisplayname
-        attribute :virtualmachineid
-        attribute :virtualmachinename
-        attribute :vlanid
-        attribute :vlanname
-        attribute :zoneid
-        attribute :zonename
-
-        def initialize(attributes={})
-          super
-        end
-
-        def destroy
-          requires :identity
-          self.jobid = extract_job_id(service.disassociate_ip_address(:id => identity))
-          true
-        end
-
-        def enable_static_nat(server)
-          server.kind_of?(Integer) ? serverid = server : serverid = server.identity
-          res = service.enable_static_nat(:virtualmachineid => serverid, :ipaddressid => identity)
-          reload
-          to_boolean(res['success'])
-        end
-
-        def disable_static_nat()
-          self.jobid = extract_job_id(service.disable_static_nat(:ipaddressid => identity))
-          true
-        end
-
-        def reload
-          self.virtualmachinedisplayname = nil
-          self.virtualmachineid = nil
-          self.virtualmachinename = nil
-          super
-        end
-
-        def ready?
-          if jobid && service.query_async_job_result(:jobid => jobid)['jobstatus'] == 0
-            false
-          else # No running job, we are ready. Refresh data.
-            reload
-            true
-          end
-        end
-
-        def save
-          raise "Operation not supported" if self.identity
-          requires :zoneid
-
-          options = {
-            :zoneid => zoneid,
-            :networkid => networkid,
-            :account => account,
-            :domainid => domainid
-          }.delete_if {|k,v| v.nil? || v == "" }
-          data = service.associate_ip_address(options)
-          merge_attributes(data)
-          true
-        end
-
-        private
-
-        def extract_job_id(job)
-          if job.kind_of? Integer
-            job
-          else
-            job['jobid'] || job['id']
-          end
-        end
-
-        # needed to hack around API inconsistencies
-        def to_boolean(val)
-          val && (val.to_s.match(/(true|t|yes|y|1)$/i) != nil)
-        end
-      end
-    end
-  end
-end

data/lib/fog/ninefold/models/compute/addresses.rb

@@ -1,27 +0,0 @@
-require 'fog/core/collection'
-require 'fog/ninefold/models/compute/address'
-
-module Fog
-  module Compute
-    class Ninefold
-      class Addresses < Fog::Collection
-        model Fog::Compute::Ninefold::Address
-
-        def all
-          data = service.list_public_ip_addresses
-          load(data)
-        end
-
-        def get(identifier)
-          return nil if identifier.nil? || identifier == ""
-          data = service.list_public_ip_addresses(:id => identifier)
-          if data.empty?
-            nil
-          else
-            new(data[0])
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,24 +0,0 @@
-require 'fog/core/model'
-
-module Fog
-  module Compute
-    class Ninefold
-      class Flavor < Fog::Model
-        identity :id
-
-        attribute :cpunumber
-        attribute :cpuspeed
-        attribute :created, :type => :time
-        attribute :displaytext
-        attribute :domain
-        attribute :domainid
-        attribute :hosttags
-        attribute :memory
-        attribute :name
-        attribute :offerha
-        attribute :storagetype
-        attribute :tags
-      end
-    end
-  end
-end

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

@@ -1,26 +0,0 @@
-require 'fog/core/collection'
-require 'fog/ninefold/models/compute/flavor'
-
-module Fog
-  module Compute
-    class Ninefold
-      class Flavors < Fog::Collection
-        model Fog::Compute::Ninefold::Flavor
-
-        def all
-          data = service.list_service_offerings
-          load(data)
-        end
-
-        def get(identifier)
-          data = service.list_service_offerings(:id => identifier)
-          if data.empty?
-            nil
-          else
-            new(data[0])
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,38 +0,0 @@
-require 'fog/core/model'
-
-module Fog
-  module Compute
-    class Ninefold
-      class Image < Fog::Model
-        identity :id
-
-        attribute :account
-        attribute :accountid
-        attribute :bootable
-        attribute :created, :type => :time
-        attribute :crossZones
-        attribute :displaytext
-        attribute :domain
-        attribute :domainid
-        attribute :format
-        attribute :hypervisor
-        attribute :isextractable
-        attribute :isfeatured
-        attribute :ispublic
-        attribute :isready
-        attribute :jobid
-        attribute :jobstatus
-        attribute :name
-        attribute :ostypeid
-        attribute :ostypename
-        attribute :passwordenabled
-        attribute :removed
-        attribute :size
-        attribute :status
-        attribute :templatetype
-        attribute :zoneid
-        attribute :zonename
-      end
-    end
-  end
-end

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

@@ -1,26 +0,0 @@
-require 'fog/core/collection'
-require 'fog/ninefold/models/compute/image'
-
-module Fog
-  module Compute
-    class Ninefold
-      class Images < Fog::Collection
-        model Fog::Compute::Ninefold::Image
-
-        def all(offering = 'executable')
-          data = service.list_templates(:templatefilter => offering)
-          load(data)
-        end
-
-        def get(identifier, offering = 'executable')
-          data = service.list_templates(:templatefilter => offering, :id => identifier)
-          if data.empty?
-            nil
-          else
-            new(data[0])
-          end
-        end
-      end
-    end
-  end
-end

data/lib/fog/ninefold/models/compute/ip_forwarding_rule.rb

@@ -1,76 +0,0 @@
-require 'fog/core/model'
-
-module Fog
-  module Compute
-    class Ninefold
-      class IpForwardingRule < Fog::Model
-        identity  :id
-
-        attribute :protocol
-        attribute :virtualmachineid
-        attribute :virtualmachinename
-        attribute :ipaddressid
-        attribute :ipaddress
-        attribute :startport
-        attribute :endport
-        attribute :state
-
-        attribute :jobid
-
-        def initialize(attributes={})
-          super
-        end
-
-        def destroy
-          requires :identity
-          self.jobid = extract_job_id(service.delete_ip_forwarding_rule(:id => identity))
-          true
-        end
-
-        def ready?
-          if jobid && service.query_async_job_result(:jobid => jobid)['jobstatus'] == 0
-            false
-          else # No running job, we are ready. Refresh data.
-            reload
-            true
-          end
-        end
-
-        def address
-          Ninefold.address.get(ipaddressid)
-        end
-
-        def address=(addr)
-          self.ipaddressid = addr.identity
-        end
-
-        def save
-          raise "Operation not supported" if self.identity
-          requires :ipaddressid
-          requires :protocol
-          requires :startport
-
-          options = {
-            :ipaddressid => ipaddressid,
-            :protocol => protocol,
-            :startport => startport,
-            :endport => endport
-          }.delete_if {|k,v| v.nil? || v == "" }
-          data = service.create_ip_forwarding_rule(options)
-          merge_attributes(data)
-          true
-        end
-
-        private
-
-        def extract_job_id(job)
-          if job.kind_of? Integer
-            job
-          else
-            job['jobid'] || job['id']
-          end
-        end
-      end
-    end
-  end
-end

data/lib/fog/ninefold/models/compute/ip_forwarding_rules.rb

@@ -1,27 +0,0 @@
-require 'fog/core/collection'
-require 'fog/ninefold/models/compute/ip_forwarding_rule'
-
-module Fog
-  module Compute
-    class Ninefold
-      class IpForwardingRules < Fog::Collection
-        model Fog::Compute::Ninefold::IpForwardingRule
-
-        def all
-          data = service.list_ip_forwarding_rules
-          load(data)
-        end
-
-        def get(identifier)
-          return nil if identifier.nil? || identifier == ""
-          data = service.list_ip_forwarding_rules(:id => identifier)
-          if data.empty?
-            nil
-          else
-            new(data[0])
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,182 +0,0 @@
-require 'fog/compute/models/server'
-
-module Fog
-  module Compute
-    class Ninefold
-      class Server < Fog::Compute::Server
-        extend Fog::Deprecation
-        deprecate :serviceofferingid, :flavor_id
-        deprecate :templateid,        :image_id
-
-        identity  :id
-
-        attribute :account
-        attribute :cpunumber
-        attribute :cpuspeed
-
-        attribute :cpuused
-        attribute :created,             :type => :time
-        attribute :displayname
-        attribute :domain
-        attribute :domainid
-        attribute :flavor_id,           :aliases => :serviceofferingid
-        attribute :forvirtualnetwork
-        attribute :group
-        attribute :groupid
-        attribute :guestosid
-        attribute :haenable
-        attribute :hostid
-        attribute :hostname
-        attribute :hypervisor
-        attribute :image_id,            :aliases => :templateid
-        #attribute :ipaddress
-        attribute :isodisplaytext
-        attribute :isoid
-        attribute :isoname
-        attribute :jobid
-        attribute :jobstatus
-        attribute :memory
-        attribute :name
-        attribute :networkkbsread
-        attribute :networkkbswrite
-        attribute :nic
-        attribute :password
-        attribute :passwordenabled
-        attribute :rootdeviceid
-        attribute :rootdevicetype
-        attribute :securitygroup
-        attribute :serviceofferingname
-        attribute :state
-        attribute :templatedisplaytext
-        attribute :templatename
-        attribute :zoneid
-        attribute :zonename
-
-        # used for creation only.
-        attribute :networkids
-        attribute :diskofferingid
-        attribute :keypair
-        attribute :securitygroupids
-        attribute :size
-        attribute :userdata
-
-        #attribute :account_id, :aliases => "account", :squash => "id"
-        #attribute :image_id, :aliases => "image", :squash => "id"
-        #attribute :flavor_id, :aliases => "server_type", :squash => "id"
-        #attribute :zone_id, :aliases => "zone", :squash => "id"
-
-        def initialize(attributes={})
-          merge_attributes({
-            :flavor_id => 105, # '1CPU, 384MB, 80GB HDD'
-            :image_id  => 421  # 'XEN Basic Ubuntu 10.04 Server x64 PV r2.0'
-          })
-          super
-        end
-
-        # This is temporary - we need to model nics.
-        def ipaddress
-          nic[0] ? nic[0]['ipaddress'] : nil
-        end
-
-        def reboot
-          requires :identity
-          self.jobid = extract_job_id(service.reboot_virtual_machine(:id => identity))
-          puts "jobid: " + jobid.to_s
-          true
-        end
-
-        def start
-          requires :identity
-          self.jobid = extract_job_id(service.start_virtual_machine(:id => identity))
-          true
-        end
-
-        def stop
-          requires :identity
-          self.jobid = extract_job_id(service.stop_virtual_machine(:id => identity))
-          true
-        end
-
-        def destroy
-          requires :identity
-          self.jobid = extract_job_id(service.destroy_virtual_machine(:id => identity))
-          true
-        end
-
-        def flavor
-          requires :flavor_id
-          service.flavors.get(flavor_id)
-        end
-
-        def image
-          requires :image_id
-          service.images.get(image_id)
-        end
-
-        def ready?
-          if jobid
-            # we do this by polling the last job id status.
-            res = service.query_async_job_result(:jobid => jobid)
-            if res['jobstatus'] == 0
-              false
-            else
-              # update with new values.
-              merge_attributes(res['jobresult']['virtualmachine'])
-              true
-            end
-          else # No running job, we are ready. Refresh data.
-            reload
-            true
-          end
-        end
-
-        def save
-          raise "Operation not supported" if self.identity
-          requires :flavor_id, :image_id, :zoneid
-
-          unless networkids
-            # No network specified, use first in this zone.
-            networks = service.list_networks(:zoneid => zoneid)
-            if networks.empty?
-              raise "No networks. Please create one, or specify a network ID"
-            else
-              # use the network with the lowest ID - the safe default
-              self.networkids = networks.sort {|x,y| x['id'] <=> y['id']}[0]['id']
-            end
-          end
-
-          options = {
-            :serviceofferingid => flavor_id,
-            :templateid => image_id,
-            :name => name,
-            :zoneid => zoneid,
-            :networkids => networkids,
-            :account => account,
-            :diskofferingid => diskofferingid,
-            :displayname => displayname,
-            :domainid => domainid,
-            :group => group,
-            :hypervisor => hypervisor,
-            :keypair => keypair,
-            :securitygroupids => securitygroupids,
-            :size => size,
-            :userdata => userdata
-          }.delete_if {|k,v| v.nil? || v == "" }
-          data = service.deploy_virtual_machine(options)
-          merge_attributes(data)
-          true
-        end
-
-        private
-
-        def extract_job_id(job)
-          if job.kind_of? Integer
-            job
-          else
-            job['jobid'] || job['id']
-          end
-        end
-      end
-    end
-  end
-end