issue#2970, [Go] add go server codeine 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,21 @@
+# Swagger generated server
+
+## 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.  This is an example of building a node.js server.
+
+To see how to make this your own, look here:
+
+[README](https://github.com/swagger-api/swagger-codegen/blob/master/README.md)
+
+### Running the server
+To run the server, follow these simple steps:
+
+```
+
+```
+
+To view the Swagger UI interface:
+
+```
+
+```

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\t%s\t%s\t%s",
+            r.Method,
+            r.RequestURI,
+            name,
+            time.Since(start),
+        )
+    })
+}

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

@@ -0,0 +1,15 @@
+package main
+
+import (
+	sw "./{{apiPath}}"
+    "log"
+    "net/http"
+)
+
+func main() {
+	log.Printf("Server started")
+
+    router := sw.NewRouter()
+    
+    log.Fatal(http.ListenAndServe(":{{serverPort}}", router))
+}

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

@@ -0,0 +1,55 @@
+package {{packageName}}
+
+import (
+	"net/http"
+	"fmt"
+	"github.com/gorilla/mux"
+)
+
+type Route struct {
+	Name        string
+	Method      string
+	Pattern     string
+	HandlerFunc http.HandlerFunc
+}
+
+type Routes []Route
+
+func NewRouter() *mux.Router {
+
+	router := mux.NewRouter().StrictSlash(true)
+	for _, route := range routes {
+		var handler http.Handler
+		handler = route.HandlerFunc
+		handler = Logger(handler, route.Name)
+
+		router.
+			Methods(route.Method).
+			Path(route.Pattern).
+			Name(route.Name).
+			Handler(handler)
+	}
+
+	return router
+}
+
+func Index(w http.ResponseWriter, r *http.Request) {
+	fmt.Fprintf(w, "Hello World!")
+}
+
+var routes = Routes{
+	Route{
+		"Index",
+		"GET",
+		"/",
+		Index,
+	},
+{{#apiInfo}}{{#apis}}{{#operations}}{{#operation}}
+	Route{
+		"{{operationId}}",
+		"{{httpMethod}}",
+		"{{path}}",
+		{{operationId}},
+	},
+{{/operation}}{{/operations}}{{/apis}}{{/apiInfo}}
+}

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

@@ -0,0 +1 @@
+{{{swagger-yaml}}}

modules/swagger-codegen/src/test/java/io/swagger/codegen/options/GoServerOptionsProvider.java

@@ -0,0 +1,30 @@
+package io.swagger.codegen.options;
+
+import io.swagger.codegen.CodegenConstants;
+
+import com.google.common.collect.ImmutableMap;
+
+import java.util.Map;
+
+public class GoServerOptionsProvider implements OptionsProvider {
+    public static final String SORT_PARAMS_VALUE = "false";
+    public static final String ENSURE_UNIQUE_PARAMS_VALUE = "true";
+
+    @Override
+    public String getLanguage() {
+        return "go-server";
+    }
+
+    @Override
+    public Map<String, String> createOptions() {
+        ImmutableMap.Builder<String, String> builder = new ImmutableMap.Builder<String, String>();
+        return builder.put(CodegenConstants.SORT_PARAMS_BY_REQUIRED_FLAG, SORT_PARAMS_VALUE)
+                .put(CodegenConstants.ENSURE_UNIQUE_PARAMS, ENSURE_UNIQUE_PARAMS_VALUE)
+                .build();
+    }
+
+    @Override
+    public boolean isServer() {
+        return true;
+    }
+}

samples/client/petstore/go/go-petstore/.swagger-codegen-ignore

@@ -0,0 +1,23 @@
+# Swagger Codegen Ignore
+# Generated by swagger-codegen https://github.com/swagger-api/swagger-codegen
+
+# Use this file to prevent files from being overwritten by the generator.
+# The patterns follow closely to .gitignore or .dockerignore.
+
+# As an example, the C# client generator defines ApiClient.cs.
+# You can make changes and tell Swagger Codgen to ignore just this file by uncommenting the following line:
+#ApiClient.cs
+
+# You can match any string of characters against a directory, file or extension with a single asterisk (*):
+#foo/*/qux
+# The above matches foo/bar/qux and foo/baz/qux, but not foo/bar/baz/qux
+
+# You can recursively match patterns against a directory, file or extension with a double asterisk (**):
+#foo/**/qux
+# Thsi matches foo/bar/qux, foo/baz/qux, and foo/bar/baz/qux
+
+# You can also negate patterns with an exclamation (!).
+# For example, you can ignore all files in a docs folder with the file extension .md:
+#docs/*.md
+# Then explicitly reverse the ignore rule for a single file:
+#!docs/README.md

samples/client/petstore/go/go-petstore/README.md

@@ -7,7 +7,7 @@ This API client was generated by the [swagger-codegen](https://github.com/swagge
 
 - API version: 1.0.0
 - Package version: 1.0.0
-- Build date: 2016-05-03T10:14:09.589-07:00
+- Build date: 2016-05-26T21:47:25.590-07:00
 - Build package: class io.swagger.codegen.languages.GoClientCodegen
 
 ## Installation

samples/server/petstore/go-api-server/.swagger-codegen-ignore

@@ -0,0 +1,23 @@
+# Swagger Codegen Ignore
+# Generated by swagger-codegen https://github.com/swagger-api/swagger-codegen
+
+# Use this file to prevent files from being overwritten by the generator.
+# The patterns follow closely to .gitignore or .dockerignore.
+
+# As an example, the C# client generator defines ApiClient.cs.
+# You can make changes and tell Swagger Codgen to ignore just this file by uncommenting the following line:
+#ApiClient.cs
+
+# You can match any string of characters against a directory, file or extension with a single asterisk (*):
+#foo/*/qux
+# The above matches foo/bar/qux and foo/baz/qux, but not foo/bar/baz/qux
+
+# You can recursively match patterns against a directory, file or extension with a double asterisk (**):
+#foo/**/qux
+# Thsi matches foo/bar/qux, foo/baz/qux, and foo/bar/baz/qux
+
+# You can also negate patterns with an exclamation (!).
+# For example, you can ignore all files in a docs folder with the file extension .md:
+#docs/*.md
+# Then explicitly reverse the ignore rule for a single file:
+#!docs/README.md

samples/server/petstore/go-api-server/go/README.md

@@ -0,0 +1,21 @@
+# Swagger generated server
+
+## 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.  This is an example of building a node.js server.
+
+To see how to make this your own, look here:
+
+[README](https://github.com/swagger-api/swagger-codegen/blob/master/README.md)
+
+### Running the server
+To run the server, follow these simple steps:
+
+```
+
+```
+
+To view the Swagger UI interface:
+
+```
+
+```

samples/server/petstore/go-api-server/go/app.yaml

@@ -0,0 +1 @@
+application: petstoreserver

samples/server/petstore/go-api-server/go/logger.go

@@ -0,0 +1,23 @@
+package petstoreserver
+
+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\t%s\t%s\t%s",
+            r.Method,
+            r.RequestURI,
+            name,
+            time.Since(start),
+        )
+    })
+}

