lorj 0.1.0 → 0.2.0

data/lib/core_process/global_process.rb

@@ -26,24 +26,24 @@ class SSLErrorMgt
          if @iRetry <@iMaxRetry
             sleep(2)
             @iRetry+=1
-            print "%s/%s try... 'unknown protocol' SSL Error\r" % [@iRetry, @iMaxRetry] if $FORJ_LOGGER.level == 0
+            print "%s/%s try... 'unknown protocol' SSL Error\r" % [@iRetry, @iMaxRetry] if PrcLib.level == 0
             return false
          else
-            Logging.error('Too many retry. %s' % message)
+            PrcLib.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
+            print "%s/%s try... %s\n" % [@iRetry, @iMaxRetry, ANSI.red(e.class)] if PrcLib.level == 0
             return false
          else
-            Logging.error('Too many retry. %s' % message)
+            PrcLib.error('Too many retry. %s' % message)
             return true
          end
       else
-         Logging.error("Exception %s: %s\n%s" % [e.class, message,backtrace.join("\n")])
+         PrcLib.error("Exception %s: %s\n%s" % [e.class, message,backtrace.join("\n")])
          return true
       end
    end
@@ -51,17 +51,17 @@ class SSLErrorMgt
 end
 
 
-class CloudProcess < BaseProcess
+class CloudProcess
    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]])
+      PrcLib.debug("%s:%s Connecting to '%s' - Project '%s'" % [self.class, sCloudObj, config.get(:provider), hParams[:tenant]])
       begin
-         controler.connect(sCloudObj)
+         controller_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 ])
+         PrcLib.error('%s:%s: Unable to connect.\n%s' % [self.class, sCloudObj, e.message ])
          nil
       end
    end
@@ -71,66 +71,68 @@ end
 # Keypair management
 # ---------------------------------------------------------------------------
 class CloudProcess
+
+   # KeyPair Create Process Handler
+   # The process implemented is:
+   # * Check local SSH keypairs
+   # * Check remote keypair existence
+   # * Compare and warn if needed.
+   # * Import public key found if missing remotely and name it.
+   #
+   # Return:
+   # - keypair : Lorj::Data keypair object. Following additional data should be found in the keypair attributes
+   #   - :coherent        : Boolean. True, if the local keypair (public AND private) is coherent with remote keypair found in the cloud
+   #   - :private_key_file: String. Path to local private key file
+   #   - :public_key_file : String. Path to local public key file
+   #   - :public_key      : String. Public key content. (config[:public_key] is also set - Used to import it)
+   #
    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
+      hLocalKeypair = keypair_detect(sKeypair_name, File.expand_path(hParams[:keypair_path]))
 
-      Logging.state("Searching for keypair '%s'" % [sKeypair_name] )
+      private_key_file = File.join(hLocalKeypair[:keypair_path], hLocalKeypair[:private_key_name])
+      public_key_file = File.join(hLocalKeypair[:keypair_path], hLocalKeypair[:private_key_name])
+
+      PrcLib.info("Found openssh private key file '%s'." % private_key_file) if hLocalKeypair[:private_key_exist? ]
+      PrcLib.info("Found openssh public key file '%s'."  % public_key_file)  if hLocalKeypair[:public_key_exist? ]
+
+      PrcLib.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'")
+
+      if keypairs.length == 0
+         PrcLib.fatal(1, "Unable to import keypair '%s'. Public key file is not found. Please run 'forj setup %s'" % [sKeypair_name, config[:account_name]]) if not hLocalKeypair[:public_key_exist? ]
+         begin
+            config[:public_key] = File.read(hLocalKeypair[:public_key_file])
+         rescue => e
+            PrcLib.error("Unable to import keypair '%s'. '%s' is unreadable.\n%s",[hLocalKeypair[:public_key_file], e.message] )
          end
-      else
-         config[:public_key] = File.read(hParams[:public_key_file])
          keypair = create_keypair(sCloudObj, hParams)
