forj 1.0.1 → 1.0.2

data/lib/lib-forj/lib/core_process/CloudProcess.rb

@@ -1,334 +0,0 @@
-#!/usr/bin/env ruby
-# encoding: UTF-8
-
-# (c) Copyright 2014 Hewlett-Packard Development Company, L.P.
-#
-#    Licensed under the Apache License, Version 2.0 (the "License");
-#    you may not use this file except in compliance with the License.
-#    You may obtain a copy of the License at
-#
-#        http://www.apache.org/licenses/LICENSE-2.0
-#
-#    Unless required by applicable law or agreed to in writing, software
-#    distributed under the License is distributed on an "AS IS" BASIS,
-#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-#    See the License for the specific language governing permissions and
-#    limitations under the License.
-
-# It requires Core objects to be defined + default ForjProcess functions.
-
-require File.join($CORE_PROCESS_PATH, "global_process.rb")
-require File.join($CORE_PROCESS_PATH, "network_process.rb")
-
-# Define framework object on BaseDefinition
-class BaseDefinition
-
-   # All objects used by this process are built from a Controller
-   process_default :use_controller => true
-
-   # predefined list of objects.
-   # Links between objects is not predefined. To do it, use needs declaration in your provider class.
-
-   # object to get list of services
-   # Defines Process handler to call
-   define_obj(:services,
-      {
-         :create_e => :connect
-      })
-   obj_needs   :data, :auth_uri
-   obj_needs   :data, :account_id
-   obj_needs   :data, :account_key
-   obj_needs   :data, :tenant
-
-   undefine_attribute :id    # Do not return any predefined ID
-   undefine_attribute :name  # Do not return any predefined NAME
-
-
-   # compute_connection
-   define_obj(:compute_connection,
-      {
-         :create_e => :connect # Will call ForjProcess connect
-      })
-   obj_needs   :data, :account_id
-   obj_needs   :data, :account_key
-   obj_needs   :data, :auth_uri
-   obj_needs   :data, :tenant
-   obj_needs   :data, :compute
-
-   undefine_attribute :id    # Do not return any predefined ID
-   undefine_attribute :name  # Do not return any predefined NAME
-
-   # network_connection
-   define_obj(:network_connection,
-      {
-         :create_e => :connect
-      })
-   obj_needs   :data, :account_id
-   obj_needs   :data, :account_key
-   obj_needs   :data, :auth_uri
-   obj_needs   :data, :tenant
-   obj_needs   :data, :network
-
-   undefine_attribute :id    # Do not return any predefined ID
-   undefine_attribute :name  # Do not return any predefined NAME
-
-   # ************************************ Network Object
-   # Identify the network
-
-   define_obj(:network,
-              :create_e    => :forj_get_or_create_network,
-              :query_e     => :forj_query_network,
-              :get_e       => :forj_get_network,
-              :delete_e    => :forj_delete_network
-             )
-   obj_needs   :CloudObject,  :network_connection
-   obj_needs   :data,         :network_name,       { :for => [:create_e] }
-
-   obj_needs_optional
-   obj_needs   :data,         :subnetwork_name,    { :for => [:create_e] }
-
-   def_query_attribute :external # true if network is external or not.
-
-   # ************************************ SubNetwork Object
-   # Identify subnetwork as part of network.
-   define_obj(:subnetwork,
-              :create_e    => :forj_get_or_create_subnetwork
-             )
-
-   obj_needs   :CloudObject,  :network_connection
-   obj_needs   :CloudObject,  :network
-   obj_needs   :data,         :subnetwork_name
-
-   def_query_attribute :network_id
-
-   # ************************************ Port Object
-   # Identify port attached to network
-   define_obj  :port,   :nohandler => true
-
-   obj_needs   :CloudObject,  :network_connection
-   def_attribute :device_id
-
-   def_query_attribute :network_id
-   def_query_attribute :device_owner
-
-
-   # ************************************ Router Object
-   # Identify the router of a network.
-   define_obj(:router,
-      {
-         :create_e   => :forj_get_or_create_router,
-#         :query_e    => :forj_query_router,
-#         :get_e      => :forj_get_router,
-         :update_e   => :forj_update_router
-#         :delete_e   => :forj_delete_router
-      })
-   obj_needs   :CloudObject,  :network_connection
-   obj_needs   :CloudObject,  :network,            { :for => [:create_e] }
-   obj_needs   :CloudObject,  :subnetwork,         { :for => [:create_e] }
-   obj_needs_optional
-   obj_needs   :data,         :router_name,        { :for => [:create_e] }
-
-   def_attribute :gateway_network_id
-
-   # ************************************ Router interface Object
-   # Identify interface attached to a router
-   # This object will probably be moved to controller task
-   # To keep the network model more generic.
-
-   # No process handler defined. Just Controller object
-   define_obj  :router_interface,   :nohandler => true
-
-   obj_needs   :CloudObject,  :network_connection
-   obj_needs   :CloudObject,  :router,             { :for => [:create_e] }
-   obj_needs   :CloudObject,  :subnetwork,         { :for => [:create_e] }
-
-   undefine_attribute   :name
-   undefine_attribute   :id
-
-   # Identify an external network thanks to the network router.
-   define_obj(:external_network,
-      {
-         :create_e   => :forj_get_or_create_ext_net,
-         :query_e    => :forj_query_external_network
-      })
-
-   obj_needs   :CloudObject,  :network_connection
-   obj_needs   :CloudObject,  :router
-
-
-   # ************************************ Security groups Object
-   # Identify security_groups
-   define_obj(:security_groups,
-      {
-         :create_e   => :forj_get_or_create_sg,
-         :query_e    => :forj_query_sg,
-         :delete_e   => :forj_delete_sg
-      })
-
-   obj_needs   :CloudObject,  :network_connection
-   obj_needs   :data,         :security_group,     { :for => [:create_e] }
-   obj_needs_optional
-   obj_needs   :data,         :sg_desc,            { :for => [:create_e] }
-
-   # ************************************ Security group rules Object
-   # Identify Rules attached to the security group
-   define_obj(:rule,
-      {
-         :create_e   => :forj_get_or_create_rule,
-         :query_e    => :forj_query_rule
-#         :delete_e   => :forj_delete_rule
-      })
-
-   undefine_attribute :name  # Do not return any predefined name attribute
-
-   obj_needs   :CloudObject,  :network_connection
-   obj_needs   :CloudObject,  :security_groups,    { :for => [:create_e] }
-   obj_needs   :data,         :sg_id,              { :for => [:create_e], :extract_from => [:security_groups, :attrs, :id] }
-   obj_needs   :data,         :dir,                { :for => [:create_e] }
-   predefine_data_value :IN,  { :desc => "Input NAT/firewall rule map type" }
-   predefine_data_value :OUT, { :desc => "Output NAT/firewall rule map type" }
-   obj_needs   :data,         :proto,              { :for => [:create_e] }
-   obj_needs   :data,         :port_min,           { :for => [:create_e] }
-   obj_needs   :data,         :port_max,           { :for => [:create_e] }
-   obj_needs   :data,         :addr_map,           { :for => [:create_e] }
-
-   # ************************************ keypairs Object
-   # Identify keypairs
-   define_obj(:keypairs,
-      {
-         :create_e   => :forj_get_or_create_keypair,
-         :query_e    => :forj_query_keypair
-#         :delete_e   => :forj_delete_keypair
-      })
-
-   obj_needs   :CloudObject,  :compute_connection
-   obj_needs   :data,         :keypair_name,       { :for => [:create_e] }
-   obj_needs   :data,         :keypair_path,       { :for => [:create_e] }
-
-   obj_needs_optional
-   obj_needs   :data,         :public_key,         { :for => [:create_e] }
-
-   def_attribute :public_key
-
-   # ************************************ Image Object
-   # Identify image
-   define_obj(:image,
-      {
-         :create_e   => :forj_get_or_create_image,
-         :query_e    => :forj_query_image
-#         :get_e      => :forj_get_image
-#         :update_e   => :forj_update_image
-#         :delete_e   => :forj_delete_image
-      })
-
-   obj_needs   :CloudObject,  :compute_connection
-   obj_needs   :data,         :image_name,         { :for => [:create_e] }
-
-   # ************************************ Flavor Object
-   # Identify flavor
-   define_obj(:flavor,
-      {
-         :create_e   => :forj_get_or_create_flavor,
-         :query_e    => :forj_query_flavor
-#         :get_e      => :forj_get_flavor,
-#         :update_e   => :forj_update_flavor,
-#         :delete_e   => :forj_delete_flavor
-      })
-
-   obj_needs   :CloudObject,  :compute_connection
-   obj_needs   :data,         :flavor_name,        { :for => [:create_e] }
-   # Cloud provider will need to map to one of those predefined flavors.
-   # limitation values may match exactly or at least ensure those limitation
-   # are under provider limitation
-   # ie, at least the CloudProcess limitation can less than the Cloud provider defines.
-   # CloudProcess EHD = 160, then Provider EHD = 200 is ok
-   # but Provider EHD = 150 is not ok.
-   predefine_data_value('tiny',   { :desc => "VCU: 1,  RAM:512M, HD:1G,   EHD: 0G,   Swap: 0G" })
-   predefine_data_value('xsmall', { :desc => "VCU: 1,  RAM:1G,   HD:10G,  EHD: 10G,  Swap: 0G" })
-   predefine_data_value('small',  { :desc => "VCU: 2,  RAM:2G,   HD:30G,  EHD: 10G,  Swap: 0G" })
-   predefine_data_value('medium', { :desc => "VCU: 2,  RAM:4G,   HD:30G,  EHD: 50G,  Swap: 0G" })
-   predefine_data_value('large',  { :desc => "VCU: 4,  RAM:8G,   HD:30G,  EHD: 100G, Swap: 0G" })
-   predefine_data_value('xlarge', { :desc => "VCU: 8,  RAM:16G,  HD:30G,  EHD: 200G, Swap: 0G" })
-
-   # ************************************ Internet network Object
-   # Define Internet network
-   #
-   # This object contains the logic to ensure the router's network has a gateway to the external network (internet)
-   # is capable to connect to internet
-   # And to create this connection if possible.
-
-   define_obj(:internet_network,    :nohandler => true )
-
-   obj_needs   :CloudObject,  :external_network # External network to connect if needed.
-
-   # ************************************ SERVER Object
-   # Identify the server to use/build on the network/...
-   define_obj(:server,
-      {
-         :create_e   => :forj_get_or_create_server,
-         :query_e    => :forj_query_server,
-         :get_e      => :forj_get_server
-#         :update_e   => :forj_update_server,
-#         :delete_e   => :forj_delete_server
-      })
-
-   obj_needs   :CloudObject,  :compute_connection
-   obj_needs   :CloudObject,  :flavor,             { :for => [:create_e] }
-   obj_needs   :CloudObject,  :network,            { :for => [:create_e] }
-   obj_needs   :CloudObject,  :security_groups,    { :for => [:create_e] }
-   obj_needs   :CloudObject,  :keypairs,           { :for => [:create_e] }
-   obj_needs   :CloudObject,  :image,              { :for => [:create_e] }
-   obj_needs   :data,         :server_name,        { :for => [:create_e] }
-
-   obj_needs_optional
-   obj_needs   :data,         :user_data,          { :for => [:create_e] }
-   obj_needs   :data,         :meta_data,          { :for => [:create_e] }
-
-   def_attribute  :status
-   predefine_data_value :create,  { :desc => "Server is creating." }
-   predefine_data_value :boot,    { :desc => "Server is booting." }
-   predefine_data_value :active,  { :desc => "Server is started." }
-   def_attribute  :private_ip_address
-   def_attribute  :public_ip_address
-
-   # ************************************ SERVER Addresses Object
-   # Object representing the list of IP addresses attached to a server.
-   define_obj(:public_ip,
-      :create_e   => :forj_get_or_assign_public_address,
-      :query_e    => :forj_query_public_address
-#      :get_e      => :forj_get_address
-#      :update_e   => :forj_update_address
-#      :delete_e   => :forj_delete_address
-   )
-
-   obj_needs   :CloudObject,  :compute_connection
-   obj_needs   :CloudObject,  :server
-
-   def_attribute :server_id
-   def_attribute :public_ip
-   undefine_attribute :name # No name to extract
-
-   # ************************************ SERVER Console Object
-   # Object representing the console log attached to a server
-
-   define_obj(:server_log,
-      {
-         :get_e      => :forj_get_server_log
-      })
-
-   obj_needs   :CloudObject,  :server
-   obj_needs   :data,         :log_lines
-   undefine_attribute  :name
-   undefine_attribute  :id
-   def_attribute  :output
-
-   # ************************************ Internet SERVER Object
-   # internet server is a server connected to the internet network.
-   define_obj(:internet_server,    :nohandler => true )
-
-   obj_needs   :CloudObject,  :internet_network
-   obj_needs   :CloudObject,  :server
-   obj_needs   :CloudObject,  :public_ip
-
-
-end

