fog-arubacloud 0.0.3

data/lib/fog/arubacloud/examples/create_smart_server.rb

@@ -0,0 +1,39 @@
+#
+# Author:: Alessio Rocchi (<alessio.rocchi@staff.aruba.it>)
+# © Copyright ArubaCloud.
+#
+# LICENSE: MIT (http://opensource.org/licenses/MIT)
+#
+
+require 'rubygems'
+require 'fog/arubacloud'
+require 'securerandom'
+require 'optparse'
+
+options = {}
+OptionParser.new do |opts|
+  opts.banner = 'Usage: get_servers.rb [options]'
+  opts.on('-uUSERNAME', '--username=USERNAME', 'ArubaCloud Username') { |n| options[:username] = n}
+  opts.on('-pPASSWORD', '--password=PASSWORD', 'ArubaCloud Password') { |p| options[:password] = p}
+end.parse!
+
+# Fog.mock!
+service = Fog::Compute.new({
+                               :provider             => 'ArubaCloud',
+                               :arubacloud_username  => options[:username],
+                               :arubacloud_password  => options[:password]
+                           })
+
+## Generate random string to append to vm name
+rnd_string = SecureRandom.hex(2)
+
+# Create a Smart VM
+server = service.servers.create({
+                                    :name           => "testfog#{rnd_string}",
+                                    :vm_type        => 'smart',
+                                    :admin_passwd   => 'Prova123',
+                                    :cpu            => 1,
+                                    :memory         => 1,
+                                    :template_id    => '415',
+                                    :package_id     => 1
+                                })

data/lib/fog/arubacloud/examples/get_objects.rb

@@ -0,0 +1,44 @@
+#
+# Author:: Alessio Rocchi (<alessio.rocchi@staff.aruba.it>)
+# © Copyright ArubaCloud.
+#
+# LICENSE: MIT (http://opensource.org/licenses/MIT)
+#
+
+require 'rubygems'
+require 'fog/arubacloud'
+require 'optparse'
+
+options = {}
+OptionParser.new do |opts|
+  opts.banner = 'Usage: get_servers.rb [options]'
+  opts.on('-uUSERNAME', '--username=USERNAME', 'ArubaCloud Username') { |n| options[:username] = n}
+  opts.on('-pPASSWORD', '--password=PASSWORD', 'ArubaCloud Password') { |p| options[:password] = p}
+end.parse!
+
+# Fog.mock!
+service = Fog::Compute.new({
+                               :provider             => 'ArubaCloud',
+                               :arubacloud_username  => options[:username],
+                               :arubacloud_password  => options[:password]
+                           })
+
+# Retrieve purchased IP list.
+# ips = service.ips
+# ips.each { |ip| puts ip.address }
+
+# Retrieve template list
+# Hypervisor Types:
+#  1 -> Microsoft Hyper-V - Cloud Pro
+#  2 -> VMWare - Cloud Pro
+#  3 -> Microsoft Hyper-V Low Cost - Cloud Pro
+#  4 -> VMWare - Cloud Smart
+templates = service.templates
+# Filter only smart templates
+smart_templates = templates.select { |template| template.hypervisor.eql?(4) && template.enabled }
+# Filter only templates which contains Centos in the name
+centos_smart = smart_templates.select { |template| template.name.include?('Centos')}
+centos_smart.each do |t|
+  puts t.name
+  puts t.id
+end

data/lib/fog/arubacloud/examples/get_servers.rb

@@ -0,0 +1,31 @@
+#
+# Author:: Alessio Rocchi (<alessio.rocchi@staff.aruba.it>)
+# © Copyright ArubaCloud.
+#
+# LICENSE: MIT (http://opensource.org/licenses/MIT)
+#
+
+require 'rubygems'
+require 'fog/arubacloud'
+require 'optparse'
+
+options = {}
+OptionParser.new do |opts|
+  opts.banner = 'Usage: get_servers.rb [options]'
+  opts.on('-uUSERNAME', '--username=USERNAME', 'ArubaCloud Username') { |n| options[:username] = n}
+  opts.on('-pPASSWORD', '--password=PASSWORD', 'ArubaCloud Password') { |p| options[:password] = p}
+end.parse!
+
+service = Fog::Compute.new({
+    :provider             => 'ArubaCloud',
+    :arubacloud_username  => options[:username],
+    :arubacloud_password  => options[:password]
+})
+
+servers = service.servers
+servers.all.each do |server|
+  server.get_server_details
+  server.get_public_ip
+  puts server.id
+  puts server.name
+end

