[Go] add go server codegen template

bin/go-petstore-server.sh

@@ -0,0 +1,31 @@
+#!/bin/sh
+
+SCRIPT="$0"
+
+while [ -h "$SCRIPT" ] ; do
+  ls=`ls -ld "$SCRIPT"`
+  link=`expr "$ls" : '.*-> \(.*\)$'`
+  if expr "$link" : '/.*' > /dev/null; then
+    SCRIPT="$link"
+  else
+    SCRIPT=`dirname "$SCRIPT"`/"$link"
+  fi
+done
+
+if [ ! -d "${APP_DIR}" ]; then
+  APP_DIR=`dirname "$SCRIPT"`/..
+  APP_DIR=`cd "${APP_DIR}"; pwd`
+fi
+
+executable="./modules/swagger-codegen-cli/target/swagger-codegen-cli.jar"
+
+if [ ! -f "$executable" ]
+then
+  mvn clean package
+fi
+
+# if you've executed sbt assembly previously it will use that instead.
+export JAVA_OPTS="${JAVA_OPTS} -XX:MaxPermSize=256M -Xmx1024M -DloggerPath=conf/log4j.properties"
+ags="$@ generate -i modules/swagger-codegen/src/test/resources/2_0/petstore.yaml -l go-server -o samples/server/petstore/go-api-server -DpackageName=petstoreserver "
+
+java $JAVA_OPTS -Dservice -jar $executable $ags

modules/swagger-codegen/src/main/java/io/swagger/codegen/languages/GoServerCodegen.java

