openwferu 0.9.10.653 → 0.9.11

data/lib/openwfe/rest/controlclient.rb

@@ -51,11 +51,6 @@ module OpenWFE
     #
     class ControlClient < RestClient
 
-        def initialize (server, port, username, password)
-
-            super('http://'+server+':'+port.to_s(), username, password)
-        end
-
         def initialize (url, username, password)
 
             super(url, username, password)
@@ -67,7 +62,7 @@ module OpenWFE
         def list_expressions ()
 
             r = self.get('listexpressions', nil, nil)
-            return decode(r)
+            decode(r)
         end
 
         #
@@ -80,7 +75,7 @@ module OpenWFE
             params['id'] = workflowInstanceId
 
             r = self.get('getflowposition', nil, params)
-            return decode(r)
+            decode(r)
         end
 
         #
@@ -92,7 +87,7 @@ module OpenWFE
 
             params = {}
 
-            return decode(self.post('cancelexpression', nil, params, fei))
+            decode(self.post('cancelexpression', nil, params, fei))
         end
 
         #
@@ -104,7 +99,7 @@ module OpenWFE
 
             params = {}
 
-            return decode(self.post('freezeexpression', nil, params, fei))
+            decode(self.post('freezeexpression', nil, params, fei))
         end
 
         #
@@ -116,17 +111,9 @@ module OpenWFE
 
             params = {}
 
-            return decode(self.post('unfreezeexpression', nil, params, fei))
+            decode(self.post('unfreezeexpression', nil, params, fei))
         end
 
-        protected
-
-            def decode (reply)
-
-                xml = REXML::Document.new(reply.body)
-                return OpenWFE.xml_decode(xml.root)
-            end
-
     end
 
 end

data/lib/openwfe/rest/oldrestservlet.rb