data/lib/fog/arubacloud/examples/vm_operations.rb

@@ -0,0 +1,60 @@
+#
+# Author:: Alessio Rocchi (<alessio.rocchi@staff.aruba.it>)
+# © Copyright ArubaCloud.
+#
+# LICENSE: MIT (http://opensource.org/licenses/MIT)
+#
+
+require 'rubygems'
+require 'fog/arubacloud'
+require 'optparse'
+
+options = {}
+OptionParser.new do |opts|
+  opts.banner = 'Usage: get_servers.rb [options]'
+  opts.on('-uUSERNAME', '--username=USERNAME', 'ArubaCloud Username') { |n| options[:username] = n}
+  opts.on('-pPASSWORD', '--password=PASSWORD', 'ArubaCloud Password') { |p| options[:password] = p}
+end.parse!
+
+# Fog.mock!
+service = Fog::Compute.new({
+                               :provider             => 'ArubaCloud',
+                               :arubacloud_username  => options[:username],
+                               :arubacloud_password  => options[:password]
+                           })
+
+
+servers = service.servers
+
+# Poweroff and delete every VM in a Datacenter
+servers.each do |s|
+  puts("Powering Off and Deleting VM: #{s.name}...")
+  next if s.state == Fog::Compute::ArubaCloud::Server::CREATING
+  s.power_off unless s.stopped?
+  until s.stopped?
+    s.get_server_details
+    puts(" --- Waiting for VM: #{s.name} to power off...")
+  end
+  begin
+    puts(' --- Enqueued Server Deletion')
+    s.delete
+  rescue
+    next
+  end
+end
+
+# Delete all vm in a datacenter
+#servers.each do |s|
+#  begin
+#    s.delete
+#  rescue
+#    next
+#  end
+#end
+
+# Release all unassociated IP
+# ips = service.ips
+# ips.each do |i|
+#   puts i.address
+#   i.remove
+# end

data/lib/fog/arubacloud/models/compute/disk.rb

@@ -0,0 +1,47 @@
+#
+# Author:: Alessio Rocchi (<alessio.rocchi@staff.aruba.it>)
+# © Copyright ArubaCloud.
+#
+# LICENSE: MIT (http://opensource.org/licenses/MIT)
+#
+
+require 'fog/core/model'
+require 'fog/arubacloud/error'
+
+module Fog
+  module Compute
+    class ArubaCloud
+      class Disk < Fog::Model
+        attribute :size
+        attribute :virtual_disk_type
+
+        # Fake create method, it returns only an hash representing the json scheme of a disk
+        # @return [Hash] hash object representing the disk
+        # @raise [Fog::ArubaCloud::Errors::BadDiskSize]
+        # @raise [Fog::ArubaCloud::Errors::BadDiskNumber]
+        def create
+          requires :size, :virtual_disk_type
+
+          raise Fog::ArubaCloud::Errors::BadDiskSize.new('Maximum disk size: 500GB') unless
+              size <= 500 # maximum disk size: 500GB
+          raise Fog::ArubaCloud::Errors::BadDiskNumber.new('Only 4 disks are supported per VM') unless
+              virtual_disk_type < 3 # only 4 disks are supported per VM
+        end
+
+        def save
+          create
+        end
+
+        # Return an hash representation of the object in order to be used in json request
+        def get_hash
+          requires :size, :virtual_disk_type
+          {
+              :Size => size,
+              :VirtualDiskType => virtual_disk_type
+          }
+        end
+
+      end #Disk
+    end #ArubaCloud
+  end #Compute
+end #Fog

