Merge e041900 into 8cba531

codegen/gateway.go

@@ -36,8 +36,10 @@ import (
 )
 
 const (
-	reqHeaders = "reqHeaderMap"
-	resHeaders = "resHeaderMap"
+	reqHeaders         = "reqHeaderMap"
+	resHeaders         = "resHeaderMap"
+	customWorkflow     = "custom"
+	serverlessWorkflow = "serverless"
 )
 
 var mandatoryEndpointFields = []string{
@@ -255,6 +257,8 @@ type EndpointSpec struct {
 	// RespTransforms, a map from endpoint response fields to client
 	// response fields that should override their values.
 	RespTransforms map[string]FieldMapperEntry `yaml:"-"`
+	// DummyReqTransforms is used to transform a serverless request to response mapping
+	DummyReqTransforms map[string]FieldMapperEntry `yaml:"-"`
 	// ErrTransforms is a map from endpoint exception fields to client exception fields
 	// that should override their values
 	// Note that this feature is not yet fully implemented in the stand-alone Zanzibar codebase
@@ -275,6 +279,8 @@ type EndpointSpec struct {
 	ClientMethod string `yaml:"clientMethod,omitempty"`
 	// The client for this endpoint if httpClient or tchannelClient
 	ClientSpec *ClientSpec `yaml:"-"`
+	// DummyEndpoint checks if the endpoint is serverless
+	IsDummyEndpoint bool `yaml:"-"`
 }
 
 func ensureFields(config map[string]interface{}, mandatoryFields []string, yamlFile string) error {
@@ -346,6 +352,7 @@ func NewEndpointSpec(
 	var workflowImportPath string
 	var clientID string
 	var clientMethod string
+	var isDummyEndpoint bool
 
 	workflowType := endpointConfigObj["workflowType"].(string)
 	if workflowType == "httpClient" || workflowType == "tchannelClient" {
@@ -355,16 +362,19 @@ func NewEndpointSpec(
 				"endpoint config %q must have clientName field", yamlFile,
 			)
 		}
-		clientID = iclientID.(string)
-
+		if iclientID != nil {
+			clientID = iclientID.(string)
+		}
 		iclientMethod, ok := endpointConfigObj["clientMethod"]
 		if !ok {
 			return nil, errors.Errorf(
 				"endpoint config %q must have clientMethod field", yamlFile,
 			)
 		}
-		clientMethod = iclientMethod.(string)
-	} else if workflowType == "custom" {
+		if iclientMethod != nil {
+			clientMethod = iclientMethod.(string)
+		}
+	} else if workflowType == customWorkflow {
 		iworkflowImportPath, ok := endpointConfigObj["workflowImportPath"]
 		if !ok {
 			return nil, errors.Errorf(
@@ -373,6 +383,8 @@ func NewEndpointSpec(
 			)
 		}
 		workflowImportPath = iworkflowImportPath.(string)
+	} else if workflowType == serverlessWorkflow {
+		isDummyEndpoint = true
 	} else {
 		return nil, errors.Errorf(
 			"Invalid workflowType %q for endpoint %q",
@@ -418,6 +430,7 @@ func NewEndpointSpec(
 		ThriftMethodName:   parts[1],
 		WorkflowType:       workflowType,
 		WorkflowImportPath: workflowImportPath,
+		IsDummyEndpoint:    isDummyEndpoint,
 		ClientID:           clientID,
 		ClientMethod:       clientMethod,
 	}
@@ -711,6 +724,14 @@ func augmentEndpointSpec(
 				espec.RespTransforms = resTransforms
 				continue
 			}
+			if name == "transformDummyReq" {
+				dummyResTransforms, err := setTransformMiddleware(middlewareObj)
+				if err != nil {
+					return nil, err
+				}
+				espec.DummyReqTransforms = dummyResTransforms
+				continue
+			}
 			if name == "transformError" {
 				errTransforms, err := setTransformMiddleware(middlewareObj)
 				if err != nil {
@@ -912,10 +933,14 @@ func (e *EndpointSpec) SetDownstream(
 	clientModules []*ClientSpec,
 	h *PackageHelper,
 ) error {
-	if e.WorkflowType == "custom" {
+	if e.WorkflowType == customWorkflow {
 		return nil
 	}
 
+	if e.WorkflowType == serverlessWorkflow {
+		return e.ModuleSpec.SetDownstream(e, h)
+	}
+
 	var clientSpec *ClientSpec
 	for _, v := range clientModules {
 		if v.ClientID == e.ClientID {

codegen/method.go

@@ -137,6 +137,9 @@ type MethodSpec struct {
 	// Statements for converting response types
 	ConvertResponseGoStatements []string
 
+	// Statements for converting Dummy request types
+	ConvertDummyRequestGoStatements []string
+
 	// Statements for propagating headers to client requests
 	PropagateHeadersGoStatements []string
 
@@ -1000,6 +1003,55 @@ func (ms *MethodSpec) setTypeConverters(
 	return nil
 }
 
+func (ms *MethodSpec) setDummyTypeConverters(
+	funcSpec *compile.FunctionSpec,
+	reqTransforms map[string]FieldMapperEntry,
+	headersPropagate map[string]FieldMapperEntry,
+	respTransforms map[string]FieldMapperEntry,
+	dummyReqTransforms map[string]FieldMapperEntry,
+	h *PackageHelper,
+) error {
+
+	dummyConverter := NewTypeConverter(h, nil)
+
+	respType := funcSpec.ResultSpec.ReturnType
+
+	dummyConverter.append(
+		"func convert",
+		PascalCase(ms.Name),
+		"DummyResponse(in ", ms.RequestType, ") ", ms.ResponseType, "{")
+
+	structType := compile.FieldGroup(funcSpec.ArgsSpec)
+
+	switch respType.(type) {
+	case
+		*compile.BoolSpec,
+		*compile.I8Spec,
+		*compile.I16Spec,
+		*compile.I32Spec,
+		*compile.EnumSpec,
+		*compile.I64Spec,
+		*compile.DoubleSpec,
+		*compile.StringSpec:
+
+		dummyConverter.append("out", " := in\t\n")
+	default:
+		// default as struct
+		respFields := respType.(*compile.StructSpec).Fields
+		dummyConverter.append("out", " := ", "&", ms.ShortResponseType, "{}\t\n")
+		err := dummyConverter.GenStructConverter(structType, respFields, dummyReqTransforms)
+		if err != nil {
+			return err
+		}
+
+	}
+
+	dummyConverter.append("\nreturn out \t}")
+	ms.ConvertDummyRequestGoStatements = dummyConverter.GetLines()
+
+	return nil
+}
+
 func getQueryMethodForPrimitiveType(typeSpec compile.TypeSpec) string {
 	var queryMethod string
 

codegen/module_system.go

@@ -44,6 +44,7 @@ type EndpointMeta struct {
 	ClientMethodName       string
 	WorkflowPkg            string
 	ReqHeaders             map[string]*TypedHeader
+	IsDummyEndpoint        bool
 	ReqHeadersKeys         []string
 	ReqRequiredHeadersKeys []string
 	ResHeaders             map[string]*TypedHeader
@@ -1116,15 +1117,15 @@ func (g *EndpointGenerator) generateEndpointFile(
 		PackageName: instance.PackageInfo.GeneratedPackagePath + "/workflow",
 		AliasName:   "workflow",
 	})
-	if e.WorkflowImportPath != "" {
+	if e.WorkflowType == "custom" {
 		includedPackages = append(includedPackages, GoPackageImport{
 			PackageName: e.WorkflowImportPath,
 			AliasName:   "custom" + strings.Title(m.PackageName),
 		})
 	}
 
 	workflowPkg := "workflow"
-	if method.Downstream == nil {
+	if method.Downstream == nil && e.WorkflowType == "custom" {
 		workflowPkg = "custom" + strings.Title(m.PackageName)
 	}
 
@@ -1153,6 +1154,7 @@ func (g *EndpointGenerator) generateEndpointFile(
 		IncludedPackages:       includedPackages,
 		Method:                 method,
 		ReqHeaders:             reqHeaders,
+		IsDummyEndpoint:        e.IsDummyEndpoint,
 		ReqHeadersKeys:         sortedHeaders(reqHeaders, false),
 		ReqRequiredHeadersKeys: sortedHeaders(reqHeaders, true),
 		ResHeadersKeys:         sortedHeaders(e.ResHeaders, false),
@@ -1190,7 +1192,14 @@ func (g *EndpointGenerator) generateEndpointFile(
 
 	out[endpointFilePath] = endpoint
 
-	workflow, err := g.templates.ExecTemplate("workflow.tmpl", meta, g.packageHelper)
+	tmpl := ""
+	if e.IsDummyEndpoint {
+		tmpl = "serverless-workflow.tmpl"
+	} else {
+		tmpl = "workflow.tmpl"
+	}
+
+	workflow, err := g.templates.ExecTemplate(tmpl, meta, g.packageHelper)
 	if err != nil {
 		return nil, errors.Wrap(err, "Error executing workflow template")
 	}

codegen/service.go

@@ -221,9 +221,10 @@ func (ms *ModuleSpec) SetDownstream(
 		clientMethod = e.ClientMethod
 
 		// TODO: move generated middlewares out of zanzibar
-		headersPropagate = e.HeadersPropagate
-		reqTransforms    = e.ReqTransforms
-		respTransforms   = e.RespTransforms
+		headersPropagate   = e.HeadersPropagate
+		reqTransforms      = e.ReqTransforms
+		respTransforms     = e.RespTransforms
+		dummyReqTransforms = e.DummyReqTransforms
 	)
 	for _, v := range ms.Services {
 		if v.Name == serviceName {
@@ -247,6 +248,16 @@ func (ms *ModuleSpec) SetDownstream(
 			"Service %q does not have method %q\n", serviceName, methodName,
 		)
 	}
+
+	if e.IsDummyEndpoint {
+		funcSpec := method.CompiledThriftSpec
+		err := method.setDummyTypeConverters(funcSpec, reqTransforms, headersPropagate, respTransforms, dummyReqTransforms, h)
+		if err != nil {
+			return err
+		}
+		return nil
+	}
+
 	serviceMethod, ok := clientSpec.ExposedMethods[clientMethod]
 	if !ok {
 		return errors.Errorf("Client %q does not expose method %q", clientSpec.ClientName, clientMethod)