-         if not hKeys[:private_key_exist? ]
+         if not hLocalKeypair[:private_key_exist? ]
             keypair[:coherent] = false
          else
             keypair[:coherent] = true
          end
+      else
+         keypair = keypairs[0]
+         keypair[:coherent] = coherent_keypair?(hLocalKeypair, keypair)
+         # Adding information about key files.
+      end
+      if keypair[:coherent]
+         keypair[:private_key_file] = hLocalKeypair[:private_key_file]
+         keypair[:public_key_file] = hLocalKeypair[:public_key_file]
       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)
+         oList = controller_query(sCloudObj, sQuery)
          query_single(sCloudObj, oList, sQuery, key_name)
       rescue => e
          if not oSSLError.ErrorDetected(e.message, e.backtrace, e)
@@ -140,25 +142,26 @@ class CloudProcess
 
    end
 
+   # Internal process function: Create keypair
    def create_keypair(sCloudObj, hParams)
       key_name = hParams[:keypair_name]
-      Logging.state("Importing keypair '%s'" % [key_name])
+      PrcLib.state("Importing keypair '%s'" % [key_name])
       oSSLError=SSLErrorMgt.new
       begin
-         keypair = controler.create(sCloudObj)
-         Logging.info("Keypair '%s' imported." % [keypair[:name]])
+         keypair = controller_create(sCloudObj)
+         PrcLib.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]
+         PrcLib.error "error importing keypair '%s'" % [key_name]
       end
       keypair
    end
 
+   # Build keypair data information structure with files found in local filesystem.
+   # Take care of priv with or without .pem and pubkey with pub.
    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))
@@ -167,12 +170,18 @@ class CloudProcess
       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'))
+      temp_file1 = File.join(key_path, key_basename)
+      private_key_ext = "" if File.exists?(temp_file1) and not File.directory?(temp_file1)
+      temp_file2 = File.join(key_path, key_basename + '.pem')
+      private_key_ext = '.pem' if File.exists?(temp_file2) and not File.directory?(temp_file2)
+
       if private_key_ext
          private_key_exist = true
          private_key_name = key_basename + private_key_ext
       else
+         [ temp_file1, temp_file2].each { | temp_file |
+            PrcLib.warning("keypair_detect: Private key file name detection has detected '%s' as a directory. Usually, it should be a private key file. Please check." % temp_file) if File.directory?(temp_file)
+         }
          private_key_exist = false
          private_key_name = key_basename
       end
@@ -181,13 +190,76 @@ class CloudProcess
       public_key_name = key_basename + '.pub'
 
 
+      # keypair basic structure
       {: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,
+       :public_key_name  => public_key_name,  :public_key_exist?  => public_key_exist
       }
    end
 
+  def forj_get_keypair(sCloudObj, sName, hParams)
+    oSSLError = SSLErrorMgt.new
+    begin
+      controller_get(sCloudObj, sName)
+    rescue => e
+      if not oSSLError.ErrorDetected(e.message,e.backtrace, e)
+        retry
+      end
+    end
+  end
+
+  def get_keypairs_path(hParams, hKeys)
+    sKeypair_name = hParams[:keypair_name]
+
+    if hKeys[:private_key_exist? ]
+      hParams[:private_key_file] = File.join(hKeys[:keypair_path], hKeys[:private_key_name])
+      PrcLib.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
+      PrcLib.fatal(1, "Public key file is not found. Please run 'forj setup %s'" % config[:account_name])
+    end
+
+    PrcLib.state("Searching for keypair '%s'" % [sKeypair_name] )
+
+    hParams
+  end
+
+   # Check if 2 keypair objects are coherent (Same public key)
+   # Parameters:
+   # - +hLocalKeypair+ : Keypair structure representing local files existence. see keypair_detect
+   # - +keypair+       : Keypair object to check.
+   #
+   # return:
+   # - coherent : Boolean. True if same public key.
+   def coherent_keypair?(hLocalKeypair, keypair)
+      #send keypairs by parameter
+
+      sKeypair_name = hLocalKeypair[:keypair_name]
+      bCoherent = false
+
+      # 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(File.join(hLocalKeypair[:keypair_path], hLocalKeypair[:public_key_name]))
+         rescue => e
+            PrcLib.error("Unable to read '%s'.\n%s" % [hLocalKeypair[:public_key_file], e.message] )
+         else
+            if local_pub_key.split(' ')[1].strip == keypair[:public_key].split(' ')[1].strip
+               PrcLib.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)
+               bCoherent = true
+            else
+               PrcLib.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" % [hLocalKeypair[:public_key_file], sKeypair_name, keypair[:public_key]])
+            end
+         end
+      else
+         PrcLib.warning("Unable to verify keypair coherence with your local SSH keys. No public key (:public_key) provided.")
+      end
+      bCoherent
+
+   end
 end
 
 # ---------------------------------------------------------------------------