data/lib/lib-forj/lib/core_process/global_process.rb

@@ -1,406 +0,0 @@
-# encoding: UTF-8
-
-# (c) Copyright 2014 Hewlett-Packard Development Company, L.P.
-#
-#    Licensed under the Apache License, Version 2.0 (the "License");
-#    you may not use this file except in compliance with the License.
-#    You may obtain a copy of the License at
-#
-#        http://www.apache.org/licenses/LICENSE-2.0
-#
-#    Unless required by applicable law or agreed to in writing, software
-#    distributed under the License is distributed on an "AS IS" BASIS,
-#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-#    See the License for the specific language governing permissions and
-#    limitations under the License.
-
-class SSLErrorMgt
-
-   def initialize(iMaxRetry = 5)
-      @iRetry = 0
-      @iMaxRetry = iMaxRetry
-   end
-
-   def ErrorDetected(message,backtrace, e)
-      if message.match('SSLv2/v3 read server hello A: unknown protocol')
-         if @iRetry <@iMaxRetry
-            sleep(2)
-            @iRetry+=1
-            print "%s/%s try... 'unknown protocol' SSL Error\r" % [@iRetry, @iMaxRetry] if $FORJ_LOGGER.level == 0
-            return false
-         else
-            Logging.error('Too many retry. %s' % message)
-            return true
-         end
-      elsif e.is_a?(Excon::Errors::InternalServerError)
-         if @iRetry <@iMaxRetry
-            sleep(2)
-            @iRetry+=1
-            print "%s/%s try... %s\n" % [@iRetry, @iMaxRetry, ANSI.red(e.class)] if $FORJ_LOGGER.level == 0
-            return false
-         else
-            Logging.error('Too many retry. %s' % message)
-            return true
-         end
-      else
-         Logging.error("Exception %s: %s\n%s" % [e.class, message,backtrace.join("\n")])
-         return true
-      end
-   end
-
-end
-
-
-class CloudProcess < BaseProcess
-   def connect(sCloudObj, hParams)
-      oSSLError = SSLErrorMgt.new # Retry object
-      Logging.debug("%s:%s Connecting to '%s' - Project '%s'" % [self.class, sCloudObj, config.get(:provider), hParams[:tenant]])
-      begin
-         controler.connect(sCloudObj)
-      rescue => e
-         if not oSSLError.ErrorDetected(e.message,e.backtrace, e)
-            retry
-         end
-         Logging.error('%s:%s: Unable to connect.\n%s' % [self.class, sCloudObj, e.message ])
-         nil
-      end
-   end
-end
-
-# ---------------------------------------------------------------------------
-# Keypair management
-# ---------------------------------------------------------------------------
-class CloudProcess
-   def forj_get_or_create_keypair(sCloudObj, hParams)
-      sKeypair_name = hParams[:keypair_name]
-      # setup has configured and copied the appropriate key to forj keypairs.
-
-      hKeys = keypair_detect(sKeypair_name, File.expand_path(hParams[:keypair_path]))
-      if hKeys[:private_key_exist? ]
-         hParams[:private_key_file] = File.join(hKeys[:keypair_path], hKeys[:private_key_name])
-         Logging.info("Openssh private key file '%s' exists." % hParams[:private_key_file])
-      end
-      if hKeys[:public_key_exist? ]
-         hParams[:public_key_file] = File.join(hKeys[:keypair_path], hKeys[:public_key_name])
-      else
-         Logging.fatal("Public key file is not found. Please run 'forj setup %s'" % config[:account_name])
-      end
-
-      Logging.state("Searching for keypair '%s'" % [sKeypair_name] )
-
-      keypairs = forj_query_keypair(sCloudObj, {:name => sKeypair_name}, hParams)
-      if keypairs.length > 0
-         keypair = keypairs[0]
-         # Check the public key with the one found here, locally.
-         if not keypair[:public_key].nil? and keypair[:public_key] != ""
-            begin
-               local_pub_key = File.read(hParams[:public_key_file])
-            rescue => e
-               Logging.error("Unable to read '%s'.\n%s",[hParams[:public_key_file], e.message] )
-               keypair[:coherent] = false
-            else
-               if local_pub_key.split(' ')[1].strip == keypair[:public_key].split(' ')[1].strip
-                  Logging.info("keypair '%s' local files are coherent with keypair in your cloud service. You will be able to connect to your box over SSH." % sKeypair_name)
-                  keypair[:coherent] = true
-               else
-                  keypair[:coherent] = false
-                  Logging.warning("Your local keypair file '%s' are incoherent with public key '%s' found in your cloud. You won't be able to access your box with this keypair.\nPublic key found in the cloud:\n%s" % [hParams[:public_key_file], sKeypair_name, keypair[:public_key]])
-               end
-            end
-         else
-            keypair[:coherent] = false
-            Logging.warning("Unable to verify keypair coherence between your cloud and your local SSH keys. The cloud controller did not provided ':public_key'")
-         end
-      else
-         config[:public_key] = File.read(hParams[:public_key_file])
-         keypair = create_keypair(sCloudObj, hParams)
-         if not hKeys[:private_key_exist? ]
-            keypair[:coherent] = false
-         else
-            keypair[:coherent] = true
-         end
-      end
-      # Adding information about key files.
-      keypair[:private_key_file] = hParams[:private_key_file]
-      keypair[:public_key_file] = hParams[:public_key_file]
-      keypair
-   end
-
-   def forj_query_keypair(sCloudObj, sQuery, hParams)
-      key_name = hParams[:keypair_name]
-      oSSLError = SSLErrorMgt.new
-      begin
-         oList = controler.query(sCloudObj, sQuery)
-         query_single(sCloudObj, oList, sQuery, key_name)
-      rescue => e
-         if not oSSLError.ErrorDetected(e.message, e.backtrace, e)
-            retry
-         end
-      end
-
-   end
-
-   def create_keypair(sCloudObj, hParams)
-      key_name = hParams[:keypair_name]
-      Logging.state("Importing keypair '%s'" % [key_name])
-      oSSLError=SSLErrorMgt.new
-      begin
-         keypair = controler.create(sCloudObj)
-         Logging.info("Keypair '%s' imported." % [keypair[:name]])
-      rescue StandardError => e
-         if not oSSLError.ErrorDetected(e.message,e.backtrace, e)
-            retry
-         end
-         Logging.error "error importing keypair '%s'" % [key_name]
-      end
-      keypair
-   end
-
-   def keypair_detect(keypair_name, key_fullpath)
-      # Build key data information structure.
-      # Take care of priv with or without .pem and pubkey with pub.
-
-      key_basename = File.basename(key_fullpath)
-      key_path = File.expand_path(File.dirname(key_fullpath))
-
-      mObj = key_basename.match(/^(.*?)(\.pem|\.pub)?$/)
-      key_basename = mObj[1]
-
-      private_key_ext = nil
-      private_key_ext = "" if File.exists?(File.join(key_path, key_basename))
-      private_key_ext = '.pem' if File.exists?(File.join(key_path, key_basename + '.pem'))
-      if private_key_ext
-         private_key_exist = true
-         private_key_name = key_basename + private_key_ext
-      else
-         private_key_exist = false
-         private_key_name = key_basename
-      end
-
-      public_key_exist = File.exists?(File.join(key_path, key_basename + '.pub'))
-      public_key_name = key_basename + '.pub'
-
-
-      {:keypair_name     => keypair_name,
-       :keypair_path     => key_path,         :key_basename       => key_basename,
-       :private_key_name => private_key_name, :private_key_exist? => private_key_exist,
-       :public_key_name  => public_key_name,  :public_key_exist?  => public_key_exist,
-      }
-   end
-
-end
-
-# ---------------------------------------------------------------------------
-# flavor management
-# ---------------------------------------------------------------------------
-class CloudProcess
-   # Depending on clouds/rights, we can create flavor or not.
-   # Usually, flavor records already exists, and the controller may map them
-   # CloudProcess predefines some values. Consult CloudProcess.rb for details
-   def forj_get_or_create_flavor(sCloudObj, hParams)
-      sFlavor_name = hParams[:flavor_name]
-      Logging.state("Searching for flavor '%s'" % [sFlavor_name] )
-
-      flavors = query_flavor(sCloudObj, {:name => sFlavor_name}, hParams)
-      if flavors.length == 0
-         if not hParams[:create]
-            Logging.error("Unable to create %s '%s'. Creation is not supported." % [sCloudObj, sFlavor_name])
-            ForjLib::Data.new.set(nil, sCloudObj)
-         else
-            create_flavor(sCloudObj,hParams)
-         end
-      else
-         flavors[0]
-      end
-   end
-
-   # Should return 1 or 0 flavor.
-   def query_flavor(sCloudObj, sQuery, hParams)
-      sFlavor_name = hParams[:flavor_name]
-      oList = forj_query_flavor(sCloudObj, sQuery, hParams)
-      query_single(sCloudObj, oList, sQuery, sFlavor_name)
-   end
-
-   # Should return 1 or 0 flavor.
-   def forj_query_flavor(sCloudObj, sQuery, hParams)
-      sFlavor_name = hParams[:flavor_name]
-      oSSLError = SSLErrorMgt.new
-      begin
-         oList = controler.query(sCloudObj, sQuery)
-      rescue => e
-         if not oSSLError.ErrorDetected(e.message,e.backtrace, e)
-            retry
-         end
-      end
-      oList
-   end
-end
-
-# ---------------------------------------------------------------------------
-# Image management
-# ---------------------------------------------------------------------------
-class CloudProcess < BaseProcess
-   def forj_get_or_create_image(sCloudObj, hParams)
-      sImage_name = hParams[:image_name]
-      Logging.state("Searching for image '%s'" % [sImage_name] )
-
-      search_the_image(sCloudObj, {:name => sImage_name}, hParams)
-      # No creation possible.
-   end
-
-   def search_the_image(sCloudObj, sQuery, hParams)
-      image_name = hParams[:image_name]
-      images = forj_query_image(sCloudObj, sQuery, hParams)
-      case images.length()
-        when 0
-          Logging.info("No image '%s' found" % [ image_name ] )
-          nil
-        else
-          Logging.info("Found image '%s'." % [ image_name ])
-          images[0]
-      end
-   end
-
-   def forj_query_image(sCloudObj, sQuery, hParams)
-      oSSLError = SSLErrorMgt.new
-      begin
-         controler.query(sCloudObj, sQuery)
-      rescue => e
-         if not oSSLError.ErrorDetected(e.message,e.backtrace, e)
-           retry
-         end
-      end
-   end
-end
-
-# ---------------------------------------------------------------------------
-# Server management
-# ---------------------------------------------------------------------------
-class CloudProcess < BaseProcess
-   # Process Handler functions
-   def forj_get_or_create_server(sCloudObj, hParams)
-      sServer_name = hParams[:server_name]
-      Logging.state("Searching for server '%s'" % [sServer_name] )
-      servers = forj_query_server(sCloudObj, {:name => sServer_name}, hParams)
-      if servers.length > 0
-         # Get server details
-         forj_get_server(sCloudObj, servers[0][:attrs][:id], hParams)
-      else
-         create_server(sCloudObj, hParams)
-      end
-   end
-
-   def forj_query_server(sCloudObj, sQuery, hParams)
-      server_name = "Undefined"
-      server_name = sQuery[:name] if sQuery.key?(:name)
-      oSSLError = SSLErrorMgt.new
-      begin
-         oList = controler.query(sCloudObj, sQuery)
-         query_single(sCloudObj, oList, sQuery, server_name)
-      rescue => e
-         if not oSSLError.ErrorDetected(e.message,e.backtrace, e)
-           retry
-         end
-      end
-   end
-
-   def forj_get_server(sCloudObj, sId, hParams)
-      oSSLError = SSLErrorMgt.new
-      begin
-         controler.get(sCloudObj, sId)
-      rescue => e
-         if not oSSLError.ErrorDetected(e.message,e.backtrace, e)
-           retry
-         end
-      end
-   end
-
-   # Internal Process function
-   def create_server(sCloudObj, hParams)
-      name = hParams[:server_name]
-      begin
-         Logging.info("boot: meta-data provided.") if hParams[:meta_data]
-         Logging.info("boot: user-data provided.") if hParams[:user_data]
-         Logging.state('creating server %s' % [name])
-         server = controler.create(sCloudObj)
-         Logging.info("%s '%s' created." % [sCloudObj, name])
-      rescue => e
-         Logging.fatal(1, "Unable to create server '%s'" % name, e)
-      end
-      server
-   end
-
-   def forj_get_server_log(sCloudObj, sId, hParams)
-      oSSLError = SSLErrorMgt.new
-      begin
-         controler.get(sCloudObj, sId)
-      rescue => e
-         if not oSSLError.ErrorDetected(e.message,e.backtrace, e)
-           retry
-         end
-      end
-   end
-end
-# ---------------------------------------------------------------------------
-# Addresses management
-# ---------------------------------------------------------------------------
-class CloudProcess < BaseProcess
-   # Process Handler functions
-   def forj_get_or_assign_public_address(sCloudObj, hParams)
-      # Function which to assign a public IP address to a server.
-      sServer_name = hParams[:server, :name]
-
-      Logging.state("Searching public IP for server '%s'" % [sServer_name] )
-      addresses = controler.query(sCloudObj, {:server_id => hParams[:server, :id]})
-      if addresses.length == 0
-         assign_address(sCloudObj, hParams)
-      else
-         addresses[0]
-      end
-   end
-
-   def forj_query_public_address(sCloudObj, sQuery, hParams)
-      server_name = hParams[:server, :name]
-      oSSLError = SSLErrorMgt.new
-      begin
-         sInfo = {
-         :notfound   => "No %s for '%s' found",
-         :checkmatch => "Found 1 %s. checking exact match for server '%s'.",
-         :nomatch    => "No %s for '%s' match",
-         :found      => "Found %s '%s' for #{server_name}.",
-         :more       => "Found several %s. Searching for '%s'.",
-         :items      => :public_ip
-         }
-         oList = controler.query(sCloudObj, sQuery)
-         query_single(sCloudObj, oList, sQuery, server_name, sInfo)
-      rescue => e
-         if not oSSLError.ErrorDetected(e.message,e.backtrace, e)
-           retry
-         end
-      end
-   end
-
-   def forj_get_public_address(sCloudObj, sId, hParams)
-      oSSLError = SSLErrorMgt.new
-      begin
-         controler.get(sCloudObj, sId)
-      rescue => e
-         if not oSSLError.ErrorDetected(e.message,e.backtrace, e)
-           retry
-         end
-      end
-   end
-
-   # Internal Process function
-   def assign_address(sCloudObj, hParams)
-      name = hParams[:server, :name]
-      begin
-         Logging.state('Getting public IP for server %s' % [name])
-         ip_address = controler.create(sCloudObj)
-         Logging.info("Public IP '%s' for server '%s' assigned." % [ip_address[:public_ip], name])
-      rescue => e
-         Logging.fatal(1, "Unable to assign a public IP to server '%s'" % name, e)
-      end
-      ip_address
-   end
-end