lorj 0.1.0

data/bin/cloud_test.rb

@@ -0,0 +1,81 @@
+#!/usr/bin/env ruby
+
+#require 'byebug'
+
+$APP_PATH = File.dirname(__FILE__)
+$LIB_PATH = File.expand_path(File.join(File.dirname($APP_PATH),'lib'))
+
+$LOAD_PATH << $LIB_PATH
+
+$LOAD_PATH << File.join($LIB_PATH, 'lib-forj', 'lib')
+
+require 'appinit.rb'
+
+# Initialize forj paths
+AppInit::forj_initialize()
+
+# Initialize global Log object
+$FORJ_LOGGER=LorjLog.new()
+
+require 'lib-forj.rb'
+
+Logging.set_level(Logger::DEBUG)
+
+# Load global Config
+oConfig = ForjConfig.new()
+
+aProcesses = []
+
+# Defines how to manage Maestro and forges
+# create a maestro box. Identify a forge instance, delete it,...
+aProcesses << File.join($LIB_PATH, 'forj', 'ForjCore.rb')
+
+# Defines how cli will control FORJ features
+# boot/down/ssh/...
+aProcesses << File.join($LIB_PATH, 'forj', 'ForjCli.rb')
+
+$LIB_FORJ_DEBUG = 3 # verbose
+
+infra_dir = File.expand_path(oConfig.get(:infra_repo))
+
+# Ask information if needed.
+if not Dir.exist?(File.expand_path(infra_dir))
+   Logging.warning(<<-END
+Your infra workspace directory is missing.
+
+Forj uses an infra workspace directory to store any kind of data that are private to you.
+We provides ways to send those data securily to your new Forge instance, as metadata.
+In production case, we suggest you to keep it safe in your SCM preferred database.
+
+If you already have an existing infra workspace, use 'forj set infra_repo=<PathToYourRepo>' to set it and restart.
+
+Otherwise, we will build a new one with some predefined data, you can review and update later.
+   END
+   )
+   sAsk = "Do you want to create a new one from Maestro (yes/no)?" % [infra_dir]
+   bBuildInfra=agree(sAsk)
+   if not bBuildInfra
+      puts 'Process aborted on your demand.'
+      exit 0
+   end
+end
+
+oCloud = ForjCloud.new(oConfig, 'hpcloud', aProcesses)
+
+#oConfig.set(:instance_name, "test")
+#oCloud.Create(:metadata)
+#oCloud.Create(:infra_repository)
+#oCloud.Create(:userdata)
+
+
+#oCloud.Setup(:server, 'hpcloud')
+#oCloud.Setup(:forge, 'hpcloud')
+
+#oCloud.Create(:forge)
+
+oConfig.set(:box_name, '183')
+oConfig.set(:box, 'maestro')
+#oConfig.Create(:server)
+oCloud.Create(:ssh)
+
+#oCloud.Query(:server, 'maestro')

data/example/students_1/process/Students.rb

@@ -0,0 +1,20 @@
+# Students process
+class StudentsProcess
+  def create_student(sObjectType, hParams)
+      puts "Running creation process for object '%s' = '%s'" % [sObjectType, hParams[:student_name] ]
+      # If you prefer to print out to the log system instead:
+      # PrcLib::debug("Running creation process for object '%s' = '%s'" % [sObjectType, hParams[:student_name] ])
+  end
+end
+
+# Declaring your data model and handlers.
+class Lorj::BaseDefinition
+
+   # We need to define the student object and the handler to use while we need to create it.
+   define_obj(:student,
+   {
+      :create_e => :create_student # The function to call in the class Students
+   })
+
+   obj_needs    :data,         :student_name,        { :for => [:create_e] }
+end

data/example/students_1/students.rb

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+
+$APP_PATH = File.dirname(__FILE__)
+require 'lorj'
+
+# If you want to see what is happening in the framework, uncomment debug settings.
+# PrcLib.level = Logger::DEBUG # Printed out to your console.
+# PrcLib.core_level = 3 # framework debug levels.
+
+# Initialize the framework
+hProcesses = [ File.join($APP_PATH, 'process', 'Students.rb')]
+
+oStudentCore = Lorj::Core.new( nil, hProcesses)
+
+# Ask the framework to create the object student 'Robert Redford'
+oStudentCore.Create(:student, :student_name => "Robert Redford")

data/example/students_2/process/Students.rb