@@ -0,0 +1,266 @@
+package io.swagger.codegen.languages;
+
+import com.fasterxml.jackson.core.JsonGenerator;
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.JsonSerializer;
+import com.fasterxml.jackson.databind.SerializerProvider;
+import com.fasterxml.jackson.databind.module.SimpleModule;
+import com.google.common.collect.ArrayListMultimap;
+import com.google.common.collect.Lists;
+import com.google.common.collect.Multimap;
+import io.swagger.codegen.*;
+import io.swagger.models.*;
+import io.swagger.util.Yaml;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.File;
+import java.io.IOException;
+import java.math.BigDecimal;
+import java.util.*;
+import java.util.Map.Entry;
+import org.apache.commons.lang3.StringUtils;
+
+public class GoServerCodegen extends DefaultCodegen implements CodegenConfig {
+
+    private static final Logger LOGGER = LoggerFactory.getLogger(GoServerCodegen.class);
+
+    protected String apiVersion = "1.0.0";
+    protected int serverPort = 8080;
+    protected String projectName = "swagger-server";
+    protected String apiPath = "go";
+
+    public GoServerCodegen() {
+        super();
+
+        // set the output folder here
+        outputFolder = "generated-code/go";
+
+        /**
+         * Models.  You can write model files using the modelTemplateFiles map.
+         * if you want to create one template for file, you can do so here.
+         * for multiple files for model, just put another entry in the `modelTemplateFiles` with
+         * a different extension
+         */
+        modelTemplateFiles.clear();
+
+        /**
+         * Api classes.  You can write classes for each Api file with the apiTemplateFiles map.
+         * as with models, add multiple entries with different extensions for multiple files per
+         * class
+         */
+        apiTemplateFiles.put(
+                "controller.mustache",   // the template to use
+                ".go");       // the extension for each file to write
+
+        /**
+         * Template Location.  This is the location which templates will be read from.  The generator
+         * will use the resource stream to attempt to read the templates.
+         */
+        embeddedTemplateDir = templateDir = "go-server";
+
+        /**
+         * Reserved words.  Override this with reserved words specific to your language
+         */
+        setReservedWordsLowerCase(
+            Arrays.asList(
+                "break", "default", "func", "interface", "select",
+                "case", "defer", "go", "map", "struct",
+                "chan", "else", "goto", "package", "switch",
+                "const", "fallthrough", "if", "range", "type",
+                "continue", "for", "import", "return", "var", "error", "ApiResponse")
+                // Added "error" as it's used so frequently that it may as well be a keyword
+        );
+
+        defaultIncludes = new HashSet<String>(
+                Arrays.asList(
+                    "map",
+                    "array")
+                );
+
+        languageSpecificPrimitives = new HashSet<String>(
+            Arrays.asList(
+                "string",
+                "bool",
+                "uint",
+                "uint32",
+                "uint64",
+                "int",
+                "int32",
+                "int64",
+                "float32",
+                "float64",
+                "complex64",
+                "complex128",
+                "rune",
+                "byte")
+            );
+
+        instantiationTypes.clear();
+        /*instantiationTypes.put("array", "GoArray");
+        instantiationTypes.put("map", "GoMap");*/
+
+        typeMapping.clear();
+        typeMapping.put("integer", "int32");
+        typeMapping.put("long", "int64");
+        typeMapping.put("number", "float32");
+        typeMapping.put("float", "float32");
+        typeMapping.put("double", "float64");
+        typeMapping.put("boolean", "bool");
+        typeMapping.put("string", "string");
+        typeMapping.put("date", "time.Time");
+        typeMapping.put("DateTime", "time.Time");
+        typeMapping.put("password", "string");
+        typeMapping.put("File", "*os.File");
+        typeMapping.put("file", "*os.File");
+        // map binary to string as a workaround
+        // the correct solution is to use []byte
+        typeMapping.put("binary", "string");
+        typeMapping.put("ByteArray", "string");
+
+        importMapping = new HashMap<String, String>();
+        importMapping.put("time.Time", "time");
+        importMapping.put("*os.File", "os");
+        importMapping.put("os", "io/ioutil");
+
+        cliOptions.clear();
+        cliOptions.add(new CliOption(CodegenConstants.PACKAGE_NAME, "Go package name (convention: lowercase).")
+                .defaultValue("swagger"));
+        /**
+         * Additional Properties.  These values can be passed to the templates and
+         * are available in models, apis, and supporting files
+         */
+        additionalProperties.put("apiVersion", apiVersion);
+        additionalProperties.put("serverPort", serverPort);
+        additionalProperties.put("apiPath", apiPath);
+        /**
+         * Supporting Files.  You can write single files for the generator with the
+         * entire object tree available.  If the input file has a suffix of `.mustache
+         * it will be processed by the template engine.  Otherwise, it will be copied
+         */
+        supportingFiles.add(new SupportingFile("swagger.mustache",
+                        "api",
+                        "swagger.yaml")
+        );
+        supportingFiles.add(new SupportingFile("main.mustache", "", "main.go"));
+        supportingFiles.add(new SupportingFile("routers.mustache", apiPath, "routers.go"));
+        supportingFiles.add(new SupportingFile("logger.mustache", apiPath, "logger.go")); 
+        supportingFiles.add(new SupportingFile("app.mustache", apiPath, "app.yaml"));        
+        writeOptional(outputFolder, new SupportingFile("README.mustache", apiPath, "README.md"));
+    }
+
+    @Override
+    public String apiPackage() {
+        return apiPath;
+    }
+
+    /**
+     * Configures the type of generator.
+     *
+     * @return the CodegenType for this generator
+     * @see io.swagger.codegen.CodegenType
+     */
+    @Override
+    public CodegenType getTag() {
+        return CodegenType.SERVER;
+    }
+
+    /**
+     * Configures a friendly name for the generator.  This will be used by the generator
+     * to select the library with the -l flag.
+     *
+     * @return the friendly name for the generator
+     */
+    @Override
+    public String getName() {
+        return "go-server";
+    }
+
+    /**
+     * Returns human-friendly help for the generator.  Provide the consumer with help
+     * tips, parameters here
+     *
+     * @return A string value for the help message
+     */
+    @Override
+    public String getHelp() {
+        return "Generates a Go server library using the swagger-tools project.  By default, " +
+                "it will also generate service classes--which you can disable with the `-Dnoservice` environment variable.";
+    }
+
+    @Override
+    public String toApiName(String name) {
+        if (name.length() == 0) {
+            return "DefaultController";
+        }
+        return initialCaps(name);
+    }
+
+    /**
+     * Escapes a reserved word as defined in the `reservedWords` array. Handle escaping
+     * those terms here.  This logic is only called if a variable matches the reseved words
+     *
+     * @return the escaped term
+     */
+    @Override
+    public String escapeReservedWord(String name) {
+        return "_" + name;  // add an underscore to the name
+    }
+
+    /**
+     * Location to write api files.  You can use the apiPackage() as defined when the class is
+     * instantiated
+     */
+    @Override
+    public String apiFileFolder() {
+        return outputFolder + File.separator + apiPackage().replace('.', File.separatorChar);
+    }
+
+    @Override
+    public String toModelName(String name) {
+        // camelize the model name
+        // phone_number => PhoneNumber
+        return camelize(toModelFilename(name));
+    }
+
+    @Override
+    public String toOperationId(String operationId) {
+        // method name cannot use reserved keyword, e.g. return
+        if (isReservedWord(operationId)) {
+            LOGGER.warn(operationId + " (reserved word) cannot be used as method name. Renamed to " + camelize(sanitizeName("call_" + operationId)));
+            operationId = "call_" + operationId;
+        }
+
+        return camelize(operationId);
+    }
+
+    @Override
+    public String toModelFilename(String name) {
+        if (!StringUtils.isEmpty(modelNamePrefix)) {
+            name = modelNamePrefix + "_" + name;
+        }
+
+        if (!StringUtils.isEmpty(modelNameSuffix)) {
+            name = name + "_" + modelNameSuffix;
+        }
+
+        name = sanitizeName(name);
+
+        // model name cannot use reserved keyword, e.g. return
+        if (isReservedWord(name)) {
+            LOGGER.warn(name + " (reserved word) cannot be used as model name. Renamed to " + camelize("model_" + name));
+            name = "model_" + name; // e.g. return => ModelReturn (after camelize)
+        }
+
+        return underscore(name);
+    }
+
+    @Override
+    public String toApiFilename(String name) {
+        // replace - with _ e.g. created-at => created_at
+        name = name.replaceAll("-", "_"); // FIXME: a parameter should not be assigned. Also declare the methods parameters as 'final'.
+
+        // e.g. PetApi.go => pet_api.go
+        return underscore(name);
+    }
+}

