processor.d

/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements. See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership. The ASF licenses this file
 * to you 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.
 */
module thrift.codegen.processor;

import std.algorithm : find;
import std.array : empty, front;
import std.conv : to;
import std.traits : ParameterTypeTuple, ReturnType, Unqual;
import std.typetuple : allSatisfy, TypeTuple;
import std.variant : Variant;
import thrift.base;
import thrift.codegen.base;
import thrift.internal.codegen;
import thrift.internal.ctfe;
import thrift.protocol.base;
import thrift.protocol.processor;

/**
 * Service processor for Interface, which implements TProcessor by
 * synchronously forwarding requests for the service methods to a handler
 * implementing Interface.
 *
 * The generated class implements TProcessor and additionally allows a
 * TProcessorEventHandler to be specified via the public eventHandler property.
 * The constructor takes a single argument of type Interface, which is the
 * handler to forward the requests to:
 * ---
 * this(Interface iface);
 * TProcessorEventHandler eventHandler;
 * ---
 *
 * If Interface is derived from another service BaseInterface, this class is
 * also derived from TServiceProcessor!BaseInterface.
 *
 * The optional Protocols template tuple parameter can be used to specify
 * one or more TProtocol implementations to specifically generate code for. If
 * the actual types of the protocols passed to process() at runtime match one
 * of the items from the list, the optimized code paths are taken, otherwise,
 * a generic TProtocol version is used as fallback. For cases where the input
 * and output protocols differ, TProtocolPair!(InputProtocol, OutputProtocol)
 * can be used in the Protocols list:
 * ---
 * interface FooService { void foo(); }
 * class FooImpl { override void foo {} }
 *
 * // Provides fast path if TBinaryProtocol!TBufferedTransport is used for
 * // both input and output:
 * alias TServiceProcessor!(FooService, TBinaryProtocol!TBufferedTransport)
 *   BinaryProcessor;
 *
 * auto proc = new BinaryProcessor(new FooImpl());
 *
 * // Low overhead.
 * proc.process(tBinaryProtocol(tBufferTransport(someSocket)));
 *
 * // Not in the specialization list – higher overhead.
 * proc.process(tBinaryProtocol(tFramedTransport(someSocket)));
 *
 * // Same as above, but optimized for the Compact protocol backed by a
 * // TPipedTransport for input and a TBufferedTransport for output.
 * alias TServiceProcessor!(FooService, TProtocolPair!(
 *   TCompactProtocol!TPipedTransport, TCompactProtocol!TBufferedTransport)
 * ) MixedProcessor;
 * ---
 */
