michiels-fog 1.3.1

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

@@ -0,0 +1,30 @@
+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 = connection.list_templates(:templatefilter => offering)
+          load(data)
+        end
+
+        def get(identifier, offering = 'executable')
+          data = connection.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

@@ -0,0 +1,79 @@
+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(connection.delete_ip_forwarding_rule(:id => identity))
+          true
+        end
+
+        def ready?
+          if jobid && connection.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 = connection.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

@@ -0,0 +1,31 @@
+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 = connection.list_ip_forwarding_rules
+          load(data)
+        end
+
+        def get(identifier)
+          return nil if identifier.nil? || identifier == ""
+          data = connection.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

@@ -0,0 +1,185 @@
+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(connection.reboot_virtual_machine(:id => identity))
+          puts "jobid: " + jobid.to_s
+          true
+        end
+
+        def start
+          requires :identity
+          self.jobid = extract_job_id(connection.start_virtual_machine(:id => identity))
+          true
+        end
+
+        def stop
+          requires :identity
+          self.jobid = extract_job_id(connection.stop_virtual_machine(:id => identity))
+          true
+        end
+
+        def destroy
+          requires :identity
+          self.jobid = extract_job_id(connection.destroy_virtual_machine(:id => identity))
+          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 ready?
+          if jobid
+            # we do this by polling the last job id status.
+            res = connection.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 = connection.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 = connection.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

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

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

data/lib/fog/ninefold/models/storage/directories.rb

@@ -0,0 +1,48 @@
+require 'fog/core/collection'
+require 'fog/ninefold/models/storage/directory'
+
+module Fog
+  module Storage
+    class Ninefold
+
+      class Directories < Fog::Collection
+
+        attribute :directory
+
+        model Fog::Storage::Ninefold::Directory
+
+        def all
+          directory ? ns = directory.key : ns = ''
+          ns = ns + '/' unless ns =~ /\/$/
+          data = connection.get_namespace(ns).body[:DirectoryList]
+          data = {:DirectoryEntry => []} if data.kind_of? String
+          data[:DirectoryEntry] = [data[:DirectoryEntry]] if data[:DirectoryEntry].kind_of? Hash
+          dirs = data[:DirectoryEntry].select {|de| de[:FileType] == 'directory'}
+          dirs.each do |d|
+            d[:Filename] = ns + d[:Filename] if directory
+            d[:Filename] += '/' unless d[:Filename] =~ /\/$/
+          end
+          load(dirs)
+        end
+
+        def get(key, options = {})
+          return nil if key == '' # Root dir shouldn't be retrieved like this.
+          key =~ /\/$/ ? ns = key : ns = key + '/'
+          res = connection.get_namespace ns
+          emc_meta = res.headers['x-emc-meta']
+          obj_id = emc_meta.scan(/objectid=(\w+),/).flatten[0]
+          new(:objectid => obj_id, :key => ns)
+        rescue Fog::Storage::Ninefold::NotFound
+          nil
+        end
+
+        def new(attributes ={})
+          attributes = {:directory => directory}.merge(attributes) if directory
+          super(attributes)
+        end
+
+      end
+
+    end
+  end
+end

data/lib/fog/ninefold/models/storage/directory.rb

@@ -0,0 +1,53 @@
+require 'fog/core/model'
+
+module Fog
+  module Storage
+    class Ninefold
+
+      class Directory < Fog::Model
+
+        identity :key, :aliases => :Filename
+        attribute :objectid, :aliases => :ObjectID
+
+        def files
+          @files ||= begin
+                       Fog::Storage::Ninefold::Files.new(
+                                                          :directory    => self,
+                                                          :connection   => connection
+                                                          )
+          end
+        end
+
+        def directories
+          @directories ||= begin
+                       Fog::Storage::Ninefold::Directories.new(
+                                                               :directory    => self,
+                                                               :connection   => connection
+                                                               )
+          end
+        end
+
+        def save
+          self.key = attributes[:directory].key + key if attributes[:directory]
+          self.key = key + '/' unless key =~ /\/$/
+          res = connection.post_namespace key
+          reload
+        end
+
+        def destroy(opts={})
+          if opts[:recursive]
+            files.each {|f| f.destroy }
+            directories.each do |d|
+              d.files.each {|f| f.destroy }
+              d.destroy(opts)
+            end
+          end
+          connection.delete_namespace key
+        end
+
+
+      end
+
+    end
+  end
+end