lorj 0.2.0 → 1.0.0

data/lib/core_process/cloud/process/subnetwork.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.
+
+# Subnetwork Management
+class CloudProcess
+  def forj_get_or_create_subnetwork(sCloudObj, hParams)
+    subnet = query_subnet_one(sCloudObj, hParams)
+    return nil if subnet.nil?
+
+    # Create the subnet
+    subnet = create_subnet(sCloudObj, hParams)
+
+    return nil if subnet.nil?
+    register(subnet)
+    subnet
+  end
+end
+
+# ************************************ SubNetwork Object model
+# Define framework object on BaseDefinition
+module Lorj
+  # Identify subnetwork as part of network.
+  class BaseDefinition
+    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
+  end
+end
+
+# Subnetwork Management - internal functions
+class CloudProcess
+  def create_subnet(sCloudObj, hParams)
+    name = hParams[:subnetwork_name]
+    PrcLib.state("Creating subnet '%s'", name)
+    begin
+      subnet = controller_create(sCloudObj)
+      PrcLib.info("Subnet '%s' created.", subnet[:name])
+   rescue => e
+     PrcLib.fatal(1, "Unable to create '%s' subnet.", name, e)
+    end
+    subnet
+  end
+
+  def delete_subnet
+    net_conn_obj = get_cloudObj(:network_connection)
+    sub_net_obj = get_cloudObj(:subnetwork)
+
+    PrcLib.state("Deleting subnet '%s'", sub_net_obj.name)
+    begin
+      provider_delete_subnetwork(net_conn_obj, sub_net_obj)
+      net_conn_obj.subnets.get(sub_net_obj.id).destroy
+   rescue => e
+     PrcLib.error("%s\n%s", e.message, e.backtrace.join("\n"))
+    end
+  end
+
+  def query_subnet_one(_sCloudObj, hParams)
+    PrcLib.state('Searching for sub-network attached to '\
+                 "network '%s'", hParams[:network, :name])
+    #######################
+    begin
+      query = { :network_id => hParams[:network, :id] }
+      subnets = controller_query(:subnetwork, query)
+   rescue => e
+     PrcLib.error("%s\n%s", e.message, e.backtrace.join("\n"))
+    end
+    return nil if subnets.nil?
+
+    case subnets.length
+    when 0
+      PrcLib.info('No subnet found from '\
+                  "'%s' network", hParams[:network, :name])
+      ForjLib::Data.new
+    when 1
+      PrcLib.info("Found '%s' subnet from "\
+                  "'%s' network", subnets[0, :name],
+                  hParams[:network, :name])
+      subnets[0]
+    else
+      PrcLib.warning('Several subnet was found on '\
+                     "'%s'. Choosing the first one "\
+                     "= '%s'", hParams[:network, :name],
+                     subnets[0, :name])
+      subnets[0]
+    end
+  end
+end

data/lib/core_process/cloud_process.rb

@@ -0,0 +1,30 @@
+# 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.
+
+cloud_path = File.dirname(__FILE__)
+
+# Define model
+
+lorj_objects = %w(common connection network subnetwork router
+                  external_network security_groups rules
+                  keypairs images flavor internet_network server public_ip
+                  server_log internet_server)
+
+lorj_objects.each do | name |
+  require File.join(cloud_path, 'cloud', 'process', name + '.rb')
+end

data/lib/logging.rb

