Cleaned up a bit, added Api Add/Update handling

api.go

@@ -0,0 +1,60 @@
+package main
+
+import(
+	"fmt"
+	"net/http"
+	"encoding/json"
+)
+
+type ApiModifyKeySuccess struct {
+	Key string 		`json:"key"`
+	Status string	`json:"status"`
+	Action string	`json:"action"`
+}
+
+func addKeyHandler(w http.ResponseWriter, r *http.Request) {
+	keyName := r.URL.Path[len("/tyk/key/"):]
+	success := true
+
+	if r.Method == "POST" || r.Method == "PUT" {
+		decoder := json.NewDecoder(r.Body)
+		var newSession SessionState
+		err := decoder.Decode(&newSession)
+
+		if err != nil {
+			log.Error("Couldn't decode new session object")
+			log.Error(err)
+			success = false
+		} else {
+			// Update our session object (create it)
+			authManager.UpdateSession(keyName, newSession)
+		}
+
+		var responseMessage []byte
+		var action string
+		if r.Method == "POST" {
+			action = "added"
+		} else {
+			action = "modified"
+		}
+
+		if success {
+			response := ApiModifyKeySuccess{
+				keyName,
+				"ok",
+				action}
+
+			responseMessage, err = json.Marshal(&response)
+
+			if err != nil {
+				log.Error("Could not create response message")
+				log.Error(err)
+				responseMessage = []byte(systemError)
+			}
+		}
+
+		fmt.Fprintf(w, string(responseMessage))
+	} else {
+		fmt.Fprintf(w, string(systemError))
+	}
+}

gateway.go

@@ -0,0 +1,47 @@
+package main
+
+import(
+	"fmt"
+	"net/http"
+	"net/http/httputil"
+)
+
+type ApiError struct {
+	Message string
+}
+
+func handler(p *httputil.ReverseProxy) func(http.ResponseWriter, *http.Request) {
+	return func(w http.ResponseWriter, r *http.Request) {
+
+		// Check for API key existence
+		authHeaderValue := r.Header.Get("authorisation")
+		if authHeaderValue != "" {
+			// Check if API key valid
+			key_authorised, thisSessionState := authManager.IsKeyAuthorised(authHeaderValue)
+			if key_authorised {
+				// If valid, check if within rate limit
+				forwardMessage := sessionLimiter.ForwardMessage(&thisSessionState)
+				if forwardMessage {
+					success_handler(w, r, p)
+				} else {
+					handle_error(w, r, "Rate limit exceeded", 429)
+				}
+				authManager.UpdateSession(authHeaderValue, thisSessionState)
+			} else {
+				handle_error(w, r, "Key not authorised", 403)
+			}
+		} else {
+			handle_error(w, r, "Authorisation field missing", 400)
+		}
+	}
+}
+
+func success_handler(w http.ResponseWriter, r *http.Request, p *httputil.ReverseProxy) {
+	p.ServeHTTP(w, r)
+}
+
+func handle_error(w http.ResponseWriter, r *http.Request, err string, err_code int) {
+	w.WriteHeader(err_code)
+	thisError := ApiError{fmt.Sprintf("%s", err)}
+	templates.ExecuteTemplate(w, "error.json", &thisError)
+}

main.go

@@ -4,6 +4,7 @@ import(
 	"fmt"
 	"net/url"
 	"net/http"
+	"html/template"
 	"net/http/httputil"
 	"github.com/Sirupsen/logrus"
 	"github.com/docopt/docopt.go"
@@ -24,13 +25,18 @@ var log = logrus.New()
 var authManager = AuthorisationManager{}
 var sessionLimiter = SessionLimiter{}
 var config = Config{}
+var templates = &template.Template{}
+var systemError string = "{\"status\": \"system error, please contact administrator\"}"
 
 func setupGlobals() {
 	if config.Storage.Type == "memory" {
 		authManager = AuthorisationManager{
 			InMemoryStorageManager{
 				map[string]string{}}}
 	}
+
+	template_file := fmt.Sprintf("%s/error.json", config.TemplatePath)
+	templates = template.Must(template.ParseFiles(template_file))
 }
 
 func init() {
@@ -73,13 +79,15 @@ func init() {
 }
 
 func main() {
+	createSampleSession()
 	remote, err := url.Parse(config.TargetUrl)
 	if err != nil {
 		log.Error("Culdn't parse target URL")
 		log.Error(err)
 	}
 
 	proxy := httputil.NewSingleHostReverseProxy(remote)
+	http.HandleFunc("/tyk/key/", addKeyHandler)
 	http.HandleFunc(config.ListenPath, handler(proxy))
 	targetPort := fmt.Sprintf(":%d", config.ListenPort)
 	err = http.ListenAndServe(targetPort, nil)
@@ -88,38 +96,4 @@ func main() {
 	}
 }
 
-func handler(p *httputil.ReverseProxy) func(http.ResponseWriter, *http.Request) {
-	return func(w http.ResponseWriter, r *http.Request) {
-
-		// Check for API key existence
-		authHeaderValue := r.Header.Get("authorisation")
-		if authHeaderValue != "" {
-			// Check if API key valid
-			key_authorised, thisSessionState := authManager.IsKeyAuthorised(authHeaderValue)
-			if key_authorised {
-				// If valid, check if within rate limit
-				forwardMessage := sessionLimiter.ForwardMessage(&thisSessionState)
-				if forwardMessage {
-					success_handler(w, r, p)
-				} else {
-					handle_error(w, r, "Rate limit exceeded", 429)
-				}
-				authManager.UpdateSession(authHeaderValue, thisSessionState)
-			} else {
-				handle_error(w, r, "Key not authorised", 403)
-			}
-		} else {
-			handle_error(w, r, "Authorisation field missing", 400)
-		}
-	}
-}
-
-func success_handler(w http.ResponseWriter, r *http.Request, p *httputil.ReverseProxy) {
-	p.ServeHTTP(w, r)
-}
 
-func handle_error(w http.ResponseWriter, r *http.Request, err string, err_code int) {
-	w.WriteHeader(err_code)
-	// TODO: This should be a template
-	fmt.Fprintf(w, "NOT AUTHORISED: %s", err)
-}

sessions.go

@@ -8,10 +8,10 @@ import (
 
 // SessionState objects represent a current API session, mainly used for rate limiting.
 type SessionState struct {
-	LastCheck int64
-	Allowance float64
-	Rate float64
-	Per float64
+	LastCheck int64		`json:"last_check"`
+	Allowance float64	`json:"allowance"`
+	Rate float64		`json:"rate"`
+	Per float64			`json:"per"`
 }
 
 // SessionLimiter is the rate limiter for the API, use ForwardMessage() to

templates/error.json

@@ -1,3 +1,3 @@
 {
-    "error": {{error_message}}
+    "error": "{{.Message}}"
 }