data/lib/fog/arubacloud/models/compute/disks.rb

@@ -0,0 +1,31 @@
+#
+# Author:: Alessio Rocchi (<alessio.rocchi@staff.aruba.it>)
+# © Copyright ArubaCloud.
+#
+# LICENSE: MIT (http://opensource.org/licenses/MIT)
+#
+
+require 'fog/core/collection'
+require 'fog/arubacloud/models/compute/ip'
+
+module Fog
+  module Compute
+    class ArubaCloud
+
+      class Disks < Fog::Collection
+        model Fog::Compute::ArubaCloud::Disk
+
+        # Dummy Method, only to maintain fog structure, it returns nothings.
+        # @return [Nil]
+        def all
+        end
+
+        # Another dummy method, it returns nothings.
+        # @return [Nil]
+        def get
+        end
+      end #Disks
+
+    end #ArubaCloud
+  end #Compute
+end #Fog

data/lib/fog/arubacloud/models/compute/ip.rb

@@ -0,0 +1,45 @@
+#
+# Author:: Alessio Rocchi (<alessio.rocchi@staff.aruba.it>)
+# © Copyright ArubaCloud.
+#
+# LICENSE: MIT (http://opensource.org/licenses/MIT)
+#
+
+require 'fog/core/model'
+require 'fog/arubacloud/error'
+
+module Fog
+  module Compute
+    class ArubaCloud
+      class IP < Fog::Model
+        identity :id, :aliases => 'ResourceId'
+
+        attribute :gateway, :aliases => 'Gateway'
+        attribute :server , :aliases => 'ServerId'
+        attribute :address, :aliases => 'Value'
+        attribute :netmask, :aliases => 'SubNetMask'
+        attribute :product_id, :aliases => 'ProductId'
+        attribute :loadbalancer_id, :aliases => 'LoadBalancerID'
+        ignore_attributes :CompanyId, :ResourceType
+
+        def initialize(attributes = {})
+          @service = attributes[:service]
+          super
+        end
+
+        def purchase
+          @service.purchase_ip
+        end
+
+        def remove
+          requires :id, :server
+          unless server.nil?
+            raise Fog::ArubaCloud::Errors::RequestError.new('Cannot remove an address attached to a vm.')
+          end
+          @service.remove_ip(id)
+        end
+
+      end #IP
+    end #ArubaCloud
+  end #Compute
+end #Fog

data/lib/fog/arubacloud/models/compute/ips.rb

@@ -0,0 +1,50 @@
+#
+# Author:: Alessio Rocchi (<alessio.rocchi@staff.aruba.it>)
+# © Copyright ArubaCloud.
+#
+# LICENSE: MIT (http://opensource.org/licenses/MIT)
+#
+
+require 'fog/core/collection'
+require 'fog/arubacloud/models/compute/ip'
+
+module Fog
+  module Compute
+    class ArubaCloud
+
+      class Ips < Fog::Collection
+        model Fog::Compute::ArubaCloud::IP
+
+        # Returns list of Ip Addresses
+        # @return [Fog::Compute::ArubaCloud::Ips]
+        # @raise [Fog::ArubaCloud::Errors::NotFound]
+        def all
+          data = service.get_purchased_ip_addresses
+          objects = data['Value']
+          load(objects)
+        end
+
+        # Returns a single IpAddress object
+        # @param ip [String]
+        # @return [Fog::Compute::ArubaCloud::IP]
+        # @raise [Fog::ArubaCloud::Errors::NotFound]
+        def get(ip)
+          # TODO: Implement single item retrieve
+        end
+
+        # Returns list of Ip Addresses related to a Virtual Machine
+        def filter_by_vmid(vmid)
+          # TODO: Implement filter ip per ID
+        end
+
+        # Purchase a new IpAddress
+        # @return [Hash] hash containing the response of the request
+        # @raise [Fog::ArubaCloud::Errors::RequestError]
+        def purchase
+          self << new(service.purchase_ip['Value'])
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/arubacloud/models/compute/network_adapter.rb

