sp-job 0.1.17 → 0.2.2

data/lib/sp/job/job_db_adapter.rb

@@ -0,0 +1,63 @@
+module SP
+  module Job
+
+    unless RUBY_ENGINE == 'jruby'  # TODO suck in the base class from SP-DUH
+
+      class JobDbAdapter < ::SP::Duh::JSONAPI::Adapters::Db
+
+        private
+
+          # Implement the JSONAPI request by direct querying of the JSONAPI function in the database
+          def do_request_on_the_db(method, path, params)
+            jsonapi_query = %Q[ SELECT * FROM public.jsonapi($1, $2, $3, $4, $5, $6, $7, $8, $9) ]
+
+            response = service.connection.exec jsonapi_query, method, (method == 'GET' ? url_with_params_for_query(path, params) : url(path)), (method == 'GET' ? '' : params_for_body(params)), user_id, company_id, company_schema, sharded_schema, accounting_schema, accounting_prefix
+            response.first if response.first
+          end
+
+          def explicit_do_request_on_the_db(exp_accounting_schema, exp_accounting_prefix, method, path, params)
+            jsonapi_query = %Q[ SELECT * FROM public.jsonapi($1, $2, $3, $4, $5, $6, $7, $8, $9) ]
+
+            response = service.connection.exec jsonapi_query, method, (method == 'GET' ? url_with_params_for_query(path, params) : url(path)), (method == 'GET' ? '' : params_for_body(params)), user_id, company_id, company_schema, sharded_schema, exp_accounting_schema, exp_accounting_prefix
+            response.first if response.first
+          end
+
+          def user_id           ; service.parameters.user_id ; end
+          def company_id        ; service.parameters.company_id ; end
+          def company_schema    ; service.parameters.company_schema.nil? ? nil : service.parameters.company_schema ; end
+          def sharded_schema    ; service.parameters.sharded_schema.nil? ? nil : service.parameters.sharded_schema ; end
+          def accounting_schema ; service.parameters.accounting_schema.nil? ? nil : service.parameters.accounting_schema ; end
+          def accounting_prefix ; service.parameters.accounting_prefix.nil? ? nil : service.parameters.accounting_prefix ; end
+
+          def params_for_body(params)
+            params.blank? ?  '' : params.to_json
+          end
+
+          def params_for_query(params)
+            query = ""
+            if !params.blank?
+              case
+                when params.is_a?(Array)
+                  # query = params.join('&')
+                  query = params.map{ |v| URI.encode(URI.encode(v), "&") }.join('&')
+                when params.is_a?(Hash)
+                  query = params.map do |k,v|
+                    if v.is_a?(String)
+                      "#{k}=\"#{URI.encode(URI.encode(v), "&")}\""
+                    else
+                      "#{k}=#{v}"
+                    end
+                  end.join('&')
+                else
+                  query = params.to_s
+              end
+            end
+            query
+          end
+
+      end
+
+    end
+
+  end
+end

data/lib/sp/job/{engine.rb → jwt.rb}

@@ -1,7 +1,7 @@
 #
-# Copyright (c) 2011-2016 Cloudware S.A. All rights reserved.
+# Helper to obtain tokens to access toconline API's.
 #
-# This file is part of sp-job.
+# And this is the mix-in we'll apply to Job execution classes
 #
 # sp-job is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License as published by
@@ -19,16 +19,18 @@
 # encoding: utf-8
 #
 
+require 'jwt' # https://github.com/jwt/ruby-jwt
+
 module SP
   module Job
-    class Engine < ::Rails::Engine
-      isolate_namespace SP::Job
+  	class JWTHelper
+
+		# encode & sign jwt
+		def self.encode(key:, payload:)
+			rsa_private = OpenSSL::PKey::RSA.new( File.read( key ) )
+			return JWT.encode payload, rsa_private, 'RS256', { :typ => "JWT" }
+		end #self.encodeJWT
 
-      initializer :append_migrations do |app|
-        unless app.root.to_s.match root.to_s
-          app.config.paths["db/migrate"] += config.paths["db/migrate"].expanded
-        end
-      end
-    end
-  end
-end
+    end # end class 'JWT'
+  end # module Job
+end# module SP

data/lib/sp/job/mail_queue.rb