@@ -199,12 +271,12 @@ class CloudProcess
    # 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] )
+      PrcLib.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])
+            PrcLib.error("Unable to create %s '%s'. Creation is not supported." % [sCloudObj, sFlavor_name])
             ForjLib::Data.new.set(nil, sCloudObj)
          else
             create_flavor(sCloudObj,hParams)
@@ -226,7 +298,7 @@ class CloudProcess
       sFlavor_name = hParams[:flavor_name]
       oSSLError = SSLErrorMgt.new
       begin
-         oList = controler.query(sCloudObj, sQuery)
+         oList = controller_query(sCloudObj, sQuery)
       rescue => e
          if not oSSLError.ErrorDetected(e.message,e.backtrace, e)
             retry
@@ -239,10 +311,10 @@ end
 # ---------------------------------------------------------------------------
 # Image management
 # ---------------------------------------------------------------------------
-class CloudProcess < BaseProcess
+class CloudProcess
    def forj_get_or_create_image(sCloudObj, hParams)
       sImage_name = hParams[:image_name]
-      Logging.state("Searching for image '%s'" % [sImage_name] )
+      PrcLib.state("Searching for image '%s'" % [sImage_name] )
 
       search_the_image(sCloudObj, {:name => sImage_name}, hParams)
       # No creation possible.
@@ -253,10 +325,15 @@ class CloudProcess < BaseProcess
       images = forj_query_image(sCloudObj, sQuery, hParams)
       case images.length()
         when 0
-          Logging.info("No image '%s' found" % [ image_name ] )
+          PrcLib.info("No image '%s' found" % [ image_name ] )
           nil
+        when 1
+          PrcLib.info("Found image '%s'." % [ image_name ])
+          images[0, :ssh_user] = ssh_user(images[0, :name])
+          images[0]
         else
-          Logging.info("Found image '%s'." % [ image_name ])
+          PrcLib.info("Found several images '%s'. Selecting the first one '%s'" % [ image_name, images[0, :name] ])
+          images[0, :ssh_user] = ssh_user(images[0, :name])
           images[0]
       end
    end
@@ -264,23 +341,33 @@ class CloudProcess < BaseProcess
    def forj_query_image(sCloudObj, sQuery, hParams)
       oSSLError = SSLErrorMgt.new
       begin
-         controler.query(sCloudObj, sQuery)
+         images = controller_query(sCloudObj, sQuery)
       rescue => e
          if not oSSLError.ErrorDetected(e.message,e.backtrace, e)
            retry
          end
       end
+      images.each { |image|
+         image[:ssh_user] = ssh_user(image[:name])
+      }
+      images
+   end
+
+   def ssh_user(image_name)
+      return "fedora" if image_name =~ /fedora/i
+      return "centos" if image_name =~ /centos/i
+      return "ubuntu"
    end
 end
 
 # ---------------------------------------------------------------------------
 # Server management
 # ---------------------------------------------------------------------------
-class CloudProcess < BaseProcess
+class CloudProcess
    # Process Handler functions
    def forj_get_or_create_server(sCloudObj, hParams)
       sServer_name = hParams[:server_name]