@@ -0,0 +1,26 @@
+
+# Author:: Alessio Rocchi (<alessio.rocchi@staff.aruba.it>)
+# © Copyright ArubaCloud.
+#
+# LICENSE: MIT (http://opensource.org/licenses/MIT)
+#
+
+require 'fog/core/model'
+require 'fog/arubacloud/error'
+
+module Fog
+  module Compute
+    class ArubaCloud
+      class NetworkAdapter < Fog::Model
+        identity :id, :aliases => 'Id'
+
+        attribute :mac_address, :aliases => 'MacAddress', :type => String
+        attribute :adapter_type, :aliases => 'NetworkAdapterType', :type => Integer
+        attribute :server_id, :aliases => 'ServerId', :type => Integer
+        attribute :vlan, :aliases => 'VLan', :type => Integer
+
+        has_many :ip_addresses, :ips, aliases: 'IPAddresses'
+      end
+    end
+  end
+end

data/lib/fog/arubacloud/models/compute/network_adapters.rb

@@ -0,0 +1,20 @@
+#
+# Author:: Alessio Rocchi (<alessio.rocchi@staff.aruba.it>)
+# © Copyright ArubaCloud.
+#
+# LICENSE: MIT (http://opensource.org/licenses/MIT)
+#
+
+require 'fog/core/collection'
+require 'fog/arubacloud/models/compute/network_adapter'
+
+
+module Fog
+  module Compute
+    class ArubaCloud
+      class NetworkAdapters < Fog::Collection
+        model Fog::Compute::ArubaCloud::NetworkAdapter
+      end
+    end
+  end
+end

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