@@ -0,0 +1,27 @@
+# Students process
+class StudentsProcess
+  def create_student(sObjectType, hParams)
+      PrcLib::state ("Running creation process for object '%s' = '%s'" % [sObjectType, hParams[:student_name] ])
+
+      oObject = controller_create(sObjectType)
+      raise "Student '%s' not created." % hParams[:student_name] if oObject.nil?
+      PrcLib::info ("'%s': '%s' created with id %s" % [sObjectType, hParams[:student_name],  oObject[:id]])
+      oObject
+  end
+
+end
+
+# Declaring your data model and handlers.
+class Lorj::BaseDefinition
+
+   # We need to define the student object and the handler to use while we need to create it.
+   define_obj(:student,
+   {
+      :create_e => :create_student,   # The function to call in the class Students
+      :query_e  => :controller_query, # We use predefined call to the controller query
+      :get_e    => :controller_get,   # We use predefined call to the controller get
+      :delete_e => :controller_delete # We use predefined call to the controller delete
+   })
+
+   obj_needs    :data,         :student_name,        { :for => [:create_e], :mapping => :name }
+end

data/example/students_2/students.rb

@@ -0,0 +1,36 @@
+#!/usr/bin/env ruby
+
+$APP_PATH = File.dirname(__FILE__)
+require 'lorj'
+
+# If you want to see what is happening in the framework, uncomment debug settings.
+# PrcLib.level = Logger::DEBUG # Printed out to your console.
+# PrcLib.core_level = 3 # framework debug levels.
+
+# Initialize the framework
+hProcesses = [ File.join($APP_PATH, 'process', 'Students.rb')]
+
+oStudentCore = Lorj::Core.new( nil, hProcesses, :mock)
+
+# Ask the framework to create the object student 'Robert Redford'
+oStudentCore.Create(:student, :student_name => "Robert Redford")
+
+# Want to create a duplicated student 'Robert Redford'?
+oStudentCore.Create(:student)
+# no problem. The key is the key in the Mock controller array.
+
+oStudentCore.Create(:student, :student_name => "Anthony Hopkins")
+
+# Let's create a third different student.
+oStudents = oStudentCore.Query(:student, { :name => "Robert Redford" } )
+
+puts "%s students found" % oStudents.length
+
+oStudents.each { | oStudent |
+   puts "%s: %s" % [oStudent[:id], oStudent[:name]]
+}
+
+# let's check the get function, who is the ID 2?
+oStudent = oStudentCore.Get(:student, 2)
+
+puts "The student ID 2 is %s" % oStudent[:name]

data/example/students_3/controller/yaml_students.rb

@@ -0,0 +1,94 @@
+# 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.
+
+
+# This class describes how to process some actions, and will do everything prior
+# this task to make it to work.
+
+
+# declare yaml student API to the controller
+cur_path = File.dirname(__FILE__)
+api_file = File.expand_path(File.join(cur_path, "..", "..", "yaml_students", 'yaml_students.rb'))
+require api_file
+
+# The controller is a combination of 2 elements:
+# - Controller class
+#   Code which will interfere with the external API.
+#
+#   The file name must respect the name of the class. 1st letter already capitalized and letter after _ is capitalized.
+#   file: my_code.rb => needs to create MyCodeController class
+#
+# - Definition class
+#   This class declare any kind of mapping or additional fields to consider.
+#   Additionnal fields are unknow by the process. So, those fields will needs to be setup before.
+#
+#   file name convention is identical than controller class.
+#   file: my_code.rb => needs to create MyCode class
+
+controller_file = File.expand_path(File.join(cur_path,'yaml_students_controller.rb'))
+require controller_file # Load controller mapping
+
+# Declare
+# - additional objects and their specific process (:connection using basic predefined :controller_create process)
+# - data_mapping :
+#   :connection_string => :file_name
+#   :course            => :training
+#
+# If some data has been added by the controller, the main and process, won't take care and the framework will fails.
+# To eliminate this errors, there is 2 cases:
+# - detect this change in the process or the main.
+# - set it up, using lorj setup function, if the data is declared askable by the controller.
+#   The controller can define how the setup have to ask values, and even can get data
+#   from itself.
+
+class YamlStudents
+
+   # This is a new object which is known by the controller only.
+   # Used to open the yaml file. Generically, I named it :connection.
+   # But this can be any name you want. Only the controller will deal with it.
+   define_obj(:connection,{
+    :create_e => :controller_create # Nothing complex to do. So, simply call the controller create.
+   })
+
+   obj_needs   :data,   :connection_string,  :mapping => :file_name
+   undefine_attribute :id    # Do not return any predefined ID
+   undefine_attribute :name  # Do not return any predefined NAME
+
+   # The student model have to be expanded.
+   define_obj(:student)
+   # It requires to create a connection to the data, ie opening the yaml file.
+   # So, before working with the :student object, the controller requires a connection
+   # This connection will be loaded in the memory and provided to the controller
+   # when needed.
+   # obj_needs :CloudObject update the :student object to requires a connection before.
+   obj_needs   :CloudObject,              :connection
+
+   # To simplify controller wrapper, we use hdata built by lorj, and passed to the API
+   # This hdata is a hash containing mapped data, thanks to set_hdata.
+   set_hdata :first_name
+   set_hdata :last_name
+   # Instead of 'course', the yaml API uses 'training'
+   set_hdata :course, :mapping => :training
+
+   get_attr_mapping :course, :training
+   # instead of 'student_name', the yaml API uses 'name'
+   get_attr_mapping :student_name, :name
+
+   # This controller will know how to manage a student file with those data.
+   # But note that the file can have a lot of more data than what the process
+   # usually manage. It is up to you to increase your process to manage more data.
+   # Then each controller may need to define mapping fields.
+end

