Use a proper Middleware for heavy lifting

The `xmlrpc.synchronousCall` middleware now triggers the
handler execution. The RouteKeeper is only convenience
wrapping now.

Also fixed up the bodyParser, which still had some issues.

Finally, moved the basic introspection support to its
own file.

Author: helje5

Package.swift

@@ -12,7 +12,7 @@ let package = Package(
 
   dependencies: [
     .package(url: "https://github.com/Macro-swift/Macro.git",
-             from: "0.5.9"),
+             from: "0.6.0"),
     .package(url: "https://github.com/Macro-swift/MacroExpress.git",
              from: "0.5.7"),
     .package(url: "https://github.com/AlwaysRightInstitute/SwiftXmlRpc.git",

Sources/MacroXmlRpc/BodyParser.swift

@@ -23,20 +23,31 @@ public extension bodyParser {
    *
    * Usage:
    *
-   *     app.use(bodyParser.xmlRpcCall())
+   *     app.route("/RPC2")
+   *        .use(bodyParser.xmlRpcCall())
+   *        .post("/RPC2") { req, res, next in
+   *          guard let call = req.xmlRpcCall else { return next() }
+   *          console.log("received call:", call)
+   *        }
    *
-   *     app.post("/RPC2") { req, res, next in
-   *       guard let call = req.xmlRpcCall else { return next() }
-   *       console.log("received call:", call)
-   *     }
+   * Note: Do not unnecessary call this middleware, i.e. maybe not at the top
+   *       level, but rather as part of an actual XML-RPC route.
    *
    * This plays well w/ other body parsers. If no other parser was active,
    * it will fill `request.body` as `.text`.
    */
-  func xmlRpcCall() -> Middleware {
+  @inlinable
+  static func xmlRpcCall() -> Middleware {
     return { req, res, next in
       if req.extra[xmlRpcRequestKey] != nil { return next() } // parsed already
 
+      func registerCallInLogger() {
+        guard let call = req.xmlRpcCall else { return }
+        // If we parsed an XML-RPC call, add its method name to the logging
+        // meta data. It is important contextual information.
+        req.log[metadataKey: "xmlrpc"] = .string(call.methodName)
+      }
+      
       // This deals w/ other bodyParsers being active. If we already have
       // content (e.g. from bodyParser.text or .raw) we reuse that.
       switch req.body {
@@ -51,6 +62,7 @@ public extension bodyParser {
               req.body       = .text(string)
               req.xmlRpcBody = XmlRpc.parseCall(string).flatMap { .call($0) }
                            ?? .invalid
+              registerCallInLogger()
               return nil
             }
             catch {
@@ -75,6 +87,7 @@ public extension bodyParser {
             req.body       = .text(string)
             req.xmlRpcBody = XmlRpc.parseCall(string).flatMap { .call($0) }
                          ?? .invalid
+            registerCallInLogger()
           }
           catch {
             // In this case, this doesn't have to be an error. Could be some
@@ -86,6 +99,7 @@ public extension bodyParser {
         case .text(let string):
           req.xmlRpcBody = XmlRpc.parseCall(string).flatMap { .call($0) }
                        ?? .invalid
+          registerCallInLogger()
           return next()
       }
     }
@@ -126,9 +140,10 @@ public extension IncomingMessage {
 
 // MARK: - Helper
 
-private func concatError(request : IncomingMessage,
-                         next    : @escaping Next,
-                         handler : @escaping ( Buffer ) -> Swift.Error?)
+@usableFromInline
+func concatError(request : IncomingMessage,
+                 next    : @escaping Next,
+                 handler : @escaping ( Buffer ) -> Swift.Error?)
 {
   var didCallNext = false
 

Sources/MacroXmlRpc/Introspection.swift

@@ -0,0 +1,41 @@
+//
+//  Introspection.swift
+//  MacroXmlRpc
+//
+//  Created by Helge Hess.
+//  Copyright © 2020 ZeeZide GmbH. All rights reserved.
+//
+
+public extension RouteKeeper {
+
+  @inlinable
+  @discardableResult
+  func systemListMethods() -> Self {
+    post { req, res, next in
+      guard let call = XmlRpc.parseCall(req.body.text ?? ""),
+            call.methodName == "system.listMethods" else {
+        return next()
+      }
+      res.send(XmlRpc.Response(req.knownXmlRpcMethodNames).xmlString)
+    }
+  }
+}
+
+extension IncomingMessage {
+  
+  @usableFromInline
+  var knownXmlRpcMethodNames : [ String ] {
+    return (extra["rpc.methods"] as? [ String ]) ?? []
+  }
+  
+  @usableFromInline
+  func addKnownXmlRpcMethod(_ methodName: String) {
+    if var methods = extra.removeValue(forKey: "rpc.methods") as? [ String ] {
+      methods.append(methodName)
+      extra["rpc.methods"] = methods
+    }
+    else {
+      extra["rpc.methods"] = [ methodName ]
+    }
+  }
+}

Sources/MacroXmlRpc/Middleware.swift

@@ -6,5 +6,89 @@
 //  Copyright © 2020 ZeeZide GmbH. All rights reserved.
 //
 
+import enum     XmlRpc.XmlRpc
+import protocol XmlRpc.XmlRpcValueRepresentable
+import MacroExpress
+
 // TODO: Try to mirror the JS server in http://xmlrpc.com
 public enum xmlrpc {}
+
+public extension xmlrpc {
+  
+  /**
+   * Calls an XML-RPC handler function synchronously.
+   *
+   * It is recommended to invoke the `bodyParser.xmlRpcCall` in a proper place,
+   * though if that didn't happen, this method will do it for the user.
+   */
+  static func synchronousCall(_ methodName: String? = nil,
+                              execute: @escaping ( XmlRpc.Call ) throws
+                                                  -> XmlRpcValueRepresentable)
+       -> Middleware
+  {
+    return { req, res, next in
+      guard req.method == "POST" else { return next() }
+      
+      if let methodName = methodName {
+        req.addKnownXmlRpcMethod(methodName)
+      }
+      
+      /* implementation */
+      
+      func process() {
+        guard let call = req.xmlRpcCall else {
+          // TBD: Not quite sure what the best thing is.
+          if typeIs(req, [ "text/xml" ]) != nil {
+            req.log.error("Could not parse XML-RPC call.")
+            return res.sendStatus(400)
+          }
+          else {
+            return next()
+          }
+        }
+        
+        if let methodName = methodName, call.methodName != methodName {
+          return next()
+        }
+        
+        // It is an XML-RPC call and it matches the requested method (or all).
+        do {
+          let value = try execute(call)
+          
+          req.log.log("executed request:", call.methodName)
+          return res.send(XmlRpc.Response.value(value.xmlRpcValue).xmlString)
+        }
+        catch let error as XmlRpc.Fault {
+          req.log.error("XML-RPC call failed w/ fault:", error)
+          return res.send(XmlRpc.Response.fault(error).xmlString)
+        }
+        catch {
+          req.log.error("XML-RPC call failed w/ non-fault error:", error)
+          res.statusCode = 500
+          return res.send("Call to XML-RPC function failed.")
+        }
+      }
+
+      /* Body parser is not active */
+      if req.extra[xmlRpcRequestKey] == nil,
+         typeIs(req, [ "text/xml" ]) != nil
+      {
+        req.log.notice("Use of XML-RPC middleware w/o a bodyParser")
+        let parser = bodyParser.xmlRpcCall()
+        do {
+          try parser(req, res) { (args: Any...) in
+            assert(req.extra[xmlRpcRequestKey] != nil) // at least .invalid!
+            process()
+          }
+        }
+        catch {
+          req.log.notice("failed to parse XML-RPC: \(error)")
+          return next()
+        }
+      }
+      else { // we have a proper body already
+        process()
+      }
+    }
+  }
+}

Sources/MacroXmlRpc/ReExports.swift

@@ -8,3 +8,4 @@
 
 @_exported import Macro
 @_exported import MacroExpress
+@_exported import enum XmlRpc.XmlRpc

Sources/MacroXmlRpc/RouteKeeper.swift

@@ -18,44 +18,7 @@ public extension RouteKeeper {
              ( XmlRpc.Call ) throws -> XmlRpcValueRepresentable)
        -> Self
   {
-    post { req, res, next in
-      if let methodName = methodName {
-        let methods = (req.extra["rpc.methods"] as? [ String ]) ?? []
-        req.extra["rpc.methods"] = methods + [ methodName ]
-      }
-      
-      guard let call = XmlRpc.parseCall(req.body.text ?? "") else {
-        return res.sendStatus(400)
-      }
-      
-      if let methodName = methodName, call.methodName != methodName {
-        return next()
-      }
-
-      do {
-        let value = try execute(call)
-        res.send(XmlRpc.Response.value(value.xmlRpcValue).xmlString)
-      }
-      catch let error as XmlRpc.Fault {
-        res.send(XmlRpc.Response.fault(error).xmlString)
-      }
-      catch {
-        res.sendStatus(500)
-      }
-    }
-  }
-
-  @inlinable
-  @discardableResult
-  func systemListMethods() -> Self {
-    post { req, res, next in
-      guard let call = XmlRpc.parseCall(req.body.text ?? ""),
-            call.methodName == "system.listMethods" else {
-        return next()
-      }
-      let methods = (req.extra["rpc.methods"] as? [ String ]) ?? []
-      res.send(XmlRpc.Response(methods).xmlString)
-    }
+    post(xmlrpc.synchronousCall(methodName, execute: execute))
   }
 }