@@ -0,0 +1,60 @@
+#
+# Copyright (c) 2011-2017 Cloudware S.A. All rights reserved.
+#
+# This file is part of sp-job.
+#
+# sp-job is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# sp-job is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with sp-job.  If not, see <http://www.gnu.org/licenses/>.
+#
+# encoding: utf-8
+#
+# require 'sp-job'
+# require 'sp/job/back_burner'
+# require 'sp/job/mail_queue'
+#
+# class MailQueue < ::SP::Job::MailQueue
+#
+#    #  Overide methods if needed!
+#
+# end
+#
+# Backburner.work('mail-queue')
+#
+
+module SP
+  module Job
+    class MailQueue
+      extend SP::Job::Common
+      include Backburner::Queue
+      queue 'mail-queue'
+      queue_respond_timeout 30
+
+      def self.perform (job)
+        email = synchronous_send_email(
+          body:        job[:body],
+          template:    job[:template],
+          to:          job[:to],
+          reply_to:    job[:reply_to],
+          subject:     job[:subject],
+          attachments: job[:attachments]
+        )
+        logger.info "mailto: #{job[:to]} - #{job[:subject]}"
+      end
+
+      def self.on_failure (e, job)
+        logger.info "Mail to #{job[:to]} failed"
+      end
+
+    end # MailQueue
+  end # Job
+end # SP

data/lib/sp/job/pg_connection.rb

@@ -27,20 +27,6 @@ module SP
 
     class PGConnection
 
-      private
-
-      #
-      # Private Data
-      #
-      @owner      = nil
-      @config     = nil
-      @connection = nil
-      @treshold   = -1
-      @counter    = 0
-      @statements = []
-
-      public
-
       #
       # Public Attributes
       #
@@ -52,13 +38,14 @@ module SP
       # @param owner
       # @param config
       #
-      def initialize (owner:, config:)
+      def initialize (owner:, config:, multithreaded: false)
+        @mutex      = multithreaded ? Mutex.new : ::SP::Job::FauxMutex.new
         @owner      = owner
         @config     = config
-        @connection         = nil
+        @connection = nil
         @treshold   = -1
         @counter    = 0
-        @statements = []
+        @id_cache   = {}
         min = @config[:min_queries_per_conn]
         max = @config[:max_queries_per_conn]
         if (!max.nil? && max > 0) || (!min.nil? && min > 0)
@@ -66,7 +53,7 @@ module SP
           new_min, new_max = [min, max].minmax
           new_min = new_min if new_min <= 0
           if new_min + new_min > 0
-            @treshold = (new_min + (new_min - new_min) * rand).to_i
+            @treshold = (new_min + (new_max - new_min) * rand).to_i
           else
             @treshold = new_min.to_i
           end
@@ -78,98 +65,103 @@ module SP
       #        Previous one ( if any ) will be closed first.
       #
       def connect ()
-        disconnect()
-        @connection = PG.connect(@config[:conn_str])
+        @mutex.synchronize {
+          _disconnect()
+          @connection = PG.connect(@config[:conn_str])
+        }
       end
 
       #
       # Close currenly open database connection.
       #
       def disconnect ()
-        if @connection.nil?
-          return
-        end
-        while @statements.count > 0 do
-            @connection.exec("DEALLOCATE #{@statements.pop()}")
-        end
-        @connection.close
-        @connection = nil
-        @counter = 0
+        @mutex.synchronize {
+          _disconnect()
+        }
       end
 
       #
-      # Prepare an SQL statement.
+      # Execute a prepared SQL statement.
       #
-      # @param query
-      #
-      # @return Statement id.
+      # @param query the SQL query with data binding
+      # @param args all the args for the query
+      # @return query result.
       #
-      def prepare_statement (query:)
-        if nil == @connection
-          connect()
-        end
-        id = "#{@owner}_#{Digest::MD5.hexdigest(query)}"
-        if @statements.include? id
-          return id
-        else
-          @statements << id
-          @connection.prepare(@statements.last, query)
-          return @statements.last
-        end
+      def exec (query, *args)
+        @mutex.synchronize {
+          if nil == @connection
+            _connect()
+          end
+          _check_life_span()
+          unless @id_cache.has_key? query
+            id = "p#{Digest::MD5.hexdigest(query)}"
+            @connection.prepare(id, query)
+            @id_cache[query] = id
+          else
+            id = @id_cache[query]
+          end
+          @connection.exec_prepared(id, args)
+        }
       end
 
       #