@@ -0,0 +1,298 @@
+#!/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.
+
+# create a forj.log file in ~/.hpcloud/forj.log
+
+require 'rubygems'
+require 'logger'
+require 'ansi'
+require 'ansi/logger'
+
+#
+# PrcLib module
+#
+# PrcLib Implements a Logging class based on logger.
+#
+# For details about this class capabilities, see PrcLib::Logging
+#
+#    # To use the Prc::Logging system, do the following:
+#    require 'PrcLib'
+#
+#    # To configure logging system:
+#    PrcLib.app_name = 'config/app' # Define application data path as
+#                                   # ~/.<app_name>.
+#                                   #  Ex: 'config/app' will use ~/.config/app
+#    PrcLib.log_file = 'app.log'    # Relative path to the log file name
+#                                   # stored in the Application data path.
+#                                   # Here, ~/.config/app/app.log
+#    PrcLib.level = Logger::FATAL   # Define printout debug level. Can be any
+#                                   # Logger predefined value.
+#
+#    # To log some information:
+#    PrcLib.debug('My debug message')
+#    PrcLib.info('My info message')
+#    PrcLib.warning('my warning')
+#    PrcLib.error('my error')
+#    PrcLib.fatal(2, "Fatal error, with return code = 2)
+#    PrcLib.message('Only printout message')
+#
+#    # You can printout some instant message to the terminal, not logged.
+#    # This is useful before any action that will take time to be executed.
+#    # It is inform the end user that something is still running, which means
+#    # the application is not frozen
+#    PrcLib.state("Running a long task")
+#    # The next message will replace the previous state message.
+#    sleep(10)
+#    PrcLib.info("The long task has been executed successfully.")
+#
+#    # You can change the logger level with PrcLib.level
+#    PrcLib.level = Logger::DEBUG
+#
+#    # You can just print high level message (print without \n) if PrcLib.level
+# is not DEBUG or INFO.
+#    PrcLib.high_level_msg("Print a message, not logged, if level is not DEBUG
+# or INFO")
+#
+# Enjoy!
+module PrcLib
+  # Class used to create 2 logger object, in order to keep track of error in a
+  # log file and change log output to OUTPUT on needs (option flags).
+  # The idea is that everytime, if you did not set the debug level mode, you can
+  # refer to the log file which is
+  # already configured with Logger::DEBUG level.
+  #
+  # As well, sometimes, you do not want to keep track on messages that are just
+  # to keep informed the end user about activity.
+  # So, this object implement 2 Logger objects.
+  # * One for log file
+  # * One for print out.
+  #
+  # Everytime you log a message with Logging, it is printed out if the level
+  # permits and stored everytime in the log file, never mind about Logger level
+  # set.
+  # In several cases, messages are printed out, but not stored in the log file.
+  #
+  # See Logging functions for details.
+  #
+  class Logging
+    attr_reader :level
+
+    # Initialize Logging instance
+    # The log file name is defined by PrcLib.log_file
+    # The log path is defined by PrcLib.app_name and will be kept as
+    # ~/.<PrcLib.app_name>
+    # The log level is defined by PrcLib.level. It will update only log print
+    # out.
+    # Depending on levels, messages are prefixed by colored 'ERROR!!!',
+    # 'FATAL!!!', 'WARNING' or <LEVEL NAME>
+    def initialize
+      file_logger_initialize
+
+      @out_logger = Logger.new(STDOUT)
+      @level = (PrcLib.level.nil? ? Logger::WARN : PrcLib.level)
+      @out_logger.level = @level
+      @out_logger.formatter = proc do |severity, _datetime, _progname, msg|
+        case severity
+        when 'ANY'
+          str = "#{msg} \n"
+        when 'ERROR', 'FATAL'
+          str = ANSI.bold(ANSI.red("#{severity}!!!")) + ": #{msg} \n"
+        when 'WARN'
+          str = ANSI.bold(ANSI.yellow('WARNING')) + ": #{msg} \n"
+        else
+          str = "#{severity}: #{msg} \n"
+        end
+        str
+      end
+    end
+
+    # Is Logging print out level is info?
+    def info?
+      (@out_logger.info?)
+    end
+
+    # Is Logging print out level is debug?
+    def debug?
+      (@out_logger.debug?)
+    end
+
+    # Is Logging print out level is error?
+    def error?
+      (@out_logger.error?)
+    end
+
+    # Is Logging print out level is fatal?
+    def fatal?
+      (@out_logger.fatal?)
+    end
+
+    # Log to STDOUT and Log file and INFO class message
+    def info(message)
+      @out_logger.info(message + ANSI.clear_line)
+      @file_logger.info(message)
+    end
+
+    # Log to STDOUT and Log file and DEBUG class message
+    def debug(message)
+      @out_logger.debug(message + ANSI.clear_line)
+      @file_logger.debug(message)
+    end
+
+    # Log to STDOUT and Log file and ERROR class message
+    def error(message)
+      @out_logger.error(message + ANSI.clear_line)
+      @file_logger.error(message)
+    end
+
+    # Log to STDOUT and Log file and FATAL class message
+    # fatal retrieve the caller list of functions and save it to the log file if
+    # the exception class is given.
+    # The exception class should provide message and backtrace.
+    def fatal(message, e = nil)
+      @out_logger.fatal(message + ANSI.clear_line)
+      @file_logger.fatal(format("%s\n%s\n%s",
+                                message,
+                                e.message,
+                                e.backtrace.join("\n"))) if e
+      @file_logger.fatal(message)
+    end
+
+    # Log to STDOUT and Log file and WARNING class message
+    def warn(message)
+      @out_logger.warn(message + ANSI.clear_line)
+      @file_logger.warn(message)
+    end
+
+    # set STDOUT logger level
+    def level=(level)
+      @level = level
+      @out_logger.level = level
+    end
+
+    # Print out a message, not logged in the log file. This message is printed
+    # out systematically as not taking care of logger level.
+    def unknown(message)
+      @out_logger.unknown(message + ANSI.clear_line)
+    end
+
+    private
+
+    def file_logger_initialize
+      log_file = PrcLib.log_file
+      if log_file.nil?
+        default_log_file = format('%s.log', PrcLib.app_name)
+        log_file = File.join(PrcLib.data_path, default_log_file)
+      end
+
+      @file_logger = Logger.new(log_file, 'weekly')
+      @file_logger.level = Logger::DEBUG
+      @file_logger.formatter = proc do |severity, datetime, progname, msg|
+        "#{progname} : #{datetime}: #{severity}: #{msg} \n"
+      end
+      PrcLib.log_file = log_file
+    end
+  end
+
+  module_function
+
+  # Create a Logging object if missing and return it.
+  # Used internally by other functions
+  def log_object
+    if PrcLib.log.nil?
+      PrcLib.log = PrcLib::Logging.new
+    else
+      PrcLib.log
+    end
+  end
+
+  # Print out a message, not logged in the log file. This message is printed out
+  # systematically as not taking care of logger level.
+  def message(message, *p)
+    log_object.unknown(format(message, *p))
+  end
+
+  # Log to STDOUT and Log file and INFO class message
+  def info(message, *p)
+    log_object.info(format(message, *p))
+    nil
+  end
+
+  # Log to STDOUT and Log file and DEBUG class message
+  def debug(message, *p)
+    log_object.debug(format(message, *p))
+    nil
+  end
+
+  # Log to STDOUT and Log file and WARNING class message
+  def warning(message, *p)
+    log_object.warn(format(message, *p))
+    nil
+  end
+
+  # Log to STDOUT and Log file and ERROR class message
+  def error(message, *p)
+    log_object.error(format(message, *p))
+    nil
+  end
+
+  # Internal heap management to help controller developper to identify issue.
+  def dcl_fail(msg, *p)
+    msg = "Declaration error:\n%s"
+    msg += format("\nSee at %s",
+                  PrcLib.model.heap[0]) if PrcLib.model.heap.is_a?(Array)
+    runtime_fail(msg, *p)
+  end
+
+  # fail extended with format.
+  def runtime_fail(msg, *p)
+    fail Lorj::PrcError.new, format(msg, *p)
+  end
+
+  # Log to STDOUT and Log file and FATAL class message then exit the application
+  # with a return code.
+  # fatal retrieve the caller list of functions and save it to the log file if
+  # the exception class is given.
+  # The exception class should provide message and backtrace.
+  def fatal(rc, message, *p)
+    e = nil
+    if p.length > 0 && p[-1].is_a?(Exception)
+      e = p[-1]
+      p.pop
+    end
+    log_object.fatal(format(message, *p), e)
+    puts 'Issues found. Please fix it and retry. Process aborted.'
+    exit rc
+  end
+
+  def level=(level)
+    log_object.level = level
+    nil
+  end
+
+  def state(message, *p)
+    print(format("%s ...%s\r",
+                 format(message, *p),
+                 ANSI.clear_line)) if log_object.level <= Logger::INFO
+    nil
+  end
+
+  # Not DEBUG and not INFO. Just printed to the output.
+  def high_level_msg(message)
+    print(format('%s', message)) if log_object.level > 1
+    nil
+  end
+end

