Use global logger (#45)

* Use global logger

* Warn in case of empty DaaS

share/api.yaml

@@ -1,6 +1,6 @@
 openapi: "3.0.0"
 info:
-  version: "1.3.2"
+  version: "1.3.3"
   title: "Provisioning Engine REST API"
   description: Provides FaaS capabilities by leveraging features from OpenNebula. Allows to manage Serverless Runtime instances based on a group of Functions defined on request.
 

src/server/client.rb

@@ -10,7 +10,7 @@ class CloudClient
         def initialize(conf, auth)
             @auth = auth
             @conf = conf
-            @logger = ProvisionEngine::Logger.new(conf[:log], 'CloudClient')
+            @logger = $logger
 
             create_client_oned(auth, conf[:one_xmlrpc])
             create_client_oneflow(auth, conf[:oneflow_server])

src/server/log.rb

@@ -58,7 +58,6 @@ def debug_dev(message)
 
         private
 
-        # TODO: Allow reusing previous file log
         def initialize_file_logger(level, rotate = true)
             FileUtils.mkdir_p(LOGS) unless Dir.exist?(LOGS)
             file = File.join(LOGS, "#{@component}.log")

src/server/runtime.rb

@@ -39,13 +39,13 @@ def self.create(client, specification)
             service_id = response[1]['DOCUMENT']['ID'].to_i
             specification['SERVICE_ID'] = service_id
 
-            client.logger.info("#{SRS} #{service_id} created")
+            $logger.info("#{SRS} #{service_id} created")
 
             response = ServerlessRuntime.sync(client, specification)
             return response unless response[0] == 200
 
-            client.logger.info("Creating #{SRD}")
-            client.logger.debug(specification)
+            $logger.info("Creating #{SRD}")
+            $logger.debug(specification)
 
             xml = ServerlessRuntime.build_xml
             runtime = ServerlessRuntime.new(xml, client.client_oned)
@@ -66,7 +66,7 @@ def self.create(client, specification)
                 return ProvisionEngine::Error.new(rc, error, message)
             end
 
-            client.logger.info("Created #{SRD}")
+            $logger.info("Created #{SRD}")
 
             runtime.info
 
@@ -115,7 +115,7 @@ def update
             response = ProvisionEngine::ServerlessRuntime.sync(@cclient, @body)
             return response unless response[0] == 200
 
-            @cclient.logger.info("Updating #{SRD} #{@id}")
+            $logger.info("Updating #{SRD} #{@id}")
             response = super()
 
             if OpenNebula.is_error?(response)
@@ -148,9 +148,8 @@ def update_sr(specification)
 
                 vm_id = @body[function]['VM_ID']
                 if vm_id.nil?
-                    rc = 500
-                    error = "No VM_ID found for function #{function}"
-                    return ProvisionEngine::Error.new(rc, error)
+                    $logger.warning "No VM_ID found for function #{function}"
+                    next
                 end
 
                 vm = ProvisionEngine::Function.new_with_id(vm_id, @cclient.client_oned)
@@ -162,13 +161,13 @@ def update_sr(specification)
                     return ProvisionEngine::Error.new(rc, error, response.message)
                 end
 
-                @cclient.logger.info "Looking for changes for function #{function}"
+                $logger.info "Looking for changes for function #{function}"
 
                 changes = specification[function].dup.delete_if do |k, v|
                     @body[function][k] == v
                 end
 
-                @cclient.logger.debug changes
+                $logger.debug changes
 
                 # Resize VM hardware
                 case vm.state_function
@@ -184,7 +183,7 @@ def update_sr(specification)
                 when ProvisionEngine::Function::STATES[:running]
                     ['capacity', 'disk'].each do |resource|
                         response = vm.public_send("resize_#{resource}?", specification[function],
-                                                  @cclient.logger)
+                                                  $logger)
                         return response unless response[0] == 200
 
                         1.upto(@cclient.conf[:timeout]) do |t|
@@ -240,21 +239,21 @@ def update_sr(specification)
         # @return [Array] [Response Code, ''/Error]
         #
         def delete
-            cclient? && @cclient.logger.info("Deleting #{SRS}")
+            cclient? && $logger.info("Deleting #{SRS}")
 
             document = JSON.parse(to_json)
             service_id = document['DOCUMENT']['TEMPLATE']['BODY']['SERVICE_ID']
 
             response = @cclient.service_delete(service_id)
             rc = response[0]
 
-            @cclient.logger.warning(SRS_NOT_FOUND) if rc == 404
+            $logger.warning(SRS_NOT_FOUND) if rc == 404
 
             if ![204, 404].include?(rc)
                 error = "#{SRS_NO_DELETE} #{service_id}"
                 message = response[1]
 
-                [error, message].each {|i| @cclient.logger.error(i) }
+                [error, message].each {|i| $logger.error(i) }
 
                 response = @cclient.service_destroy(service_id)
 
@@ -264,7 +263,7 @@ def delete
                 end
             end
 
-            @cclient.logger.info("Deleting #{SRD}")
+            $logger.info("Deleting #{SRD}")
 
             response = super()
 
@@ -274,7 +273,7 @@ def delete
                 return ProvisionEngine::Error.new(rc, error, response.message)
             end
 
-            @cclient.logger.info("#{SRD} deleted")
+            $logger.info("#{SRD} deleted")
             [204, '']
         end
 
@@ -335,13 +334,13 @@ def self.sync(client, specification)
                         next unless role['nodes'].size < role['cardinality']
 
                         msg = "Waiting #{t} seconds for service role #{role['name']} VMs"