@@ -0,0 +1,279 @@
+#
+#--
+# Copyright (c) 2007, John Mettraux, OpenWFE.org
+# All rights reserved.
+# 
+# Redistribution and use in source and binary forms, with or without 
+# modification, are permitted provided that the following conditions are met:
+# 
+# . Redistributions of source code must retain the above copyright notice, this
+#   list of conditions and the following disclaimer.  
+# 
+# . Redistributions in binary form must reproduce the above copyright notice, 
+#   this list of conditions and the following disclaimer in the documentation 
+#   and/or other materials provided with the distribution.
+# 
+# . Neither the name of the "OpenWFE" nor the names of its contributors may be
+#   used to endorse or promote products derived from this software without
+#   specific prior written permission.
+# 
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 
+# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE 
+# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 
+# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 
+# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
+# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 
+# POSSIBILITY OF SUCH DAMAGE.
+#++
+#
+#
+
+#
+# "made in Japan"
+#
+# John Mettraux at openwfe.org
+#
+
+require 'thread'
+require 'webrick'
+require 'rexml/document'
+require 'openwfe/rest/xmlcodec'
+
+
+module OpenWFE
+
+    #
+    # A common parent class for the worklist and the engine old-style (2002)
+    # REST interface.
+    #
+    class OldRestServlet < WEBrick::HTTPServlet::AbstractServlet
+
+        MUTEX = Mutex.new
+        CT = "Content-Type"
+
+        def initialize (server, params)
+
+            super
+
+            @auth_system = params[:AuthSystem] || {}
+
+            @realm_name = get_realm_name
+
+            @last_given_session_id = -1
+            @sessions = {}
+        end
+
+        #
+        # this default implementation returns "no_realm".
+        #
+        def get_realm_name
+            "no_realm"
+        end
+
+        def service req, res
+
+            if req.request_method == 'POST'
+                class << req
+                    def parse_query
+                        @query = WEBrick::HTTPUtils::parse_query(@query_string)
+                    end
+                end
+            end
+
+            username = authenticate req, res
+
+            if req.query_string == nil
+
+                get_new_session username, req, res
+                return
+            end
+
+            req.attributes['username'] = username
+
+            action = req.query["action"]
+            action = action.downcase if action
+
+            if action == "endworksession"
+                end_work_session req, res
+                return
+            end
+
+            action_method = "do__#{action}".intern
+
+            unless self.respond_to?(action_method)
+                action_not_implemented action, res
+                return
+            end
+
+            begin
+                self.send action_method, req, res
+            rescue Exception => e
+                reply_with_exception res, e
+            end
+        end
+
+        #
+        # Returns always the same servlet instance.
+        #
+        def self.get_instance (server, *options)
+            MUTEX.synchronize do
+                return @__instance__ if @__instance__
+                @__instance__ = self.new(server, *options)
+            end
+        end
+
+        protected
+
+            def reply_with_error (res, code, error_message)
+
+                res.status = code
+                res[CT] = "text/plain"
+                res.body = error_message
+            end
+
+            def reply_with_exception (res, exception)
+
+                message = exception.message
+
+                ms = message.split
+
+                code = 500
+                body = message
+
+                if ms.length > 1 and ms[0].to_i != 0
+                    code = Integer(ms[0])
+                    body = message[4..-1]
+                end
+
+                message << "\n"
+                message << OpenWFE::exception_to_s(exception)
+                message << "\n"
+
+                reply_with_error(res, code, body)
+            end
+
+            def reply_with_xml (res, code, xml)
+
+                res.status = code
+                res[CT] = "application/xml"
+
+                if xml.kind_of?(REXML::Element)
+                    doc = REXML::Document.new
+                    doc << xml
+                    xml = OpenWFE::xml_to_s(doc)
+                end
+
+                res.body = xml
+            end
+
+            def end_work_session (req, res)
+
+                sid = req.query['session']
+                @sessions.delete(Integer(sid)) if sid
+
+                @logger.debug "end_work_session() #{sid}"
+                #@logger.debug "end_work_session() sessions : #{@sessions.size}"
+
+                reply_with_xml(res, 200, REXML::Element.new('bye'))
+            end
+
+            def authenticate req, res
+
+                user = nil
+
+                WEBrick::HTTPAuth::basic_auth(req, res, @realm_name) do |u, p|
+
+                    user = get_session_user req
+
+                    if user
+                        true
+                    else
+                        user = u
+                        _authenticate u, p
+                    end
+                end
+
+                user
+            end
+
+            def _authenticate user, pass
+
+                if @auth_system.kind_of?(Hash)
+                    @auth_system[user] == pass
+                elsif @auth_system.kind_of?(Proc)
+                    @auth_system.call user, pass
+                elsif @auth_system.respond_to?(:authenticate)
+                    @auth_system.authenticate user, pass
+                else
+                    false
+                end
+            end
+
+            def determine_agent (req)
+
+                req.addr.join "|"
+            end
+
+            def get_new_session username, req, res
+
+                sid = new_session_id
+
+                @sessions[sid] = [ 
+                    username,
+                    determine_agent(req), 
+                    Time.now.to_i 
+                ]
+
+                @logger.debug "get_new_session() #{sid}"
+                #@logger.debug "get_new_session() sessions : #{@sessions.size}"
+
+                esess = REXML::Element.new 'session'
+                esess.add_attribute 'id', sid
+
+                reply_with_xml res, 200, esess
+            end
+            
+            def action_not_implemented action, res
+
+                reply_with_error(
+                    res, 404, "action '#{action}' is not implemented.")
+            end
+
+            def new_session_id
+                MUTEX.synchronize do
+
+                    id = Integer(Time.new.to_f * 100000)
+
+                    id = @last_given_session_id + 1 \
+                        if id <= @last_given_session_id
+
+                    @last_given_session_id = id
+                    id
+                end
+            end
+
+            def get_session_user (req)
+
+                sid = req.query['session']
+
+                @logger.debug "get_session_user() sid : #{sid}"
+
+                return nil unless sid
+
+                s = @sessions[Integer(sid)]
+
+                return nil unless s
+
+                username, agent, last_seen = s
+
+                return username if agent == determine_agent(req)
+
+                nil
+            end
+    end
+end
+

data/lib/openwfe/rest/restclient.rb

@@ -41,6 +41,8 @@ require 'base64'
 require 'net/http'
 require 'rexml/document'
 
+require 'openwfe/version'
+
 
 module OpenWFE
 
@@ -63,25 +65,51 @@ module OpenWFE
         #
         # Closes this REST client
         #
-        def close ()
-
-            post('endWorkSession', nil, {}, nil)
+        def close
+            get('endWorkSession', nil, {})
         end
 
         protected
 