template TServiceProcessor(Interface, Protocols...) if (
  isService!Interface && allSatisfy!(isTProtocolOrPair, Protocols)
) {
  mixin({
    static if (is(Interface BaseInterfaces == super) && BaseInterfaces.length > 0) {
      static assert(BaseInterfaces.length == 1,
        "Services cannot be derived from more than one parent.");

      string code = "class TServiceProcessor : " ~
        "TServiceProcessor!(BaseService!Interface) {\n";
      code ~= "private Interface iface_;\n";

      string constructorCode = "this(Interface iface) {\n";
      constructorCode ~= "super(iface);\n";
      constructorCode ~= "iface_ = iface;\n";
    } else {
      string code = "class TServiceProcessor : TProcessor {";
      code ~= q{
        override bool process(TProtocol iprot, TProtocol oprot,
          Variant context = Variant()
        ) {
          auto msg = iprot.readMessageBegin();

          void writeException(TApplicationException e) {
            oprot.writeMessageBegin(TMessage(msg.name, TMessageType.EXCEPTION,
              msg.seqid));
            e.write(oprot);
            oprot.writeMessageEnd();
            oprot.transport.writeEnd();
            oprot.transport.flush();
          }

          if (msg.type != TMessageType.CALL && msg.type != TMessageType.ONEWAY) {
            skip(iprot, TType.STRUCT);
            iprot.readMessageEnd();
            iprot.transport.readEnd();

            writeException(new TApplicationException(
              TApplicationException.Type.INVALID_MESSAGE_TYPE));
            return false;
          }

          auto dg = msg.name in processMap_;
          if (!dg) {
            skip(iprot, TType.STRUCT);
            iprot.readMessageEnd();
            iprot.transport.readEnd();

            writeException(new TApplicationException("Invalid method name: '" ~
              msg.name ~ "'.", TApplicationException.Type.INVALID_MESSAGE_TYPE));

            return false;
          }

          (*dg)(msg.seqid, iprot, oprot, context);
          return true;
        }

        TProcessorEventHandler eventHandler;

        alias void delegate(int, TProtocol, TProtocol, Variant) ProcessFunc;
        protected ProcessFunc[string] processMap_;
        private Interface iface_;
      };

      string constructorCode = "this(Interface iface) {\n";
      constructorCode ~= "iface_ = iface;\n";
    }

    // Generate the handling code for each method, consisting of the dispatch
    // function, registering it in the constructor, and the actual templated
    // handler function.
    foreach (methodName;
      FilterMethodNames!(Interface, __traits(derivedMembers, Interface))
    ) {
      // Register the processing function in the constructor.
      immutable procFuncName = "process_" ~ methodName;
      immutable dispatchFuncName = procFuncName ~ "_protocolDispatch";
      constructorCode ~= "processMap_[`" ~ methodName ~ "`] = &" ~
        dispatchFuncName ~ ";\n";

      bool methodMetaFound;
      TMethodMeta methodMeta;
      static if (is(typeof(Interface.methodMeta) : TMethodMeta[])) {
        enum meta = find!`a.name == b`(Interface.methodMeta, methodName);
        if (!meta.empty) {
          methodMetaFound = true;
          methodMeta = meta.front;
        }
      }

      // The dispatch function to call the specialized handler functions. We
      // test the protocols if they can be converted to one of the passed
      // protocol types, and if not, fall back to the generic TProtocol
      // version of the processing function.
      code ~= "void " ~ dispatchFuncName ~
        "(int seqid, TProtocol iprot, TProtocol oprot, Variant context) {\n";
      code ~= "foreach (Protocol; TypeTuple!(Protocols, TProtocol)) {\n";
      code ~= q{
        static if (is(Protocol _ : TProtocolPair!(I, O), I, O)) {
          alias I IProt;
          alias O OProt;
        } else {
          alias Protocol IProt;
          alias Protocol OProt;
        }
        auto castedIProt = cast(IProt)iprot;
        auto castedOProt = cast(OProt)oprot;
      };
      code ~= "if (castedIProt && castedOProt) {\n";
      code ~= procFuncName ~
        "!(IProt, OProt)(seqid, castedIProt, castedOProt, context);\n";
      code ~= "return;\n";
      code ~= "}\n";
      code ~= "}\n";
      code ~= "throw new TException(`Internal error: Null iprot/oprot " ~
        "passed to processor protocol dispatch function.`);\n";
      code ~= "}\n";

      // The actual handler function, templated on the input and output
      // protocol types.
      code ~= "void " ~ procFuncName ~ "(IProt, OProt)(int seqid, IProt " ~
        "iprot, OProt oprot, Variant connectionContext) " ~
        "if (isTProtocol!IProt && isTProtocol!OProt) {\n";
      code ~= "TArgsStruct!(Interface, `" ~ methodName ~ "`) args;\n";

      // Store the (qualified) method name in a manifest constant to avoid
      // having to litter the code below with lots of string manipulation.
      code ~= "enum methodName = `" ~ methodName ~ "`;\n";

      code ~= q{
        enum qName = Interface.stringof ~ "." ~ methodName;

        Variant callContext;
        if (eventHandler) {
          callContext = eventHandler.createContext(qName, connectionContext);
        }

        scope (exit) {
          if (eventHandler) {
            eventHandler.deleteContext(callContext, qName);
          }
        }

        if (eventHandler) eventHandler.preRead(callContext, qName);

        args.read(iprot);
        iprot.readMessageEnd();
        iprot.transport.readEnd();

        if (eventHandler) eventHandler.postRead(callContext, qName);
      };

      code ~= "TResultStruct!(Interface, `" ~ methodName ~ "`) result;\n";
      code ~= "try {\n";

      // Generate the parameter list to pass to the called iface function.
      string[] paramList;
      foreach (i, _; ParameterTypeTuple!(mixin("Interface." ~ methodName))) {
        string paramName;
        if (methodMetaFound && i < methodMeta.params.length) {
          paramName = methodMeta.params[i].name;
        } else {
          paramName = "param" ~ to!string(i + 1);
        }
        paramList ~= "args." ~ paramName;
      }

      immutable call = "iface_." ~ methodName ~ "(" ~ ctfeJoin(paramList) ~ ")";
      if (is(ReturnType!(mixin("Interface." ~ methodName)) == void)) {
        code ~= call ~ ";\n";
      } else {
        code ~= "result.set!`success`(" ~ call ~ ");\n";
      }

      // If this is not a oneway method, generate the receiving code.
      if (!methodMetaFound || methodMeta.type != TMethodType.ONEWAY) {
        if (methodMetaFound) {
          foreach (e; methodMeta.exceptions) {
            code ~= "} catch (Interface." ~ e.type ~ " " ~ e.name ~ ") {\n";
            code ~= "result.set!`" ~ e.name ~ "`(" ~ e.name ~ ");\n";
          }
        }
        code ~= "}\n";

        code ~= q{
          catch (Exception e) {
            if (eventHandler) {
              eventHandler.handlerError(callContext, qName, e);
            }

            auto x = new TApplicationException(to!string(e));
            oprot.writeMessageBegin(
              TMessage(methodName, TMessageType.EXCEPTION, seqid));
            x.write(oprot);
            oprot.writeMessageEnd();
            oprot.transport.writeEnd();
            oprot.transport.flush();
            return;
          }

          if (eventHandler) eventHandler.preWrite(callContext, qName);

          oprot.writeMessageBegin(TMessage(methodName,
            TMessageType.REPLY, seqid));
          result.write(oprot);
          oprot.writeMessageEnd();
          oprot.transport.writeEnd();
          oprot.transport.flush();

          if (eventHandler) eventHandler.postWrite(callContext, qName);
        };
      } else {
        // For oneway methods, we obviously cannot notify the client of any
        // exceptions, just call the event handler if one is set.
        code ~= "}\n";
        code ~= q{
          catch (Exception e) {
            if (eventHandler) {
              eventHandler.handlerError(callContext, qName, e);
            }
            return;
          }

          if (eventHandler) eventHandler.onewayComplete(callContext, qName);
        };
      }
      code ~= "}\n";

    }

    code ~= constructorCode ~ "}\n";
    code ~= "}\n";

    return code;
  }());
}

