fog 0.7.1 → 2.3.0

data/lib/fog/linode/requests/dns/domain_list.rb

@@ -0,0 +1,40 @@
+module Fog
+  module DNS
+    class Linode
+      class Real
+        # List of domains (you have access to)
+        #
+        # ==== Parameters
+        # * domain_id<~Integer>: limit the list to the domain ID specified
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Array>:
+        #     * DATA<~Array>
+        #       * 'DOMAINID'<~Interger>
+        #       * 'SOA_EMAIL'<~String>
+        #       * 'DESCRIPTION'<~String>
+        #       * 'TTL_SEC'<~String>
+        #       * 'EXPIRE_SEC'<~Integer>
+        #       * 'RETRY_SEC'<~Integer>
+        #       * 'DOMAIN'<~String>
+        #       * 'STATUS'<~Integer>
+        #       * 'MASTER_IPS'<~String>
+        #       * 'REFRESH_SEC'<~Integer>
+        #       * 'TYPE'<~String>
+        def domain_list(domain_id = nil)
+          options = {}
+          if domain_id
+            options.merge!(:domainId => domain_id)
+          end
+
+          request(
+            :expects  => 200,
+            :method   => 'GET',
+            :query    => { :api_action => 'domain.list' }.merge!(options)
+          )
+        end
+      end
+    end
+  end
+end

data/lib/fog/linode/requests/dns/domain_resource_create.rb

@@ -0,0 +1,42 @@
+module Fog
+  module DNS
+    class Linode
+      class Real
+        # Creates a resource record in a domain
+        #
+        # ==== Parameters
+        # * domain_id<~Integer>: limit the list to the domain ID specified
+        # * type<~String>: One of: NS, MX, A, AAAA, CNAME, TXT, or SRV
+        # * options<~Hash>
+        #   * name<~String>: The hostname or FQDN. When Type=MX the subdomain to delegate to the
+        #                    Target MX server
+        #   * target<~String> When Type=MX the hostname. When Type=CNAME the target of the alias.
+        #                    When Type=TXT the value of the record. When Type=A or AAAA the token
+        #                    of '[remote_addr]' will be substituted with the IP address of the request.
+        #   * priority<~Integer>: priority for MX and SRV records, 0-255 - default: 10
+        #   * weight<~Integer>: default: 5
+        #   * port<~Integer>: default: 80
+        #   * protocol<~String>: The protocol to append to an SRV record. Ignored on other record
+        #                        types. default: udp
+        #   * ttl_sec<~Integer>: note, Linode will round the input to set values (300, 3600, 7200, etc)
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * DATA<~Hash>:
+        #       * 'ResourceID'<~Integer>: ID of the resource record created
+        def domain_resource_create(domain_id, type, options = {})
+          query= {}
+          request(
+            :expects  => 200,
+            :method   => 'GET',
+            :query    => {
+              :api_action   => 'domain.resource.create',
+              :domainID => domain_id,
+              :type  => type
+            }.merge!( options)
+          )
+        end
+      end
+    end
+  end
+end

data/lib/fog/linode/requests/dns/domain_resource_delete.rb

@@ -0,0 +1,26 @@
+module Fog
+  module DNS
+    class Linode
+      class Real
+        # Delete the given resource from a domain
+        #
+        # ==== Parameters
+        # * domain_id<~Integer>: id of domain resource belongs to
+        # * resource_id<~Integer>: id of resouce to delete
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * DATA<~Hash>:
+        #       * resource_id<~Integer>:  resource id that was deleted
+        def domain_resource_delete(domain_id, resource_id)
+          request(
+            :expects  => 200,
+            :method   => 'GET',
+            :query    => { :api_action => 'domain.resource.delete', :domainId => domain_id, :resourceID => resource_id }
+          )
+        end
+      end
+    end
+  end
+end

data/lib/fog/linode/requests/dns/domain_resource_list.rb