data/example/students_3/controller/yaml_students_controller.rb

@@ -0,0 +1,123 @@
+# 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.
+
+
+# This class describes how to process some actions, and will do everything prior
+# this task to make it to work.
+
+# This Mock controller keep the data in memory in hash/Array data.
+
+# declare yaml student API to the controller
+cur_file = File.expand_path(File.join(File.dirname(File.dirname(__FILE__)), "..", "yaml_students", 'yaml_students.rb'))
+require cur_file
+
+# The controller is a combination of 2 elements:
+# - Controller class
+#   Code which will interfere with the external API.
+#
+#   The file name must respect the name of the class. 1st letter already capitalized and letter after _ is capitalized.
+#   file: my_code.rb => needs to create MyCodeController class
+#
+# - Definition class
+#   This class declare any kind of mapping or additional fields to consider.
+#   Additionnal fields are unknow by the process. So, those fields will needs to be setup before.
+#
+#   file name convention is identical than controller class.
+#   file: my_code.rb => needs to create MyCode class
+
+class YamlStudentsController
+   def initialize()
+      @@valid_attributes = [:name, :first_name, :last_name, :id, :status, :training]
+   end
+
+   def create(sObjectType, hParams)
+      case sObjectType
+         when :connection
+            required?(hParams, :hdata, :file_name)
+            YamlSchool.new(hParams[:hdata, :file_name])
+         when :student
+            required?(hParams, :connection)
+            required?(hParams, :student_name)
+
+            hParams[:connection].create_student(hParams[:student_name], hParams[:hdata])
+         else
+            Error "'%s' is not a valid object for 'create'" % sObjectType
+      end
+   end
+
+   # This function return a collection which have to provide:
+   # functions: [], length, each
+   # Used by network process.
+   def query(sObjectType, sQuery, hParams)
+      case sObjectType
+         when :student
+            required?(hParams, :connection)
+
+            hParams[:connection].query_student(sQuery)
+         else
+            Error "'%s' is not a valid object for 'create'" % sObjectType
+      end
+
+   end
+
+   def delete(sObjectType, hParams)
+      case sObjectType
+         when :student
+            required?(hParams, :connection)
+
+            hParams[:connection].delete_student(hParams[sObjectType][:id])
+         else
+            Error "'%s' is not a valid object for 'create'" % sObjectType
+      end
+   end
+
+   def get_attr(oControlerObject, key)
+      # This controller function read the data and
+      # extract the information requested by the framework.
+      # Those data will be mapped to the process data model.
+      # The key is an array, to get data from a level tree.
+      # [data_l1, data_l2, data_l3] => should retrieve data from structure like data[ data_l2[ data_l3 ] ]
+      begin
+         attributes = oControlerObject
+         raise "get_attr: attribute '%s' is unknown in '%s'. Valid one are : '%s'" % [key[0], oControlerObject.class, @@valid_attributes ] unless @@valid_attributes.include?(key[0])
+         Lorj::rhGet(attributes, key)
+      rescue => e
+         Error "get_attr: Unable to map '%s'. %s" % [key, e.message]
+      end
+   end
+
+   def set_attr(oControlerObject, key, value)
+      begin
+         attributes = oControlerObject
+         raise "set_attr: attribute '%s' is unknown in '%s'. Valid one are : '%s'" % [key[0], oControlerObject.class, @@valid_attributes ] unless @@valid_attributes.include?(key[0])
+         Lorj::rhSet(attributes, value, key)
+      rescue => e
+         Error "set_attr: Unable to map '%s' on '%s'" % [key, sObjectType]
+      end
+   end
+
+   def update(sObjectType, oObject, hParams)
+      case sObjectType
+         when :student
+            required?(hParams, :connection)
+
+            hParams[:connection].update_student(oObject)
+         else
+            Error "'%s' is not a valid object for 'create'" % sObjectType
+      end
+   end
+
+end