/**
 * A struct representing the arguments of a Thrift method call.
 *
 * There should usually be no reason to use this directly without the help of
 * TServiceProcessor, but it is documented publicly to help debugging in case
 * of CTFE errors.
 *
 * Consider this example:
 * ---
 * interface Foo {
 *   int bar(string a, bool b);
 *
 *   enum methodMeta = [
 *     TMethodMeta("bar", [TParamMeta("a", 1), TParamMeta("b", 2)])
 *   ];
 * }
 *
 * alias TArgsStruct!(Foo, "bar") FooBarArgs;
 * ---
 *
 * The definition of FooBarArgs is equivalent to:
 * ---
 * struct FooBarArgs {
 *   string a;
 *   bool b;
 *
 *   mixin TStructHelpers!([TFieldMeta("a", 1, TReq.OPT_IN_REQ_OUT),
 *     TFieldMeta("b", 2, TReq.OPT_IN_REQ_OUT)]);
 * }
 * ---
 *
 * If the TVerboseCodegen version is defined, a warning message is issued at
 * compilation if no TMethodMeta for Interface.methodName is found.
 */
template TArgsStruct(Interface, string methodName) {
  static assert(is(typeof(mixin("Interface." ~ methodName))),
    "Could not find method '" ~ methodName ~ "' in '" ~ Interface.stringof ~ "'.");
  mixin({
    bool methodMetaFound;
    TMethodMeta methodMeta;
    static if (is(typeof(Interface.methodMeta) : TMethodMeta[])) {
      auto meta = find!`a.name == b`(Interface.methodMeta, methodName);
      if (!meta.empty) {
        methodMetaFound = true;
        methodMeta = meta.front;
      }
    }

    string memberCode;
    string[] fieldMetaCodes;
    foreach (i, _; ParameterTypeTuple!(mixin("Interface." ~ methodName))) {
      // If we have no meta information, just use param1, param2, etc. as
      // field names, it shouldn't really matter anyway. 1-based »indexing«
      // is used to match the common scheme in the Thrift world.
      string memberId;
      string memberName;
      if (methodMetaFound && i < methodMeta.params.length) {
        memberId = to!string(methodMeta.params[i].id);
        memberName = methodMeta.params[i].name;
      } else {
        memberId = to!string(i + 1);
        memberName = "param" ~ to!string(i + 1);
      }

      // Unqual!() is needed to generate mutable fields for ref const()
      // struct parameters.
      memberCode ~= "Unqual!(ParameterTypeTuple!(Interface." ~ methodName ~
        ")[" ~ to!string(i) ~ "])" ~ memberName ~ ";\n";

      fieldMetaCodes ~= "TFieldMeta(`" ~ memberName ~ "`, " ~ memberId ~
        ", TReq.OPT_IN_REQ_OUT)";
    }

    string code = "struct TArgsStruct {\n";
    code ~= memberCode;
    version (TVerboseCodegen) {
      if (!methodMetaFound &&
        ParameterTypeTuple!(mixin("Interface." ~ methodName)).length > 0)
      {
        code ~= "pragma(msg, `[thrift.codegen.processor.TArgsStruct] Warning: No " ~
          "meta information for method '" ~ methodName ~ "' in service '" ~
          Interface.stringof ~ "' found.`);\n";
      }
    }
    immutable fieldMetaCode =
      fieldMetaCodes.empty ? "" : "[" ~ ctfeJoin(fieldMetaCodes) ~ "]";
    code ~= "mixin TStructHelpers!(" ~ fieldMetaCode  ~ ");\n";
    code ~= "}\n";
    return code;
  }());
}