modules/swagger-codegen/src/main/resources/META-INF/services/io.swagger.codegen.CodegenConfig

@@ -46,3 +46,4 @@ io.swagger.codegen.languages.CsharpDotNet2ClientCodegen
 io.swagger.codegen.languages.ClojureClientCodegen
 io.swagger.codegen.languages.HaskellServantCodegen
 io.swagger.codegen.languages.LumenServerCodegen
+io.swagger.codegen.languages.GoServerCodegen

modules/swagger-codegen/src/main/resources/go-server/README.mustache

@@ -0,0 +1,30 @@
+# Go API Server for {{packageName}}
+
+{{#appDescription}}
+{{{appDescription}}}
+{{/appDescription}}
+
+## Overview
+This server was generated by the [swagger-codegen]
+(https://github.com/swagger-api/swagger-codegen) project.  
+By using the [OpenAPI-Spec](https://github.com/OAI/OpenAPI-Specification) from a remote server, you can easily generate a server stub.  
+-
+
+To see how to make this your own, look here:
+
+[README](https://github.com/swagger-api/swagger-codegen/blob/master/README.md)
+
+- API version: {{appVersion}}
+- Build date: {{generatedDate}}
+{{#infoUrl}}
+For more information, please visit [{{{infoUrl}}}]({{{infoUrl}}})
+{{/infoUrl}}
+
+
+### Running the server
+To run the server, follow these simple steps:
+
+```
+go run main.go
+```
+

modules/swagger-codegen/src/main/resources/go-server/app.mustache

@@ -0,0 +1 @@
+application: {{packageName}}

modules/swagger-codegen/src/main/resources/go-server/controller.mustache

@@ -0,0 +1,19 @@
+package {{packageName}}
+
+{{#operations}}
+import (
+	"net/http"
+)
+
+type {{classname}} struct {
+
+}
+
+{{#operation}}
+func {{nickname}}(w http.ResponseWriter, r *http.Request) {
+		w.Header().Set("Content-Type", "application/json; charset=UTF-8")
+		w.WriteHeader(http.StatusOK)
+}
+
+{{/operation}}
+{{/operations}}

modules/swagger-codegen/src/main/resources/go-server/logger.mustache

@@ -0,0 +1,23 @@
+package {{packageName}}
+
+import (
+    "log"
+    "net/http"
+    "time"
+)
+
+func Logger(inner http.Handler, name string) http.Handler {
+    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+        start := time.Now()
+
+        inner.ServeHTTP(w, r)
+
+        log.Printf(
+            "%s %s %s %s",
+            r.Method,
+            r.RequestURI,
+            name,
+            time.Since(start),
+        )
+    })
+}