data/example/students_3/process/students.rb

@@ -0,0 +1,118 @@
+# 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.
+
+# Students process - Define specific handlers
+class StudentsProcess
+   def create_student(sObjectType, hParams)
+      PrcLib::state ("Running creation process for object '%s' = '%s'" % [sObjectType, hParams[:student_name] ])
+
+      # config object is a reference to runtime/config data.
+      oList = Query(sObjectType, {:student_name => hParams[:student_name]})
+      case oList.length
+         when 0
+            oObject = controller_create(sObjectType)
+            raise "Student '%s' not created." % hParams[:student_name] if oObject.nil?
+            PrcLib::info ("'%s': '%s' created with id %s" % [sObjectType, hParams[:student_name],  oObject[:id]])
+         when 1
+            oObject = oList[0]
+            PrcLib::info ("'%s': '%s' loaded with id %s" % [sObjectType, hParams[:student_name],  oObject[:id]])
+         else
+            oObject = oList[0]
+            PrcLib::warning("More than one student named '%s' is found: %s records. Selecting the first one and removing duplicates." % [hParams[:student_name], oList.length])
+            iCount = 0
+            oList[1..-1].each { | elem |
+               register(elem)
+               iCount += controller_delete(sObjectType)
+            }
+            PrcLib::info ("'%s': %s duplicated '%s' removed. First loaded with id %s" % [sObjectType, iCount, hParams[:student_name],  oObject[:id]])
+      end
+      oObject
+   end
+
+   # The following handler is inactive.
+   # It provides a simple print-out code.
+   # If you want to activate it:
+   # * uncomment query_student function
+   # * update the :student data model
+   #   on query_e, replace controller_query by query_student
+
+   # def query_student(sObjectType, sQuery, hParams)
+   #    PrcLib::state ("Running query process for object '%s' with query '%s'" % [sObjectType, sQuery])
+   #
+   #   oObjects = controller_query(sObjectType, sQuery)
+   #   raise "Query error." if oObjects.nil?
+   #
+   #   PrcLib::info ("'%s': Queried. %s records found." % [sObjectType, oObjects.length])
+   #   oObjects
+   # end
+
+   # This handler is inactive.
+   # It provides a simple print-out code.
+   # If you want to activate it:
+   # * uncomment get_student function
+   # * update the :student data model
+   #   on get_e, replace controller_get by get_student
+
+   # def delete_student(sObjectType, hParams)
+   #    controller_delete(:student)
+   #    PrcLib::info ("'%s:%s' student removed" % [hParams[:student, :id], hParams[:student, :name]])
+   # end
+end
+
+# Declaring your data model and handlers.
+# Process Handlers functions have to be declared before, as lorj check their existence during data model definition.
+
+class Lorj::BaseDefinition
+
+   # We need to define the student object data model and process handlers to use.
+   # Process handlers must manipulate data defined here.
+   #
+   # The controller can redefine object for it needs, but should NEVER impact the main process.
+   # The controller can add specific process to deal with internal controller objects.
+   # But this should never influence the original process model.
+
+   # Use define_obj, to declare the new object managed by lorj with process handlers.
+   define_obj(:student,
+   {
+      :create_e => :create_student,   # The function to call in the class Students
+      :query_e  => :controller_query, # We use predefined call to the controller query
+      :delete_e => :controller_delete # We use predefined call to the controller delete
+   })
+
+   # obj_needs is used to declare parameters to pass to handlers.
+   # :for indicates those parameters to be passed to create_e handler only.
+   # Those data (or objects) will be collected and passed to the process handler as hParams.
+
+   obj_needs   :data,   :student_name,          { :for => [:create_e] }
+
+   # By default, all data are required.
+   # You can set it as optional. Your process will need to deal with this optional data.
+   obj_needs_optional
+   obj_needs   :data,   :first_name,            { :for => [:create_e] }
+   obj_needs   :data,   :last_name,             { :for => [:create_e] }
+   obj_needs   :data,   :course  # Note that in this model, the training is renamed as course.
+                                 # the controller will need to map it to 'training'.
+
+   # def_attribute defines the data model.
+   # The process will be able to access those data
+   def_attribute :course
+   def_attribute :student_name
+   def_attribute :first_name
+   def_attribute :last_name
+   def_attribute :status
+
+   undefine_attribute :name
+end

