lorj 0.2.0 → 1.0.0

data/lib/core_process/cloud/process/keypairs.rb

@@ -0,0 +1,276 @@
+# 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.
+
+# 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)
+    keypair_name = hParams[:keypair_name]
+    # setup has configured and copied the appropriate key to forj keypairs.
+
+    loc_kpair = keypair_detect(keypair_name,
+                               File.expand_path(hParams[:keypair_path]))
+
+    private_key_file = File.join(loc_kpair[:keypair_path],
+                                 loc_kpair[:private_key_name])
+    public_key_file = File.join(loc_kpair[:keypair_path],
+                                loc_kpair[:public_key_name])
+
+    PrcLib.info("Found openssh private key file '%s'.",
+                private_key_file) if loc_kpair[:private_key_exist?]
+    PrcLib.info("Found openssh public key file '%s'.",
+                public_key_file) if loc_kpair[:public_key_exist?]
+
+    PrcLib.state("Searching for keypair '%s'", keypair_name)
+
+    keypairs = forj_query_keypair(sCloudObj,
+                                  { :name => keypair_name }, hParams)
+
+    if keypairs.length == 0
+      keypair = keypair_import(keypair_name, loc_kpair)
+    else
+      keypair = keypairs[0]
+      keypair[:coherent] = coherent_keypair?(loc_kpair, keypair)
+      # Adding information about key files.
+    end
+    if keypair[:coherent]
+      keypair[:private_key_file] = loc_kpair[:private_key_file]
+      keypair[:public_key_file] = loc_kpair[:public_key_file]
+    end
+    keypair
+  end
+
+  def forj_query_keypair(sCloudObj, sQuery, hParams)
+    key_name = hParams[:keypair_name]
+    ssl_error_obj = SSLErrorMgt.new
+    begin
+      list = controller_query(sCloudObj, sQuery)
+      query_single(sCloudObj, list, sQuery, key_name)
+    rescue => e
+      retry unless ssl_error_obj.error_detected(e.message, e.backtrace, e)
+    end
+  end
+end
+
+# Keypair management: Internal process functions
+class CloudProcess
+  def keypair_import(keypair_name, loc_kpair)
+    PrcLib.fatal(1, "Unable to import keypair '%s'. "\
+                    'Public key file is not found. '\
+                    "Please run 'forj setup %s'",
+                 keypair_name,
+                 config[:account_name]) unless loc_kpair[:public_key_exist?]
+    begin
+      config[:public_key] = File.read(loc_kpair[:public_key_file])
+    rescue => e
+      PrcLib.fatal(1, "Unable to import keypair '%s'. '%s' is "\
+                      "unreadable.\n%s", keypair_name,
+                   loc_kpair[:public_key_file], e.message)
+    end
+    keypair = create_keypair(sCloudObj, hParams)
+    if !loc_kpair[:private_key_exist?]
+      keypair[:coherent] = false
+    else
+      keypair[:coherent] = true
+    end
+    keypair
+  end
+
+  def create_keypair(sCloudObj, hParams)
+    key_name = hParams[:keypair_name]
+    PrcLib.state("Importing keypair '%s'", key_name)
+    ssl_error_obj = SSLErrorMgt.new
+    begin
+      keypair = controller_create(sCloudObj)
+      PrcLib.info("Keypair '%s' imported.", keypair[:name])
+    rescue StandardError => e
+      retry unless ssl_error_obj.error_detected(e.message, e.backtrace, e)
+      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)
+    key_basename = File.basename(key_fullpath)
+    key_path = File.expand_path(File.dirname(key_fullpath))
+
+    obj_match = key_basename.match(/^(.*?)(\.pem|\.pub)?$/)
+    key_basename = obj_match[1]
+
+    private_key_ext, files = _check_key_file(key_path, key_basename,
+                                             ['', '.pem'])
+
+    if private_key_ext
+      priv_key_exist = true
+      priv_key_name = key_basename + private_key_ext
+    else
+      files.each do | 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)
+      end
+      priv_key_exist = false
+      priv_key_name = key_basename
+    end
+
+    pub_key_exist = File.exist?(File.join(key_path, key_basename + '.pub'))
+    pub_key_name = key_basename + '.pub'
+
+    # keypair basic structure
+    { :keypair_name     => keypair_name,
+      :keypair_path     => key_path,      :key_basename       => key_basename,
+      :private_key_name => priv_key_name, :private_key_exist? => priv_key_exist,
+      :public_key_name  => pub_key_name,  :public_key_exist?  => pub_key_exist
+    }
+  end
+
+  def _check_key_file(key_path, key_basename, extensions)
+    found_ext = nil
+    files = []
+    extensions.each do | ext |
+      temp_file = File.join(key_path, key_basename + ext)
+      if File.exist?(temp_file) && !File.directory?(temp_file)
+        found_ext = ext
+        files << temp_file
+      end
+    end
+    [found_ext, files]
+  end
+
+  def forj_get_keypair(sCloudObj, sName, _hParams)
+    ssl_error_obj = SSLErrorMgt.new
+    begin
+      controller_get(sCloudObj, sName)
+    rescue => e
+      retry unless ssl_error_obj.error_detected(e.message, e.backtrace, e)
+    end
+  end
+
+  def get_keypairs_path(hParams, hKeys)
+    keypair_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'", keypair_name)
+
+    hParams
+  end
+
+  # Check if 2 keypair objects are coherent (Same public key)
+  # Parameters:
+  # - +loc_kpair+ : 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?(loc_kpair, keypair)
+    # send keypairs by parameter
+
+    keypair_name = loc_kpair[:keypair_name]
+    is_coherent = false
+
+    pub_keypair = keypair[:public_key]
+
+    # Check the public key with the one found here, locally.
+    if !pub_keypair.nil? && pub_keypair != ''
+      begin
+        loc_pubkey = File.read(File.join(loc_kpair[:keypair_path],
+                                         loc_kpair[:public_key_name]))
+     rescue => e
+       PrcLib.error("Unable to read '%s'.\n%s",
+                    loc_kpair[:public_key_file], e.message)
+      else
+        if loc_pubkey.split(' ')[1].strip == pub_keypair.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.', keypair_name)
+          is_coherent = 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",
+                         loc_kpair[:public_key_file], keypair_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
+    is_coherent
+  end
+end
+
+# Define framework object on BaseDefinition
+module Lorj
+  # ************************************ keypairs Object
+  # Identify keypairs
+  class BaseDefinition
+    define_obj(:keypairs,
+
+               :create_e => :forj_get_or_create_keypair,
+               :query_e => :forj_query_keypair,
+               :get_e => :forj_get_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
+  end
+end

data/lib/core_process/cloud/process/network.rb

@@ -0,0 +1,108 @@
+# 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.
+
+# Network Management
+class CloudProcess
+  # Process Create handler
+  def forj_get_or_create_network(sCloudObj, hParams)
+    PrcLib.state("Searching for network '%s'", hParams[:network_name])
+    networks = find_network(sCloudObj, hParams)
+    if networks.length == 0
+      network = create_network(sCloudObj, hParams)
+    else
+      network = networks[0]
+    end
+    register(network)
+
+    # Attaching if missing the subnet.
+    # Creates an object subnet, attached to the network.
+    unless hParams[:subnetwork_name]
+      hParams[:subnetwork_name] = 'sub-' + hParams[:network_name]
+      config[:subnetwork_name] = hParams[:subnetwork_name]
+    end
+
+    # object.Create(:subnetwork)
+    Create(:subnetwork)
+
+    network
+  end
+
+  # Process Delete handler
+  def forj_delete_network(sCloudObj, hParams)
+    oProvider.delete(sCloudObj, hParams)
+ rescue => e
+   PrcLib.error("%s\n%s", e.message, e.backtrace.join("\n"))
+  end
+
+  def forj_get_network(sCloudObj, sID, hParams)
+    oProvider.get(sCloudObj, sID, hParams)
+  rescue => e
+    PrcLib.error("%s\n%s", e.message, e.backtrace.join("\n"))
+  end
+end
+
+# Define framework object on BaseDefinition
+module Lorj
+  # ************************************ Network Object
+  # Identify the network
+  class BaseDefinition
+    define_obj(:network,
+               :create_e => :forj_get_or_create_network,
+               :query_e => :controller_query,
+               :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.
+  end
+end
+
+# Network Process internal functions #
+class CloudProcess
+  # Network creation
+  # It returns:
+  # nil or Provider Object
+  def create_network(sCloudObj, hParams)
+    name = hParams[:network_name]
+    begin
+      PrcLib.state("Creating network '%s'", name)
+      network = controller_create(sCloudObj)
+      PrcLib.info("Network '%s' created", network[:name])
+   rescue => e
+     PrcLib.fatal(1, "Unable to create network '%s'", name, e)
+    end
+    network
+  end
+
+  # Search for a network from his name.
+  # Name may be unique in project context, but not in the cloud system
+  # It returns:
+  # nil or Provider Object
+  def find_network(sCloudObj, hParams)
+    query = { :name => hParams[:network_name] }
+    list = controller_query(sCloudObj, query)
+    query_single(sCloudObj, list, query, hParams[:network_name])
+ rescue => e
+   PrcLib.error("%s\n%s", e.message, e.backtrace.join("\n"))
+  end
+end

data/lib/core_process/cloud/process/public_ip.rb

@@ -0,0 +1,100 @@
+# 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.
+
+# Addresses management
+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.
+    server_name = hParams[:server, :name]
+
+    PrcLib.state("Searching public IP for server '%s'", server_name)
+    addresses = controller_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]
+    ssl_error_obj = SSLErrorMgt.new
+    begin
+      info = {
+        :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
+      }
+      list = controller_query(sCloudObj, sQuery)
+      query_single(sCloudObj, list, sQuery, server_name, info)
+    rescue => e
+      retry unless ssl_error_obj.error_detected(e.message, e.backtrace, e)
+    end
+  end
+
+  def forj_get_public_address(sCloudObj, sId, _hParams)
+    ssl_error_obj = SSLErrorMgt.new
+    begin
+      controller_get(sCloudObj, sId)
+    rescue => e
+      retry unless ssl_error_obj.error_detected(e.message, e.backtrace, e)
+    end
+  end
+end
+
+# Define framework object on BaseDefinition
+module Lorj
+  # ************************************ SERVER Addresses Object
+  # Object representing the list of IP addresses attached to a server.
+  class BaseDefinition
+    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
+  end
+end
+
+# Internal Process function
+class CloudProcess
+  def assign_address(sCloudObj, hParams)
+    name = hParams[:server, :name]
+    begin
+      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
+     PrcLib.fatal(1, "Unable to assign a public IP to server '%s'", name, e)
+    end
+    ip_address
+  end
+end