-      # Execute a previously prepared SQL statement.
-      #
-      # @param id
-      # @param args
+      # Execute a query,
       #
-      # @return PG result
+      # @param query
       #
-      def execute_statement (id:, args:)
-        check_life_span()
-        @connection.exec_prepared(id, args)
+      def query (query:)
+        @mutex.synchronize {
+          unless query.nil?
+            _check_life_span()
+            @connection.exec(query)
+          end
+        }
       end
 
       #
-      # Destroy a previously prepared SQL statement.
+      # Call this to check if the database is not a production database where it's
+      # dangerous to make development stuff. It checks the presence of a magic parameter
+      # on the PG configuration that marks the database as a development arena
       #
-      # @param id
-      # @param args
-      #
-      def dealloc_statement (id:)
-        if nil == id
-          while @statements.count > 0 do
-              @connection.exec("DEALLOCATE #{@statements.pop()}")
-          end
-        else
-          @statements.delete!(id)
-          @connection.exec("DEALLOCATE #{id}")
-        end
+      def safety_check ()
+        SP::Duh::Db::safety_check(@connection)
       end
 
       #
-      # Execute a query,
-      #
-      # @param query
+      # Returns the configured connection string
       #
-      def query (query:)
-        unless query.nil?
-          check_life_span()
-          @connection.exec(query)
-        end
+      def conn_str
+        @config[:conn_str]
       end
 
       private
 
+      def _connect () 
+        _disconnect()
+        @connection = PG.connect(@config[:conn_str])
+      end
+
+      def _disconnect ()
+        if @connection.nil?
+          return
+        end
+
+        @connection.exec("DEALLOCATE ALL")
+        @id_cache = {}
+
+        @connection.close
+        @connection = nil
+        @counter = 0
+      end
+
       #
       # Check connection life span
       #
-      def check_life_span ()
+      def _check_life_span ()
         return unless @treshold > 0
         @counter += 1
         if @counter > @treshold
-          connect()
+          _connect()
         end
       end
 

data/lib/sp/job/unique_file.rb

@@ -0,0 +1,73 @@
+#
+# Copyright (c) 2011-2016 Cloudware S.A. All rights reserved.
+#
+# This file is part of sp-job.
+#
+# And this is the mix-in we'll apply to Job execution classes
+#
+# sp-job is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# sp-job is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with sp-job.  If not, see <http://www.gnu.org/licenses/>.
+#
+# encoding: utf-8
+#
+require 'ffi'
+require 'os'
+require 'fileutils'
+
+module SP
+  module Job
+    module Unique
+      module File
+        extend FFI::Library
+        ffi_lib 'c'
+        attach_function :puts, [ :string ], :int
+        attach_function :mkstemps, [:string, :int], :int
+        attach_function :fcntl, [:int, :int, :pointer], :int
+        attach_function :close, [ :int ], :int
+        unless OS.mac?
+          attach_function :readlink, [ :string, :pointer, :int ], :int
+        end
+
+        #
+        # Creates a uniquely named file inside the specified folder. The created file is empty
+        #
+        # @param a_folder Folder where the file will be created
+        # @param a_suffix file suffix, warning must include the .
+        # @return Absolute file path
+        #
+        def self.create (a_folder, a_extension)
+          FileUtils.mkdir_p(a_folder) if !Dir.exist?(a_folder)
+          fd = ::SP::Job::Unique::File.mkstemps("#{a_folder}/XXXXXX#{a_extension}", a_extension.length)
+          return nil if fd < 0
+
+          ptr = FFI::MemoryPointer.new(:char, 8192)     # Assumes max path is less that this
+          if OS.mac?
+            r = ::SP::Job::Unique::File.fcntl(fd, 50, ptr) # 50 is F_GETPATH in OSX
+          else
+            r = ::SP::Job::Unique::File.readlink("/proc/self/fd/#{fd}", ptr, 8192)
+            if r > 0 && r < 8192
+              r = 0
+            end
+          end
+          ::SP::Job::Unique::File.close(fd)
+          return nil if r != 0
+          return nil if ptr.null?
+
+          rv = ptr.read_string
+
+          return rv
+        end
+      end
+    end
+  end
+end

data/lib/sp/job/uploaded_image_converter.rb