samples/server/petstore/go-api-server/go/pet.go

@@ -0,0 +1,50 @@
+package petstoreserver
+
+import (
+	"net/http"
+)
+
+type Pet struct {
+
+}
+
+func AddPet(w http.ResponseWriter, r *http.Request) {
+		w.Header().Set("Content-Type", "application/json; charset=UTF-8")
+		w.WriteHeader(http.StatusOK)
+}
+
+func DeletePet(w http.ResponseWriter, r *http.Request) {
+		w.Header().Set("Content-Type", "application/json; charset=UTF-8")
+		w.WriteHeader(http.StatusOK)
+}
+
+func FindPetsByStatus(w http.ResponseWriter, r *http.Request) {
+		w.Header().Set("Content-Type", "application/json; charset=UTF-8")
+		w.WriteHeader(http.StatusOK)
+}
+
+func FindPetsByTags(w http.ResponseWriter, r *http.Request) {
+		w.Header().Set("Content-Type", "application/json; charset=UTF-8")
+		w.WriteHeader(http.StatusOK)
+}
+
+func GetPetById(w http.ResponseWriter, r *http.Request) {
+		w.Header().Set("Content-Type", "application/json; charset=UTF-8")
+		w.WriteHeader(http.StatusOK)
+}
+
+func UpdatePet(w http.ResponseWriter, r *http.Request) {
+		w.Header().Set("Content-Type", "application/json; charset=UTF-8")
+		w.WriteHeader(http.StatusOK)
+}
+
+func UpdatePetWithForm(w http.ResponseWriter, r *http.Request) {
+		w.Header().Set("Content-Type", "application/json; charset=UTF-8")
+		w.WriteHeader(http.StatusOK)
+}
+
+func UploadFile(w http.ResponseWriter, r *http.Request) {
+		w.Header().Set("Content-Type", "application/json; charset=UTF-8")
+		w.WriteHeader(http.StatusOK)
+}
+