@@ -0,0 +1,41 @@
+module Fog
+  module DNS
+    class Linode
+      class Real
+        # List of resource records for a domain
+        #
+        # ==== Parameters
+        # * domain_id<~Integer>: limit the list to the domain ID specified
+        # * resource_id<~Integer>: optional.  use if want only a specific resource record
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Array>:
+        #     * DATA<~Array>
+        #       * 'PROTOCOL'<~String>:  for SRV records. default is UDP
+        #       * 'TTL_SEC'<~Interger>:
+        #       * 'PRIORITY'<~Interger>: for MX and SRV records
+        #       * 'TYPE'<~String>: One of: NS, MX, A, AAAA, CNAME, TXT, or SRV
+        #       * 'TARGET'<~String>: When Type=MX the hostname. When Type=CNAME the target of the alias.
+        #                           When Type=TXT the value of the record. When Type=A or AAAA the token
+        #                           of '[remote_addr]' will be substituted with the IP address of the request.
+        #       * 'WEIGHT'<~Interger>:
+        #       * 'RESOURCEID'<~Interger>: ID of the resource record
+        #       * 'PORT'<~Interger>:
+        #       * 'DOMAINID'<~Interger>: ID of the domain that this record belongs to
+        #       * 'NAME'<~Interger>: The hostname or FQDN. When Type=MX, the subdomain to delegate to
+        def domain_resource_list(domain_id, resource_id = nil)
+          query = { :api_action => 'domain.resource.list', :domainID => domain_id }
+          if resource_id
+            query[:resourceID] = resource_id
+          end
+          request(
+            :expects  => 200,
+            :method   => 'GET',
+            :query    => query
+          )
+        end
+      end
+    end
+  end
+end

data/lib/fog/linode/requests/dns/domain_resource_update.rb

@@ -0,0 +1,43 @@
+module Fog
+  module DNS
+    class Linode
+      class Real
+        # Updates a resource record in a domain
+        #
+        # ==== Parameters
+        # * domain_id<~Integer>: limit the list to the domain ID specified
+        # * resource_id<~Integer>: id of resouce to delete
+        # * options<~Hash>
+        #   * type<~String>: One of: NS, MX, A, AAAA, CNAME, TXT, or SRV
+        #   * name<~String>: The hostname or FQDN. When Type=MX the subdomain to delegate to the
+        #                    Target MX server
+        #   * target<~String> When Type=MX the hostname. When Type=CNAME the target of the alias.
+        #                    When Type=TXT the value of the record. When Type=A or AAAA the token
+        #                    of '[remote_addr]' will be substituted with the IP address of the request.
+        #   * priority<~Integer>: priority for MX and SRV records, 0-255 - default: 10
+        #   * weight<~Integer>: default: 5
+        #   * port<~Integer>: default: 80
+        #   * protocol<~String>: The protocol to append to an SRV record. Ignored on other record
+        #                        types. default: udp
+        #   * ttl_sec<~Integer>: note, Linode will round the input to set values (300, 3600, 7200, etc)
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * DATA<~Hash>:
+        #       * 'ResourceID'<~Integer>: ID of the resource record updated
+        def domain_resource_update(domain_id, resource_id, options = {})
+          query= {}
+          request(
+            :expects  => 200,
+            :method   => 'GET',
+            :query    => {
+              :api_action   => 'domain.resource.update',
+              :domainID => domain_id,
+              :resourceID => resource_id,
+            }.merge!( options)
+          )
+        end
+      end
+    end
+  end
+end

data/lib/fog/linode/requests/dns/domain_update.rb

@@ -0,0 +1,36 @@
+module Fog
+  module DNS
+    class Linode
+      class Real
+        # Update a domain record
+        #
+        # ==== Parameters
+        # * domain_id<~Integer>: The ID to identify the zone
+        # * options<~Hash>
+        #   * domain<~String>: The zone's name.
+        #   * type<~String>: master or slave
+        #   * description<~String> Currently undisplayed
+        #   * SOA_email<~String> Required when type=master
+        #   * refresh_sec<~Integer> numeric, default: '0'
+        #   * retry_sec<~Integer> numeric, default: '0'
+        #   * expire_sec<~Integer> numeric, default: '0'
+        #   * ttl_sec<~String> numeric, default: '0'
+        #   * status<~Integer> 0, 1, or 2 (disabled, active, edit mode), default: 1
+        #   * master_ips<~String> When type=slave, the zone's master DNS servers list, semicolon separated
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * DATA<~Hash>:
+        #       * 'DomainID'<~Integer>: domain ID
+        def domain_update(domain_id, options = {})
+          request(
+            :expects  => 200,
+            :method   => 'GET',
+            :query    => { :api_action => 'domain.update', :domainId => domain_id }.merge!(options)
+          )
+        end
+      end
+    end
+  end
+end