data/lib/lorj/version.rb

@@ -1,3 +1,20 @@
+# 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.
+
+# Lorj version
 module Lorj
-  VERSION = "0.2.0"
+  VERSION = '1.0.0'
 end

data/lib/lorj.rb

@@ -17,32 +17,72 @@
 #    limitations under the License.
 #++
 
-
-
-require "lorj/version"
+require 'lorj/version'
 
 # This is the lorj base library.
 
 # To use it, add require 'lorj'
 
-require 'prc.rb'           # Load PrcLib Base module
-require 'prc-logging.rb'   # Load class PrcLib::Logging
-require 'prc-config.rb'    # Load class Lorj::Config
-require 'prc-account.rb'   # Load class Lorj::Account
+require 'prc.rb'                   # PrcLib Base module
+require 'rh.rb'                    # recursive Hash
+require 'logging.rb'               # class PrcLib::Logging
+require 'prc_base_config.rb'       # PRC::BaseConfig class
+require 'prc_section_config.rb'    # PRC::SectionConfig class
+require 'prc_core_config.rb'       # PRC::CoreConfig class
+require 'lorj_defaults.rb'         # PRC::Defaults class - Application defaults
+require 'lorj_config.rb'           # Lorj::Config class -
+require 'lorj_account.rb'          # Lorj::Account class  - account config
 