@@ -28,9 +28,7 @@
 # require 'sp/job/back_burner'
 # require 'sp/job/uploaded_image_converter'
 # 
-# class CLASSNAME
-#   extend SP::Job::Common
-#   extend SP::Job::UploadedImageConverter
+# class CLASSNAME < ::SP::Job::UploadedImageConverter
 # 
 #   def self.perform(job)
 # 
@@ -48,23 +46,40 @@
 
 module SP
   module Job
-    module UploadedImageConverter
+    class UploadedImageConverter
       extend SP::Job::Common
 
       def self.perform (job)
 
-        throw Exception.new("i18n_entity_id_must_be_defined") if job[:entity_id].nil? || job[:entity_id].to_i == 0
+        raise_error(message: 'i18n_entity_id_must_be_defined') if job[:entity_id].nil? || job[:entity_id].to_i == 0
 
         step        = 100 / (job[:copies].size + 1)
-        original    = File.join($config[:paths][:temporary_uploads], job[:original])
-        destination = File.join($config[:paths][:uploads_storage], job[:entity], id_to_path(job[:entity_id]), job[:folder])
+        progress    = step
+        original    = File.join(config[:paths][:temporary_uploads], job[:original])
+        destination = File.join(config[:paths][:uploads_storage], job[:entity], id_to_path(job[:entity_id]), job[:folder])
 
         #
-        # Read the original image, any format that image magic can handle will be ok
+        # Check the original image, check format and limits
         # 
         FileUtils::mkdir_p destination
-        image = Magick::Image.read(original).first
-        update_progress(step: step, message: 'i18n_reading_original_$image', image: job[:original])
+        update_progress(progress: progress, message: 'i18n_reading_original_$image', image: job[:original])
+        img_info = %x[identify #{original}]
+        m = %r[.*\.ul\s(\w+)\s(\d+)x(\d+)\s.*].match img_info
+        if $?.success? == false
+          return report_error(message: 'i18n_invalid_image', info: "Image #{original} can't be identified '#{img_info}'")
+        end
+        if m.nil? || m.size != 4 
+          return report_error(message: 'i18n_invalid_image', info: "Image #{original} can't be identified '#{img_info}'")
+        end
+        unless config[:options][:formats].include? m[1]
+          return report_error(message: 'i18n_unsupported_$format', format: m[1])
+        end
+        if m[2].to_i > config[:options][:max_width]
+          return report_error(message: 'i18n_image_too_wide_$width$max_width', width: m[2], max_width:  config[:options][:max_width])
+        end
+        if m[3].to_i > config[:options][:max_height]
+          return report_error(message: 'i18n_image_too_tall_$height$max_height', height: m[3], max_height: config[:options][:max_height])
+        end
 
         barrier = true # To force progress on first scalling
 
@@ -72,18 +87,22 @@ module SP
         # Iterate the copies array
         #
         job[:copies].each do |copy|
-          img_copy = image.copy()
-          img_copy.change_geometry(copy[:geometry].to_s) do |cols, rows, img|
-            img.resize!(cols, rows)
+          %x[convert #{original} -geometry #{copy[:geometry]} #{File.join(destination, copy[:name])}]
+          unless $?.success?
+            raise_error(message: 'i18n_internal_error', info: "convert failed to scale #{original} to #{copy[:geometry]}")
           end
-          img_copy.write(File.join(destination, copy[:name]))
-          update_progress(step: step, message: 'i18n_scalling_image_$name$geometry', name: copy[:name], geometry: copy[:geometry], barrier: barrier)
+          progress += step
+          update_progress(progress: progress, message: 'i18n_scalling_image_$name$geometry', name: copy[:name], geometry: copy[:geometry], barrier: barrier)
           logger.debug("Scaled to geometry #{copy[:geometry]}")
           barrier = false
         end
 
         # Closing arguments, all done
-        update_progress(status: 'completed', message: 'i18n_image_conversion_complete', link: File.join('/',job[:entity], id_to_path(job[:entity_id]), job[:folder], 'logo_template.png'))
+        send_response(message: 'i18n_image_conversion_complete', link: File.join('/',job[:entity], id_to_path(job[:entity_id]), job[:folder], 'logo_template.png'))
+
+        # Remove original file
+        FileUtils::rm_f(original) if config[:options][:delete_originals] 
+
       end
 
     end # UploadedImageConverter