+            def decode (reply)
+
+                raise "Error : #{reply.code} - #{reply.body}" \
+                    if reply.code != "200"
+
+                begin
+                    xml = REXML::Document.new reply.body
+                    OpenWFE::XmlCodec::decode xml.root
+                rescue Exception => e
+                    if $DEBUG
+                        #puts
+                        #puts e.to_s
+                        puts
+                        puts "failed to decode reply :"
+                        puts
+                        puts reply.body
+                        puts
+                    end
+                    raise e
+                end
+            end
+
+            #
+            # GETs a REST operation
+            #
             def get (action, subResourceName, params)
 
-                return @httpclient\
-                    .get(compute_resource(action, subResourceName, params))
+                @httpclient.get(
+                    compute_resource(action, subResourceName, params))
             end
 
+            #
+            # POSTs a REST operation
+            #
             def post (action, subResourceName, params, data)
 
-                data = data.to_s()
-
-                return @httpclient\
-                    .post(compute_resource(action, subResourceName, params), data)
+                @httpclient.post(
+                    compute_resource(action, subResourceName, params), 
+                    data.to_s)
             end
 
         private
@@ -95,7 +123,7 @@ module OpenWFE
                 url = url[7..-1] if url[0..6] == 'http://'
 
                 i = url.index('/')
-                if i < 0
+                unless i
                     @resource = '/defaultrestresource'
                 else
                     @resource = url[i..-1]
@@ -117,31 +145,33 @@ module OpenWFE
 
                 hs = {}
                 hs['Authorization'] = \
-                    'Basic ' + Base64.encode64(@username+":"+password)
-                hs['RestClient'] = 'openwfe-ruby'
+                    'Basic ' + Base64.encode64(@username+":"+password).strip
+                hs['RestClient'] = "openwfe-ruby #{OPENWFERU_VERSION}"
+                hs['User-Agent'] = "openwfe-ruby #{OPENWFERU_VERSION}"
+
+                #puts "@resource is '#{@resource}'"
+                #puts "hs is '#{hs.inspect}'"
 
                 r = @httpclient.get(@resource, hs)
 
-                xml = REXML::Document.new(r.body)
+                #xml = REXML::Document.new(r.body)
+                #@session_id = Integer(xml.root.attributes["id"])
 
-                @session_id = Integer(xml.root.attributes["id"])
+                @session_id = decode r
             end
 
-            def compute_resource (action, subResourceName, params)
+            def compute_resource (action, sub_resource_name, params)
 
-                resource = @resource
-                resource = resource+'/'+subResourceName if subResourceName
+                reso = @resource.dup
+                reso += "/#{sub_resource_name}" if sub_resource_name
 
-                resource = resource+\
-                    '?session='+@session_id.to_s()+'&action='+action
+                reso += "?session=#{@session_id.to_s}&action=#{action}"
 
-                if params
-                    params.keys.each do |k|
-                        resource = resource+'&'+k.to_s()+'='+params[k].to_s()
-                    end
-                end
+                params.each { |k, v| 
+                    reso += "&#{k.to_s}=#{v.to_s}" 
+                } if params
 
-                return resource
+                reso
             end
     end
 end

data/lib/openwfe/rest/worklistclient.rb

@@ -49,22 +49,16 @@ module OpenWFE
     #
     class WorklistClient < RestClient
 
-        def initialize (server, port, username, password)
-
-            super('http://'+server+':'+port.to_s(), username, password)
-        end
-
         def initialize (url, username, password)
-
-            super(url, username, password)
+            super
         end
 
         #
         # Returns the list of stores the worklist hosts
         #
-        def list_stores ()
-            r = self.get('listStores', nil, nil)
-            return decode(r)
+        def list_stores
+            r = get('listStores', nil, nil)
+            decode(r)
         end
 
         #
@@ -80,15 +74,18 @@ module OpenWFE
             params = {}
             params["limit"] = limit
 
-            return decode(self.get('getHeaders', storeName, params))
+            decode(get('getHeaders', storeName, params))
         end
 
-        def find_flow_instance (storeName, workflowInstanceId)
+        #
+        # TODO : rdoc me
+        #
+        def find_flow_instance (store_name, workflow_instance_id)
 
             params = {}
-            params["id"] = workflowInstanceId
+            params["id"] = workflow_instance_id
 
-            return decode(self.get('findFlowInstance', storeName, params))
+            decode(get('findFlowInstance', store_name, params))
         end
 
         #
@@ -98,12 +95,12 @@ module OpenWFE
         #
         def launch_flow (engineId, launchitem)
 