-      Logging.state("Searching for server '%s'" % [sServer_name] )
+      PrcLib.state("Searching for server '%s'" % [sServer_name] )
       servers = forj_query_server(sCloudObj, {:name => sServer_name}, hParams)
       if servers.length > 0
          # Get server details
@@ -290,13 +377,22 @@ class CloudProcess < BaseProcess
       end
    end
 
+   def forj_delete_server(sCloudObj, hParams)
+     oSSLError = SSLErrorMgt.new
+     begin
+       controller_delete(sCloudObj)
+       PrcLib.info("Server %s was destroyed " % hParams[:server][:name] )
+     rescue => e
+       if not oSSLError.ErrorDetected(e.message,e.backtrace, e)
+         retry
+       end
+     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)
+         controller_query(sCloudObj, sQuery)
       rescue => e
          if not oSSLError.ErrorDetected(e.message,e.backtrace, e)
            retry
@@ -307,7 +403,7 @@ class CloudProcess < BaseProcess
    def forj_get_server(sCloudObj, sId, hParams)
       oSSLError = SSLErrorMgt.new
       begin
-         controler.get(sCloudObj, sId)
+         controller_get(sCloudObj, sId)
       rescue => e
          if not oSSLError.ErrorDetected(e.message,e.backtrace, e)
            retry
@@ -319,13 +415,13 @@ class CloudProcess < BaseProcess
    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])
+         PrcLib.info("boot: meta-data provided.") if hParams[:meta_data]
+         PrcLib.info("boot: user-data provided.") if hParams[:user_data]
+         PrcLib.state('creating server %s' % [name])
+         server = controller_create(sCloudObj)
+         PrcLib.info("%s '%s' created." % [sCloudObj, name])
       rescue => e
-         Logging.fatal(1, "Unable to create server '%s'" % name, e)
+         PrcLib.fatal(1, "Unable to create server '%s'" % name, e)
       end
       server
    end
@@ -333,7 +429,7 @@ class CloudProcess < BaseProcess
    def forj_get_server_log(sCloudObj, sId, hParams)
       oSSLError = SSLErrorMgt.new
       begin
-         controler.get(sCloudObj, sId)
+         controller_get(sCloudObj, sId)
       rescue => e
          if not oSSLError.ErrorDetected(e.message,e.backtrace, e)
            retry
@@ -344,14 +440,14 @@ end
 # ---------------------------------------------------------------------------
 # Addresses management
 # ---------------------------------------------------------------------------
-class CloudProcess < BaseProcess
+class CloudProcess
    # 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]})
+      PrcLib.state("Searching public IP for server '%s'" % [sServer_name] )
+      addresses = controller_query(sCloudObj, {:server_id => hParams[:server, :id]})
       if addresses.length == 0
          assign_address(sCloudObj, hParams)
       else
@@ -371,7 +467,7 @@ class CloudProcess < BaseProcess
          :more       => "Found several %s. Searching for '%s'.",
          :items      => :public_ip
          }
-         oList = controler.query(sCloudObj, sQuery)
+         oList = controller_query(sCloudObj, sQuery)
          query_single(sCloudObj, oList, sQuery, server_name, sInfo)
       rescue => e
          if not oSSLError.ErrorDetected(e.message,e.backtrace, e)
@@ -383,7 +479,7 @@ class CloudProcess < BaseProcess
    def forj_get_public_address(sCloudObj, sId, hParams)
       oSSLError = SSLErrorMgt.new
       begin
-         controler.get(sCloudObj, sId)
+         controller_get(sCloudObj, sId)
       rescue => e
          if not oSSLError.ErrorDetected(e.message,e.backtrace, e)
            retry
@@ -395,11 +491,11 @@ class CloudProcess < BaseProcess
    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])
+         PrcLib.state('Getting public IP for server %s' % [name])
+         ip_address = controller_create(sCloudObj)
+         PrcLib.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)
+         PrcLib.fatal(1, "Unable to assign a public IP to server '%s'" % name, e)
       end
       ip_address
    end