data/example/students_3/students.rb

@@ -0,0 +1,93 @@
+#!/usr/bin/env ruby
+
+$APP_PATH = File.dirname(__FILE__)
+require 'lorj'
+require 'ansi'
+
+# Load global Config
+
+# This object is used to provide configuration data to lorj
+
+# The config search is:
+# 1- Application defaults (defaults.yaml) - Not defined by default. update the following line and create defaults.yaml
+# PrcLib.app_defaults = $APP_PATH
+# 2- Local defaults (~/.<Application Name>/config.yaml) - <Application Name> is 'Lorj' by default. Can be updated with following line.
+# PrcLib.app_name = 'myapp'
+# 3 - runtime. Those variables are set, with oConfig[key] = value
+
+oConfig = Lorj::Config.new() # Use Simple Config Object
+
+# You can use an account object, which add an extra account level
+# between runtime and config.yaml/app default
+# oConfig = Lorj::Account.new('MyAccount') #
+
+
+# If you want to see what is happening in the framework, uncomment debug settings.
+# PrcLib.level = Logger::DEBUG # Printed out to your console.
+# PrcLib.core_level = 3 # framework debug levels.
+
+# Initialize the framework
+hProcesses = [ File.join($APP_PATH, 'process', 'students.rb')]
+
+#~ oStudentCore = Lorj::Core.new( oConfig, hProcesses, :mock)
+oStudentCore = Lorj::Core.new( oConfig, hProcesses, File.join($APP_PATH, 'controller', 'yaml_students.rb'))
+
+oStudentCore.Create(:connection, :connection_string => "/tmp/students.yaml")
+
+puts ANSI.bold("Create 1st student:")
+
+# Set the student name to use
+# There is different way to set them... Those lines do the same using config object. Choose what you want.
+oConfig.set(:first_name, 'Robert')
+oConfig[:last_name]    = "Redford"
+oConfig[:student_name] = "Robert Redford"
+oConfig[:course]       = 'Art Comedy'
+
+# Ask the framework to create the object student 'Robert Redford'
+oStudentCore.Create(:student)
+
+puts ANSI.bold("Create 2nd student:")
+# We can set runtime configuration instantly from the Create call
+# The following line :
+oStudentCore.Create(:student, {
+   student_name:  'Anthony Hopkins',
+   first_name:    'Anthony',
+   last_name:     'Hopkins',
+   course:        'Art Drama'
+})
+# oConfig[:student_name] = "Anthony Hopkins"
+# oConfig[:course] = "Art Drama"
+# oStudentCore.Create(:student)
+
+puts ANSI.bold("Create 3rd student:")
+oStudentCore.Create(:student, {
+   student_name: "Marilyn Monroe",
+   first_name:   'Marilyn',
+   last_name:    'Monroe',
+   course:       'Art Drama'
+})
+# replaced the following :
+# oConfig[:student_name] = "Anthony Hopkins"
+# oStudentCore.Create(:student)
+
+puts ANSI.bold("Create mistake")
+oStudent = oStudentCore.Create(:student, {
+   :student_name  => "Anthony Mistake",
+   :first_name    => 'Anthony',
+   :last_name     => 'Mistake',
+   :course        => 'what ever you want!!!'
+})
+
+puts "Student created '%s'" % oStudent[:attrs]
+
+# Because the last student was the mistake one, we can directly delete it.
+# Usually, we use get instead.
+puts ANSI.bold("Remove mistake")
+oStudentCore.Delete(:student)
+puts "Wrong student to remove: %s = %s" % [oStudent[:id], oStudent[:student_name]]
+
+puts ANSI.bold("List of students for 'Art Drama':")
+puts oStudentCore.Query(:student, { :course => "Art Drama"}).to_a
+
+puts ANSI.bold("Deleted students:")
+puts oStudentCore.Query(:student,{ :status => :removed}).to_a