-                        client.logger.info(msg)
+                        $logger.info(msg)
                         sleep 1
 
                         throw(:query_service)
                     end
 
-                    client.logger.debug(service)
+                    $logger.debug(service)
 
                     roles.each do |role|
                         id = role['nodes'][0]['vm_info']['VM']['ID'].to_i
@@ -389,7 +388,7 @@ def self.to_service(client, specification)
             service_templates.each do |service_template|
                 next unless service_template['NAME'] == tuple
 
-                client.logger.info("Found matching flow template for tuple: #{tuple}")
+                $logger.info("Found matching flow template for tuple: #{tuple}")
 
                 merge_template = {
                     'roles' => []
@@ -419,12 +418,14 @@ def self.to_service(client, specification)
                             return ProvisionEngine::Error.new(500, error)
                         end
 
-                        vm_template = ProvisionEngine::Function.map_vm_template(specification[role], vm_template, client)
+                        vm_template = ProvisionEngine::Function.map_vm_template(
+                            specification[role], vm_template, client
+                        )
 
                         vm_template_contents = "#{vm_template}\n#{user_template}"
 
-                        client.logger.info("Applying \"vm_template_contents\" to role #{role}")
-                        client.logger.debug(vm_template_contents)
+                        $logger.info("Applying \"vm_template_contents\" to role #{role}")
+                        $logger.debug(vm_template_contents)
 
                         merge_template['roles'] << {
                             'name' => role,
@@ -455,7 +456,7 @@ def self.to_service(client, specification)
                 end
 
                 service = rb
-                client.logger.debug(service)
+                $logger.debug(service)
 
                 if client.service_fail?(service)
                     error = "#{SRS} #{service_id} entered FAILED state after creation"
@@ -526,8 +527,8 @@ def rename?(specification)
 
             return [200, ''] unless new_name && new_name != name
 
-            @cclient.logger.info("Renaming #{SRD} #{@id}")
-            @cclient.logger.debug("From: #{name} To: #{new_name}")
+            $logger.info("Renaming #{SRD} #{@id}")
+            $logger.debug("From: #{name} To: #{new_name}")
 
             response = rename(new_name)
 
@@ -632,9 +633,8 @@ def functions
 
                 vm_id = @body[function]['VM_ID']
                 if vm_id.nil?
-                    rc = 500
-                    error = "No VM_ID found for function #{function}"
-                    return ProvisionEngine::Error.new(rc, error)
+                    $logger.warning "No VM_ID found for function #{function}"
+                    next
                 end
 
                 vm = ProvisionEngine::Function.new_with_id(vm_id, @cclient.client_oned)

src/server/server.rb

@@ -25,22 +25,22 @@
 require 'runtime'
 require 'function'
 
-VERSION = '1.3.2'
+VERSION = '1.3.3'
 
 ############################################################################
 # API configuration
 ############################################################################
 
 conf = ProvisionEngine::Configuration.new
+$logger = ProvisionEngine::Logger.new(conf[:log])
 
 configure do
     set :bind, conf[:host]
     set :port, conf[:port]
-    set :logger, ProvisionEngine::Logger.new(conf[:log])
 end
 
-settings.logger.info "Using oned at #{conf[:one_xmlrpc]}"
-settings.logger.info "Using oneflow at #{conf[:oneflow_server]}"
+$logger.info "Using oned at #{conf[:one_xmlrpc]}"
+$logger.info "Using oneflow at #{conf[:oneflow_server]}"
 
 ############################################################################
 # Routes setup
@@ -50,7 +50,7 @@
 before do
     if conf[:log][:level] == 0
         call = "API Call: #{request.request_method} #{request.fullpath} #{request.body.read}"
-        settings.logger.debug(call)
+        $logger.debug(call)
         request.body.rewind
     end
 end
@@ -263,7 +263,7 @@ def auth?
         rc = 401
         error = 'Authentication required'
 
-        settings.logger.error(error)
+        $logger.error(error)
         halt rc, json_response(rc, ProvisionEngine::Error.new(rc, error))
     end
 
@@ -274,7 +274,7 @@ def auth?
         rc = 401
         error = 'Unsupported authentication scheme'
 
-        [error, auth_header].each {|i| settings.logger.error(i) }
+        [error, auth_header].each {|i| $logger.error(i) }
         halt rc, json_response(rc, ProvisionEngine::Error.new(rc, error, auth_header))
     end
 
@@ -288,13 +288,13 @@ def body_valid?
         rc = 400
         error = 'Invalid JSON'
 
-        [error, e.message].each {|i| settings.logger.error(i) }
+        [error, e.message].each {|i| $logger.error(i) }
         halt rc, json_response(rc, ProvisionEngine::Error.new(rc, error, e.message))
     end
 end
 
 def log_request(type)
-    settings.logger.info("Received request to #{type}")
+    $logger.info("Received request to #{type}")
 end
 
 def log_response(level, code, data, message)
@@ -304,7 +304,7 @@ def log_response(level, code, data, message)
         body = data.to_json
     end
 
-    settings.logger.info("#{RC}: #{code}")
-    settings.logger.send(level, message)
-    settings.logger.debug("Response Body: #{body}")
+    $logger.info("#{RC}: #{code}")
+    $logger.send(level, message)
+    $logger.debug("Response Body: #{body}")
 end

tests/init.rb

@@ -86,7 +86,9 @@
             require 'log'
             require 'logger'
 
+            $logger = ProvisionEngine::Logger.new(conf_engine[:log], 'purge')
             client = ProvisionEngine::CloudClient.new(conf_engine, auth)
+
             response = client.service_pool_get
             expect(response[0]).to eq(200)