-            eli = OpenWFE.xml_encode(launchitem)
+            eli = OpenWFE::XmlCodec::encode(launchitem)
 
             params = {}
             params[ENGINEID] = engineId
 
-            return decode(self.post('launchFlow', nil, params, eli))
+            decode(post('launchFlow', nil, params, eli))
         end
 
         #
@@ -113,7 +110,7 @@ module OpenWFE
         #
         def get_workitem (storeName, flowExpressionId)
 
-            return get_item('getWorkitem', storeName, flowExpressionId)
+            get_item('getWorkitem', storeName, flowExpressionId)
         end
 
         #
@@ -125,7 +122,7 @@ module OpenWFE
 
             #puts "...getAndLockWorkitem() for #{flowExpressionId}"
 
-            return get_item('getAndLockWorkitem', storeName, flowExpressionId)
+            get_item('getAndLockWorkitem', storeName, flowExpressionId)
         end
 
         #
@@ -154,16 +151,15 @@ module OpenWFE
 
                     #puts "  .ok is #{ok}"
                     #puts "  .id is #{h.flowExpressionId}"
-                    break if not ok
+                    break unless ok
                 end
 
                 #puts "  .id is #{h.flowExpressionId}"
 
-                return get_and_lock_workitem(storeName, h.flow_expression_id) \
-                    if ok
+                get_and_lock_workitem(storeName, h.flow_expression_id) if ok
             end
 
-            return nil
+            nil
         end
 
         #
@@ -172,7 +168,7 @@ module OpenWFE
         #
         def release_workitem (workitem)
 
-            return post_item('releaseWorkitem', workitem)
+            post_item('releaseWorkitem', workitem)
         end
 
         #
@@ -180,7 +176,7 @@ module OpenWFE
         #
         def save_workitem (workitem)
 
-            return post_item('saveWorkitem', workitem)
+            post_item('saveWorkitem', workitem)
         end
 
         #
@@ -189,9 +185,11 @@ module OpenWFE
         #
         def proceed_workitem (workitem)
 
-            return post_item('forwardWorkitem', workitem)
+            post_item('forwardWorkitem', workitem)
         end
 
+        alias :forward_workitem :proceed_workitem
+
         #
         # Returns the list of flow URLs the user owning this session may
         # launch.
@@ -200,8 +198,7 @@ module OpenWFE
 
             params = {}
 
-            #return decode(post('listLaunchables', nil, params, nil))
-            return decode(get('listLaunchables', nil, params))
+            decode(get('listLaunchables', nil, params))
         end
 
         #
@@ -214,7 +211,7 @@ module OpenWFE
             params = {}
             params[TARGETSTORE] = targetStoreName
 
-            return decode(post('delegate', workitem.store, params, ewi))
+            decode(post('delegate', workitem.store, params, ewi))
         end
 
         #
@@ -228,7 +225,7 @@ module OpenWFE
             params = {}
             params[TARGETPARTICIPANT] = targetParticipantName
 
-            return decode(post('delegate', workitem.store, params, ewi))
+            decode(post('delegate', workitem.store, params, ewi))
         end
 
         #def queryStore (storeName, query)
@@ -236,33 +233,27 @@ module OpenWFE
 
         protected
 
-            def decode (reply)
-
-                xml = REXML::Document.new(reply.body)
-                return OpenWFE.xml_decode(xml.root)
-            end
-
-            def get_item (restMethodName, storeName, flowExpressionId)
+            def get_item (rest_method_name, store_name, flow_expression_id)
 
-                fei = OpenWFE.xml_encode(flowExpressionId)
-                fei = OpenWFE.xmldoc_to_string(fei, false)
+                fei = OpenWFE::XmlCodec::encode flow_expression_id
+                fei = OpenWFE::xmldoc_to_string fei, false
 
                 params = {}
 
-                wi = decode(self.post(restMethodName, storeName, params, fei))
+                wi = decode(post(rest_method_name, store_name, params, fei))
 
-                wi.store = storeName if wi
+                wi.store = store_name if wi
 
-                return wi
+                wi
             end
 
-            def post_item (restMethodName, workitem)
+            def post_item (rest_method_name, workitem)
 
-                ewi = OpenWFE.xml_encode(workitem)
+                ewi = OpenWFE::XmlCodec::encode(workitem)
 
                 params = {}
 
-                return decode(post(restMethodName, workitem.store, params, ewi))
+                decode(post(rest_method_name, workitem.store, params, ewi))
             end
 
     end