data/lib/fog/linode.rb

@@ -0,0 +1,2 @@
+require 'fog/linode/compute'
+require 'fog/linode/dns'

data/lib/fog/opennebula/README.md

@@ -0,0 +1,113 @@
+# Getting started with OpenNebula (one) Fog provider
+
+[OpenNebula](http://www.opennebula.org) provides ruby bindings to access the xml-rpc
+
+The opennebula fog extensions provides examples for using Fog with OpenNebula (4.4).
+
+**Note:** This provider is under construction! This means everything that is provided should work without problems, but there are many features not available yet. Please contribute!
+
+## Requirements
+
+For working with this provider the following pre-requisites are needed:
+
+* Ruby version 1.8.x or 1.9.x
+* `fog` gem
+* Working OpenNebula instance with XML-RPC and credentials
+* This version is tested with OpenNebula 4.4 and the opennebula gem dependency is hardcoded to this version. it should work with version 4.6, but is not tested.
+
+
+## Examples
+
+General proceeding:
+
+* Connect to one-rpc
+* create new vm object
+* fetch a template/flavor from one (this template should be predefined)
+* assigne the flavor/template to the vm
+* change the attributes of this flavor/template (name, cpu, memory, nics....)
+* save/instantiate the vm
+
+```ruby
+require 'fog'
+
+# connect to your one rpc
+con = Fog::Compute.new(
+    {
+      :provider => 'OpenNebula',
+      :opennebula_username => 'user',
+      :opennebula_password => 'password',
+      :opennebula_endpoint => 'http://oned.domain:2633/RPC2'
+    }
+  )
+
+
+# list all vms
+con.servers
+
+# list all flavors (templates in OpenNebula slang)
+con.flavors
+
+# get flavor with id 4
+con.flavors.get 4
+
+# list all Virtual Networks
+con.networks
+con.networks.get 2
+
+# get all usergroups
+con.groups
+
+# create a new vm (creates the object, the vm is not instantiated yet)
+newvm = con.servers.new
+
+# set the flavor of the vm
+newvm.flavor = con.flavors.get 4
+
+# set the name of the vm
+newvm.name = "FooBarVM"
+
+# set the groupid of the vm 
+newvm.gid = 0
+
+# set cores and memory (MB)
+newvm.flavor.vcpu = 2
+newvm.flavor.memory = 256
+
+# create a new network interface attached to the network with id 1 and virtio as driver/model
+network = client.networks.get(1)
+nic = con.interfaces.new({ :vnet => network, :model => "virtio"})
+
+# Attach the new nic to our vm
+newvm.flavor.nic = [ nic ]
+
+# instantiat the new vm
+newvm.save
+```
+
+## Features
+
+tbd
+
+## not working yet
+
+* con.groups.get 4
+
+_AND_ everything not mentioned in features or examples ;)
+
+
+## Troubleshooting
+
+* ArgumentError: opennebula is not a recognized compute provider
+  * is the correct gem version included?
+
+## Additional Resources
+* [Fog cloud library](http://fog.io)
+* [Fog documentation](http://rubydoc.info/gems/fog)
+* [Fog Github repo](https://github.com/fog/fog)
+* [Fog Release Notes](https://github.com/fog/fog/blob/master/changelog.txt)
+* [Ruby OpenNebula Cloud API](http://docs.opennebula.org/stable/integration/system_interfaces/ruby.html)
+* [OpenNebula ruby bindings](http://docs.opennebula.org/doc/stable/oca/ruby/)
+
+## Support and Feedback
+
+Please contribute and send feedback! Just do it here!

data/lib/fog/opennebula/compute.rb

@@ -0,0 +1,136 @@
+require 'fog/opennebula/core'
+
+module Fog
+  module Compute
+    class OpenNebula < Fog::Service
+      requires   :opennebula_endpoint
+      recognizes :opennebula_username, :opennebula_password
+
+      model_path 'fog/opennebula/models/compute'
+      model       :server
+      collection  :servers
+      model       :network
+      collection  :networks
+      model       :flavor
+      collection  :flavors
+      model       :interface
+      collection  :interfaces
+      model       :group
+      collection  :groups
+
+      request_path 'fog/opennebula/requests/compute'
+      request :list_vms
+      request :list_groups
+      request :list_networks
+      request :vm_allocate
+      request :vm_destroy
+      request :get_vnc_console
+      request :vm_resume
+      request :vm_suspend
+      request :vm_stop
+      request :template_pool
+      request :vm_disk_snapshot
+      request :vm_shutdown
+      request :image_pool
+
+      class Mock
+        def self.data
+          @data ||= Hash.new do |hash, key|
+            hash[key] = {
+              "vms" => [
+                {
+                  "onevm_object" => "",
+                  "status" => "RUNNING",
+                  "state" => "3",
+                  "id" => 4,
+                  "uuid" => "5",
+                  "gid" => "5",
+                  "name" => "MockVM",
+                  "user" => "MockUser",
+                  "group" => "MockGroup",
+                  "cpu" => "2",
+                  "memory" => "1024",
+                  "mac" => "00:01:02:03:04:05",
+                  "ip" => "1.1.1.1"
+                }
+              ],
+              "image_pool" => [
+                {}
+              ],
+              "template_pool" => [
+                {
+                  "content" => %Q{
+                    NAME = mock-vm
+                    MEMORY = 512
+                    VCPU = 1
+                    CPU = 1
+                  },
+                  "id" => 1,
+                  "name" => 'mock',
+                  "cpu" => 1,
+                  "vcpu" => 1,
+                  "memory" => 512,
+                  "sched_requirements" => 'CPUSPEED > 1000',
+                  "sched_rank" => 'FREECPU',
+                  "sched_ds_requirements" => "NAME=mock",
+                  "sched_ds_rank" => "FREE_MB",
+                  "disk" => {},
+                  "nic" => {},
+                  "os" => {
+                    'ARCH' => 'x86_64'
+                  },
+                  "graphics" => {},
+                  "raw" => %|["DATA"=>"<cpu match='exact'><model fallback='allow'>core2duo</model></cpu>", "TYPE"=>"kvm"]|,
+                  "context" => {},
+                  "user_variables" => {}
+                }
+              ]
+            }
+          end
+        end
+
+        def self.reset
+          @data = nil
+        end
+
+        include Collections
+        def initialize(options={})
+          @opennebula_endpoint = options[:opennebula_endpoint]
+          @opennebula_username = options[:opennebula_username]
+          @opennebula_password = options[:opennebula_password]
+
+          begin
+            require "opennebula"
+          rescue LoadError
+            raise Fog::Errors::LoadError, "To use OpenNebula provider, you must load 'opennebula' gem"
+          end
+        end
+
+        def client
+          return @client
+        end
+
+        def data
+          self.class.data[@opennebula_endpoint]
+        end
+
+        def reset_data
+          self.class.data.delete(@opennebula_endpoint)
+        end
+      end
+
+      class Real
+        include Collections
+
+        def client
+          return @client
+        end
+
+        def initialize(options={})
+          require 'opennebula'
+          @client = ::OpenNebula::Client.new("#{options[:opennebula_username]}:#{options[:opennebula_password]}", options[:opennebula_endpoint])
+        end
+      end
+    end
+  end
+end

data/lib/fog/opennebula/core.rb

@@ -0,0 +1,8 @@
+require 'fog/core'
+
+module Fog
+  module OpenNebula
+    extend Fog::Provider
+    service(:compute, 'Compute')
+  end
+end

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

@@ -0,0 +1,175 @@
+require 'fog/core/model'
+
+module Fog
+  module Compute
+    class OpenNebula
+      class Flavor < Fog::Model
+        identity :id
+        attribute :name
+        attribute :content
+        attribute :cpu
+        attribute :vcpu
+        attribute :memory
+        attribute :sched_requirements
+        attribute :sched_rank
+        attribute :sched_ds_requirements
+        attribute :sched_ds_rank
+        attribute :disk
+        attribute :nic
+        attribute :os
+        attribute :graphics
+        attribute :raw
+        attribute :context
+        attribute :user_variables
+
+
+        def to_label
+          "#{name} -- #{vcpu} VCPU - #{memory}MB Mem"
+        end
+
+        def to_s
+          "" + get_cpu \
+            + get_vcpu \
+            + get_memory \
+            + get_disk \
+            + get_nic \
+            + get_os \
+            + get_graphics \
+            + get_raw \
+            + get_sched_requirements \
+            + get_sched_ds_requirements \
+            + get_sched_rank \
+            + get_sched_ds_rank \
+            + get_context \
+            + get_user_variables
+        end
+
+        def get_cpu
+          return "CPU=#{vcpu.to_f/10}\n" unless cpu
+          return "CPU=#{vcpu}\n" if cpu.to_i > vcpu.to_i
+          "CPU=#{cpu}\n"
+        end
+
+        def get_vcpu
+          self.vcpu = 1 unless vcpu
+          "VCPU=#{vcpu}\n"
+        end
+
+        def get_memory
+          self.memory = 128 unless memory
+          "MEMORY=#{memory}\n"
+        end
+
+        def get_raw
+          return "" unless raw
+          ret = "RAW=#{raw}\n"
+          ret.gsub!(/\{/, '[')
+          ret.gsub!(/\}/, ']')
+          ret.gsub!(/=>/,'=')
+          ret
+        end
+
+        def get_disk
+          return "" unless disk
+          ret = ""
+          if disk.is_a? Array
+            disk.each do |d|
+              ret += "DISK=#{d}\n"
+            end
+          else
+            ret = "DISK=#{disk}\n"
+          end
+          ret.gsub!(/\{/, '[')
+          ret.gsub!(/\}/, ']')
+          ret.gsub!(/>/,'')
+          ret
+        end
+
+        def get_os
+          return "" unless os
+          ret = "OS=#{os}\n"
+          ret.gsub!(/\{/, '[')
+          ret.gsub!(/\}/, ']')
+          ret.gsub!(/>/,'')
+          ret
+        end
+
+        def get_graphics
+          return "" unless graphics
+          ret = "GRAPHICS=#{graphics}\n"
+          ret.gsub!(/\{/, '[')
+          ret.gsub!(/\}/, ']')
+          ret.gsub!(/>/,'')
+          ret
+        end
+
+        def get_nic
+          # NIC=[MODEL="virtio",NETWORK="vlan17",NETWORK_UNAME="oneadmin"]
+          return "" if nic.nil?
+          ret = ""
+          if nic.is_a? Array
+            nic.each do |n|
+              ret += %Q|NIC=[MODEL="#{n.model}",NETWORK_ID="#{n.vnet.id}"]\n| unless n.vnet.nil?
+            end
+          end
+          #ret.gsub!(/\{/, '[')
+          #ret.gsub!(/\}/, ']')
+          #ret.gsub!(/>/,'')
+          ret
+        end
+
+        def get_sched_ds_requirements
+          return "" unless sched_ds_requirements
+          %Q|SCHED_DS_REQUIREMENTS="#{sched_ds_requirements.gsub(/"/){ %q(\") }}"\n|
+        end
+
+        def get_sched_ds_rank
+          return "" unless sched_ds_rank
+          %Q|SCHED_DS_RANK="#{sched_ds_rank.gsub(/"/){ %q(\") }}"\n|
+        end
+
+        def get_sched_requirements
+          return "" unless sched_requirements
+          %Q|SCHED_REQUIREMENTS="#{sched_requirements.gsub(/"/){ %q(\") }}"\n|
+        end
+
+        def get_sched_rank
+          return "" unless sched_rank
+          %Q|SCHED_RANK="#{sched_rank.gsub(/"/){ %q(\") }}"\n|
+        end
+
+        def get_context
+          return "" unless context
+          if context.is_a? String
+            return %Q|CONTEXT= [ #{context} ]\n|
+          elsif context.is_a? Hash
+            ret = ""
+            context.each do |key, value|
+              ret << %Q|"#{key}"="#{value}",|
+            end
+            ret.chop! if ret.end_with?(',')
+            return %Q|CONTEXT=[ #{ret} ]\n|
+          else
+            return ""
+          end
+        end
+
+        def get_user_variables
+          return "" unless user_variables
+          if user_variables.is_a? String
+            return %Q|#{user_variables}\n|
+          elsif user_variables.is_a? Hash
+            ret = ""
+            user_variables.each do |key, value|
+              ret << %Q|#{key}="#{value}"\n|
+            end
+            return ret
+          else
+            return ""
+          end
+        end
+
+      end
+    end
+  end
+end