/**
 * A struct representing the result of a Thrift method call.
 *
 * It contains a field called "success" for the return value of the function
 * (with id 0), and additional fields for the exceptions declared for the
 * method, if any.
 *
 * There should usually be no reason to use this directly without the help of
 * TServiceProcessor, but it is documented publicly to help debugging in case
 * of CTFE errors.
 *
 * Consider the following example:
 * ---
 * interface Foo {
 *   int bar(string a);
 *
 *   alias .FooException FooException;
 *
 *   enum methodMeta = [
 *     TMethodMeta("bar",
 *       [TParamMeta("a", 1)],
 *       [TExceptionMeta("fooe", 1, "FooException")]
 *     )
 *   ];
 * }
 * alias TResultStruct!(Foo, "bar") FooBarResult;
 * ---
 *
 * The definition of FooBarResult is equivalent to:
 * ---
 * struct FooBarResult {
 *   int success;
 *   FooException fooe;
 *
 *   mixin(TStructHelpers!([TFieldMeta("success", 0, TReq.OPTIONAL),
 *     TFieldMeta("fooe", 1, TReq.OPTIONAL)]));
 * }
 * ---
 *
 * If the TVerboseCodegen version is defined, a warning message is issued at
 * compilation if no TMethodMeta for Interface.methodName is found.
 */
template TResultStruct(Interface, string methodName) {
  static assert(is(typeof(mixin("Interface." ~ methodName))),
    "Could not find method '" ~ methodName ~ "' in '" ~ Interface.stringof ~ "'.");

  mixin({
    string code = "struct TResultStruct {\n";

    string[] fieldMetaCodes;

    static if (!is(ReturnType!(mixin("Interface." ~ methodName)) == void)) {
      code ~= "ReturnType!(Interface." ~ methodName ~ ") success;\n";
      fieldMetaCodes ~= "TFieldMeta(`success`, 0, TReq.OPTIONAL)";
    }

    bool methodMetaFound;
    static if (is(typeof(Interface.methodMeta) : TMethodMeta[])) {
      auto meta = find!`a.name == b`(Interface.methodMeta, methodName);
      if (!meta.empty) {
        foreach (e; meta.front.exceptions) {
          code ~= "Interface." ~ e.type ~ " " ~ e.name ~ ";\n";
          fieldMetaCodes ~= "TFieldMeta(`" ~ e.name ~ "`, " ~ to!string(e.id) ~
            ", TReq.OPTIONAL)";
        }
        methodMetaFound = true;
      }
    }

    version (TVerboseCodegen) {
      if (!methodMetaFound &&
        ParameterTypeTuple!(mixin("Interface." ~ methodName)).length > 0)
      {
        code ~= "pragma(msg, `[thrift.codegen.processor.TResultStruct] Warning: No " ~
          "meta information for method '" ~ methodName ~ "' in service '" ~
          Interface.stringof ~ "' found.`);\n";
      }
    }

    immutable fieldMetaCode =
      fieldMetaCodes.empty ? "" : "[" ~ ctfeJoin(fieldMetaCodes) ~ "]";
    code ~= "mixin TStructHelpers!(" ~ fieldMetaCode  ~ ");\n";
    code ~= "}\n";
    return code;
  }());
}