@@ -0,0 +1,185 @@
+#
+# Author:: Alessio Rocchi (<alessio.rocchi@staff.aruba.it>)
+# © Copyright ArubaCloud.
+#
+# LICENSE: MIT (http://opensource.org/licenses/MIT)
+#
+
+require 'fog/compute/models/server'
+require 'fog/arubacloud/error'
+
+module Fog
+  module Compute
+    class ArubaCloud
+      class Server < Fog::Compute::Server
+        CREATING = 1
+        STOPPED = 2
+        RUNNING = 3
+        ARCHIVED = 4
+        DELETED = 5
+
+        # This is the instance ID which is unique per Datacenter
+        identity :id, :aliases => 'ServerId'
+
+        attribute :name, :aliases => 'Name'
+        attribute :state, :aliases => 'ServerStatus'
+        attribute :memory, :aliases => 'RAMQuantity', :squash => 'Quantity'
+        attribute :cpu, :aliases => 'CPUQuantity', :squash => 'Quantity'
+        attribute :hypervisor, :aliases => 'HypervisorType'
+        attribute :datacenter_id, :aliases => 'DatacenterId'
+        attribute :hd_qty, :aliases => 'HDQuantity'
+        attribute :hd_total_size, :aliases => 'HDTotalSize'
+        attribute :smart_ipv4, :aliases => 'EasyCloudIPAddress', :squash => 'Value'
+        attribute :smart_package, :aliases => 'EasyCloudPackageID'
+        attribute :vnc_port, :aliases => 'VncPort'
+        attribute :admin_passwd
+        attribute :vm_type
+        attribute :ipv4_addr
+        attribute :package_id
+        attribute :template_id, :aliases => 'OSTemplateId'
+        attribute :template_description, :aliases => 'OSTemplate', :squash => :Description
+
+        #has_many :network_adapters, :network_adapters, aliases: 'NetworkAdapters'
+
+        ignore_attributes :CompanyId, :Parameters, :VirtualDVDs, :RenewDateSmart, :Note, :CreationDate,
+                          :ControlToolActivationDate, :ControlToolInstalled, :UserId, :ScheduledOperations, :Snapshots,
+                          :ActiveJobs
+
+        def initialize(attributes = {})
+          @service = attributes[:service]
+
+          if attributes[:vm_type].nil?
+            self.vm_type = 'smart' if attributes['HypervisorType'].eql? '4' || 'pro'
+          end
+
+          super
+        end
+
+        # Is server in ready state
+        # @param [String] ready_state By default state is RUNNING
+        # @return [Boolean] return true if server is in ready state
+        def ready?(ready_state=RUNNING)
+          state == ready_state
+        end
+
+        # Is server in stopped state
+        # @param [String] stopped_state By default stopped state is STOPPED
+        # @return [Boolean] return true if server is in stopped state
+        def stopped?(stopped_state=STOPPED)
+          state == stopped_state
+        end
+
+        # Is server in creating state
+        # @param [String] creating_state By default creating state is CREATING
+        # @return [Boolean] return true if server is in creating state
+        def creating?(creating_state=CREATING)
+          state == creating_state
+        end
+
+        def save
+          if persisted?
+            update
+          else
+            create
+          end
+        end
+
+        def create
+          requires :name, :cpu, :memory, :admin_passwd, :vm_type
+          data = attributes
+
+          if vm_type.eql? 'pro'
+            # Automatically purchase a public ip address
+            data[:ipv4_id] = service.purchase_ip['Value']['ResourceId']
+            service.create_vm_pro(data)
+          elsif vm_type.eql? 'smart'
+            service.create_vm_smart(data)
+          else
+            raise Fog::ArubaCloud::Errors::BadParameters.new('VM Type can be smart or pro.')
+          end
+
+          # Retrieve new server list and filter the current virtual machine
+          # in order to retrieve the ID
+          # In case of failure, I will try it 3 for 3 times
+          try = 0
+          server = nil
+          while server.nil? && try <= 3
+            servers = service.get_servers
+            #server = servers['Value'].select { |v| v['Name'].include?(data[:name]) }.first
+            servers['Value'].each do |s|
+              if s['Name'].to_s.include? data[:name].to_s
+                server = s
+              end
+            end
+            Fog::Logger.debug("Fog::Compute::ArubaCloud::Server.create, #{data[:name]} server: #{server.inspect}")
+            if server
+              merge_attributes(server)
+            else
+              message = "error during attribute merge, `server` object is not ready, try n.#{try}"
+              Fog::Logger.warning("Fog::Compute::ArubaCloud::Server.create, #{message}")
+              Fog::Logger.warning(servers.inspect.to_yaml)
+              sleep(1)
+            end
+            try += 1
+          end
+        end
+
+        def get_server_details
+          requires :id
+          response = service.get_server_details(id)
+          new_attributes = response['Value']
+          merge_attributes(new_attributes)
+        end
+
+        def get_public_ip
+          requires :id
+          if self.vm_type.eql? 'smart'
+            self.smart_ipv4
+          else
+            self.get_server_details unless self.attributes['NetworkAdapters']
+            self.attributes['NetworkAdapters'].each do |na|
+              na['IPAddresses'].each do |ipa|
+                if ipa['ProductId'].eql? 20
+                  self.ipv4_addr = ipa['Value'].to_s
+                  return self.ipv4_addr
+                end
+              end
+            end
+          end
+
+        end
+
+        def power_off
+          requires :id, :state
+          unless state.eql? RUNNING
+            raise Fog::ArubaCloud::Errors::VmStatus.new("Cannot poweroff vm in current state: #{state}")
+          end
+          @service.power_off_vm(id)
+        end
+
+        def power_on
+          requires :id, :state
+          unless state.eql? STOPPED
+            raise Fog::ArubaCloud::Errors::VmStatus.new("Cannot poweron vm in current state: #{state}")
+          end
+          @service.power_on_vm(id)
+        end
+
+        def delete
+          requires :id
+          state == STOPPED ? service.delete_vm(id) : raise(Fog::ArubaCloud::Errors::VmStatus.new(
+              "Cannot delete vm in current state: #{state}"
+          ))
+        end
+
+        def reinitialize
+          requires :id, :hypervisor
+          state == STOPPED ? service.reinitialize_vm(id) : raise(Fog::ArubaCloud::Errors::VmStatus.new(
+              "Cannot reinitialize vm in current state: #{state}"
+          ))
+        end
+
+      end
+    end
+  end
+end