samples/server/petstore/go-api-server/go/routers.go

@@ -0,0 +1,188 @@
+package petstoreserver
+
+import (
+	"net/http"
+	"fmt"
+	"github.com/gorilla/mux"
+)
+
+type Route struct {
+	Name        string
+	Method      string
+	Pattern     string
+	HandlerFunc http.HandlerFunc
+}
+
+type Routes []Route
+
+func NewRouter() *mux.Router {
+
+	router := mux.NewRouter().StrictSlash(true)
+	for _, route := range routes {
+		var handler http.Handler
+		handler = route.HandlerFunc
+		handler = Logger(handler, route.Name)
+
+		router.
+			Methods(route.Method).
+			Path(route.Pattern).
+			Name(route.Name).
+			Handler(handler)
+	}
+
+	return router
+}
+
+func Index(w http.ResponseWriter, r *http.Request) {
+	fmt.Fprintf(w, "Hello World!")
+}
+
+var routes = Routes{
+	Route{
+		"Index",
+		"GET",
+		"/",
+		Index,
+	},
+
+	Route{
+		"AddPet",
+		"POST",
+		"/pet",
+		AddPet,
+	},
+
+	Route{
+		"DeletePet",
+		"DELETE",
+		"/pet/{petId}",
+		DeletePet,
+	},
+
+	Route{
+		"FindPetsByStatus",
+		"GET",
+		"/pet/findByStatus",
+		FindPetsByStatus,
+	},
+
+	Route{
+		"FindPetsByTags",
+		"GET",
+		"/pet/findByTags",
+		FindPetsByTags,
+	},
+
+	Route{
+		"GetPetById",
+		"GET",
+		"/pet/{petId}",
+		GetPetById,
+	},
+
+	Route{
+		"UpdatePet",
+		"PUT",
+		"/pet",
+		UpdatePet,
+	},
+
+	Route{
+		"UpdatePetWithForm",
+		"POST",
+		"/pet/{petId}",
+		UpdatePetWithForm,
+	},
+
+	Route{
+		"UploadFile",
+		"POST",
+		"/pet/{petId}/uploadImage",
+		UploadFile,
+	},
+
+	Route{
+		"DeleteOrder",
+		"DELETE",
+		"/store/order/{orderId}",
+		DeleteOrder,
+	},
+
+	Route{
+		"GetInventory",
+		"GET",
+		"/store/inventory",
+		GetInventory,
+	},
+
+	Route{
+		"GetOrderById",
+		"GET",
+		"/store/order/{orderId}",
+		GetOrderById,
+	},
+
+	Route{
+		"PlaceOrder",
+		"POST",
+		"/store/order",
+		PlaceOrder,
+	},
+
+	Route{
+		"CreateUser",
+		"POST",
+		"/user",
+		CreateUser,
+	},
+
+	Route{
+		"CreateUsersWithArrayInput",
+		"POST",
+		"/user/createWithArray",
+		CreateUsersWithArrayInput,
+	},
+
+	Route{
+		"CreateUsersWithListInput",
+		"POST",
+		"/user/createWithList",
+		CreateUsersWithListInput,
+	},
+
+	Route{
+		"DeleteUser",
+		"DELETE",
+		"/user/{username}",
+		DeleteUser,
+	},
+
+	Route{
+		"GetUserByName",
+		"GET",
+		"/user/{username}",
+		GetUserByName,
+	},
+
+	Route{
+		"LoginUser",
+		"GET",
+		"/user/login",
+		LoginUser,
+	},
+
+	Route{
+		"LogoutUser",
+		"GET",
+		"/user/logout",
+		LogoutUser,
+	},
+
+	Route{
+		"UpdateUser",
+		"PUT",
+		"/user/{username}",
+		UpdateUser,
+	},
+
+}