-require "core/core"                 # Lorj Core classes
-require "core/lorj-data"            # Lorj Lorj::Data object
-require "core/lorj-basedefinition"  # Lorj Lorj::BaseDefinition object
-require "core/lorj-baseprocess"     # Lorj Lorj::BaseProcess object
-require "core/lorj-basecontroller"  # Lorj Lorj::BaseController object
-require "core/lorj-keypath"         # Lorj Lorj::BaseDefinition object
-require "core/definition"           # Lorj Process definition
-require "core/definition_internal"  # Lorj internal functions
+require 'core/core_internal'       # Lorj Core class private init. functions
+require 'core/core'                # Lorj Core class
+require 'core/core_model'          # Lorj Model class
+require 'core/core_process'        # Lorj core process functions
+require 'core/core_controller'     # Lorj core controller functions
+require 'core/core_object_data'    # Lorj ObjectData class
+require 'core/lorj_data'           # Lorj Lorj::Data object
+require 'core/lorj_basedefinition' # Lorj Lorj::BaseDefinition object
+require 'core/lorj_baseprocess'    # Lorj Lorj::BaseProcess object
+require 'core/lorj_basecontroller' # Lorj Lorj::BaseController object
+require 'core/lorj_keypath'        # Lorj Lorj::BaseDefinition object
+require 'core/definition'          # Lorj Process definition
+require 'core/definition_internal' # Lorj internal functions
 
+# lorj module
 module Lorj
-   slib_forj = File.dirname(__FILE__)
+  # Internal Lorj function to debug lorj.
+  #
+  # * *Args* :
+  #   - +iLevel+ : value between 1 to 5. Setting 5 is the most verbose!
+  #   - +sMsg+   : Array of string or symbols. keys tree to follow and check
+  #                existence in yVal.
+  #
+  # * *Returns* :
+  #   - nothing
+  #
+  # * *Raises* :
+  #   No exceptions
+  def self::debug(iLevel, sMsg, *p)
+    if iLevel <= PrcLib.core_level
+      message = format('-%s- %s', iLevel, sMsg)
+
+      PrcLib.debug(format(message, *p))
+    end
+  end
+
+  # Internal PrcError class object derived from RuntimeError.
+  # Internally used with raise.
+  # Used to identify the error origin, while an error is thrown.
+  class PrcError < RuntimeError
+    attr_reader :lorg_message
+
+    def initialize(message = nil)
+      @lorj_message = message
+    end
+  end
+
+  slib_forj = File.dirname(__FILE__)
 
-   PrcLib.lib_path = File.expand_path(File.join(File.dirname(slib_forj),'lib'))
+  PrcLib.lib_path = File.expand_path(File.join(File.dirname(slib_forj), 'lib'))
 
-   PrcLib.core_level = 0
+  PrcLib.core_level = 0
 end