samples/server/petstore/go-api-server/go/store.go

@@ -0,0 +1,30 @@
+package petstoreserver
+
+import (
+	"net/http"
+)
+
+type Store struct {
+
+}
+
+func DeleteOrder(w http.ResponseWriter, r *http.Request) {
+		w.Header().Set("Content-Type", "application/json; charset=UTF-8")
+		w.WriteHeader(http.StatusOK)
+}
+
+func GetInventory(w http.ResponseWriter, r *http.Request) {
+		w.Header().Set("Content-Type", "application/json; charset=UTF-8")
+		w.WriteHeader(http.StatusOK)
+}
+
+func GetOrderById(w http.ResponseWriter, r *http.Request) {
+		w.Header().Set("Content-Type", "application/json; charset=UTF-8")
+		w.WriteHeader(http.StatusOK)
+}
+
+func PlaceOrder(w http.ResponseWriter, r *http.Request) {
+		w.Header().Set("Content-Type", "application/json; charset=UTF-8")
+		w.WriteHeader(http.StatusOK)
+}
+

samples/server/petstore/go-api-server/go/user.go

@@ -0,0 +1,50 @@
+package petstoreserver
+
+import (
+	"net/http"
+)
+
+type User struct {
+
+}
+
+func CreateUser(w http.ResponseWriter, r *http.Request) {
+		w.Header().Set("Content-Type", "application/json; charset=UTF-8")
+		w.WriteHeader(http.StatusOK)
+}
+
+func CreateUsersWithArrayInput(w http.ResponseWriter, r *http.Request) {
+		w.Header().Set("Content-Type", "application/json; charset=UTF-8")
+		w.WriteHeader(http.StatusOK)
+}
+
+func CreateUsersWithListInput(w http.ResponseWriter, r *http.Request) {
+		w.Header().Set("Content-Type", "application/json; charset=UTF-8")
+		w.WriteHeader(http.StatusOK)
+}
+
+func DeleteUser(w http.ResponseWriter, r *http.Request) {
+		w.Header().Set("Content-Type", "application/json; charset=UTF-8")
+		w.WriteHeader(http.StatusOK)
+}
+
+func GetUserByName(w http.ResponseWriter, r *http.Request) {
+		w.Header().Set("Content-Type", "application/json; charset=UTF-8")
+		w.WriteHeader(http.StatusOK)
+}
+
+func LoginUser(w http.ResponseWriter, r *http.Request) {
+		w.Header().Set("Content-Type", "application/json; charset=UTF-8")
+		w.WriteHeader(http.StatusOK)
+}
+
+func LogoutUser(w http.ResponseWriter, r *http.Request) {
+		w.Header().Set("Content-Type", "application/json; charset=UTF-8")
+		w.WriteHeader(http.StatusOK)
+}
+
+func UpdateUser(w http.ResponseWriter, r *http.Request) {
+		w.Header().Set("Content-Type", "application/json; charset=UTF-8")
+		w.WriteHeader(http.StatusOK)
+}
+

samples/server/petstore/go-api-server/main.go

@@ -0,0 +1,15 @@
+package main
+
+import (
+	sw "./go"
+    "log"
+    "net/http"
+)
+
+func main() {
+	log.Printf("Server started")
+
+    router := sw.NewRouter()
+    
+    log.Fatal(http.ListenAndServe(":8080", router))
+}