Initial commit

Author: uakfdotb

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2018 Favyen Bastani
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -0,0 +1,7 @@
+Launch Gogs on LunaNode
+-----------------------
+
+To get started with Gogs on LunaNode, just head to https://launchgogs.lunanode.com
+
+The code for the launcher is in this repository. The launcher will setup a Gogs
+installation with HTTPS. The git SSH port will be on non-standard 10022.

main.go

@@ -0,0 +1,332 @@
+package main
+
+import (
+	"bytes"
+	"crypto/sha512"
+	"crypto/hmac"
+	"encoding/hex"
+	"encoding/json"
+	"fmt"
+	"io/ioutil"
+	"log"
+	"net/http"
+	"net/url"
+	"strconv"
+	"strings"
+	"time"
+)
+
+const IMAGE_ID = 121428
+
+type ErrorResponse struct {
+	Error string `json:"error"`
+}
+
+type GetIPResponse struct {
+	IP string `json:"ip"`
+}
+
+type NullResponse struct {}
+
+type LunaSshkeyAdd struct {
+	KeyID string `json:"key_id"`
+}
+
+type LunaScriptCreate struct {
+	ScriptID string `json:"script_id"`
+}
+
+type LunaNetworkList struct {
+	Networks []struct {
+		NetID string `json:"net_id"`
+	} `json:"networks"`
+}
+
+type LunaFloatingList struct {
+	IPs []struct {
+		IP string `json:"ip"`
+		AttachedType string `json:"attached_type"`
+		Region string `json":region"`
+	} `json:"ips"`
+}
+
+type LunaVmCreate struct {
+	VmID string `json:"vm_id"`
+}
+
+type LunaDynList struct {
+	Dyns map[string]struct{
+		ID string `json:"id"`
+		Name string `json:"name"`
+		IP string `json:"ip"`
+	} `json:"dyns"`
+}
+
+func main() {
+	scriptBytes, err := ioutil.ReadFile("run.sh")
+	if err != nil {
+		panic(err)
+	}
+	script := string(scriptBytes)
+
+	fileServer := http.FileServer(http.Dir("static/"))
+	http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
+		if r.URL.Path == "/" {
+			w.Header().Set("Cache-Control", "no-cache")
+		}
+		fileServer.ServeHTTP(w, r)
+	})
+	http.HandleFunc("/getip", func(w http.ResponseWriter, r *http.Request) {
+		r.ParseForm()
+		apiID := r.PostForm.Get("api_id")
+		apiKey := r.PostForm.Get("api_key")
+		ip, err := getFreeFloatingIP(apiID, apiKey, "toronto")
+		if err != nil {
+			errorResponse(w, r, err.Error())
+			return
+		}
+		if ip == "" {
+			err := request(apiID, apiKey, "floating", "add", map[string]string{
+				"region": "toronto",
+			}, nil)
+			if err != nil {
+				errorResponse(w, r, err.Error())
+				return
+			}
+			ip, _ = getFreeFloatingIP(apiID, apiKey, "toronto")
+			if ip == "" {
+				errorResponse(w, r, "failed to get an external IP")
+				return
+			}
+		}
+		jsonResponse(w, GetIPResponse{ip})
+	})
+
+	http.HandleFunc("/launch", func(w http.ResponseWriter, r *http.Request) {
+		r.ParseForm()
+		apiID := r.PostForm.Get("api_id")
+		apiKey := r.PostForm.Get("api_key")
+		ip := r.PostForm.Get("ip")
+		hostname := r.PostForm.Get("hostname")
+		sshKey := r.PostForm.Get("sshkey")
+		plan := r.PostForm.Get("plan")
+
+		remoteIP := r.RemoteAddr
+
+		myscript := script
+		myscript = strings.Replace(myscript, "[HOSTNAME]", hostname, -1)
+
+		var cleanupFuncs []func()
+		cleanup := func() {
+			for _, f := range cleanupFuncs {
+				f()
+			}
+		}
+
+		// create DNS if desired
+		if strings.HasSuffix(hostname, ".lndyn.com") && strings.HasPrefix(hostname, "gogs") && len(hostname) == 21 {
+			err := request(apiID, apiKey, "dns", "dyn-add", map[string]string{
+				"name": strings.Split(hostname, ".")[0],
+				"ip": ip,
+			}, nil)
+			if err != nil {
+				cleanup()
+				errorResponse(w, r, err.Error())
+				return
+			}
+			cleanupFuncs = append(cleanupFuncs, func() {
+				var response LunaDynList
+				if err := request(apiID, apiKey, "dns", "dyn-list", nil, &response); err != nil {
+					log.Printf("warning: error listing dyns for cleanup: %v", err)
+					return
+				}
+				for _, dyn := range response.Dyns {
+					if dyn.Name == strings.Split(hostname, ".")[0] || dyn.IP == ip {
+						request(apiID, apiKey, "dns", "dyn-remove", map[string]string{"dyn_id": dyn.ID}, nil)
+					}
+				}
+			})
+		}
+
+		params := map[string]string{
+			"region": "toronto",
+			"plan_id": plan,
+			"image_id": strconv.Itoa(IMAGE_ID),
+			"ip": ip,
+			"hostname": hostname,
+		}
+
+		log.Printf("[%s] creating vm", remoteIP)
+
+		// add ssh key, if set
+		if sshKey != "" {
+			var keyResponse LunaSshkeyAdd
+			err := request(apiID, apiKey, "sshkey", "add", map[string]string{
+				"label": "tmp",
+				"sshkey": sshKey,
+			}, &keyResponse)
+			if err != nil {
+				cleanup()
+				errorResponse(w, r, "error adding SSH key: " + err.Error())
+				return
+			}
+			params["key_id"] = keyResponse.KeyID
+			defer func() {
+				request(apiID, apiKey, "sshkey", "remove", map[string]string{
+					"key_id": keyResponse.KeyID,
+				}, nil)
+			}()
+		} else {
+			params["set_password"] = "yes"
+		}
+
+		// add startup script
+		var scriptResponse LunaScriptCreate
+		err = request(apiID, apiKey, "script", "create", map[string]string{
+			"name": "tmp-gogs",
+			"content": myscript,
+		}, &scriptResponse)
+		if err != nil {
+			cleanup()
+			errorResponse(w, r, "error creating startup script: " + err.Error())
+			return
+		}
+		params["scripts"] = scriptResponse.ScriptID
+		defer func() {
+			request(apiID, apiKey, "script", "delete", map[string]string{
+				"script_id": scriptResponse.ScriptID,
+			}, nil)
+		}()
+
+		// should we set network?
+		var networkResponse LunaNetworkList
+		request(apiID, apiKey, "network", "list", map[string]string{
+			"region": "toronto",
+		}, &networkResponse)
+		if len(networkResponse.Networks) >= 1 {
+			params["net_id"] = networkResponse.Networks[0].NetID
+		}
+
+		// create vm
+		var vmResponse LunaVmCreate
+		err = request(apiID, apiKey, "vm", "create", params, &vmResponse)
+		if err != nil {
+			cleanup()
+			errorResponse(w, r, "error creating VM: " + err.Error())
+			return
+		}
+
+		jsonResponse(w, NullResponse{})
+	})
+	log.Fatal(http.ListenAndServe(":8080", nil))
+}
+
+func errorResponse(w http.ResponseWriter, r *http.Request, msg string) {
+	log.Printf("[%s] error: %s", r.RemoteAddr, msg)
+	jsonResponse(w, ErrorResponse{msg})
+}
+
+func jsonResponse(w http.ResponseWriter, x interface{}) {
+	bytes, err := json.Marshal(x)
+	if err != nil {
+		panic(err)
+	}
+	w.Header().Set("Content-Type", "application/json")
+	w.Write(bytes)
+}
+
+const LNDYNAMIC_API_URL = "https://dynamic.lunanode.com/api/{CATEGORY}/{ACTION}/"
+
+func request(apiID string, apiKey string, category string, action string, params map[string]string, target interface{}) error {
+	if len(apiID) != 16 {
+		return fmt.Errorf("API ID should be 16 characters")
+	} else if len(apiKey) != 128 {
+		return fmt.Errorf("API key should be 128 characters")
+	}
+
+	// construct URL
+	targetUrl := LNDYNAMIC_API_URL
+	targetUrl = strings.Replace(targetUrl, "{CATEGORY}", category, -1)
+	targetUrl = strings.Replace(targetUrl, "{ACTION}", action, -1)
+
+	// get raw parameters string
+	if params == nil {
+		params = make(map[string]string)
+	}
+	params["api_id"] = apiID
+	params["api_partialkey"] = apiKey[:64]
+	rawParams, err := json.Marshal(params)
+	if err != nil {
+		return err
+	}
+
+	// HMAC signature with nonce
+	nonce := fmt.Sprintf("%d", time.Now().Unix())
+	handler := fmt.Sprintf("%s/%s/", category, action)
+	hashTarget := fmt.Sprintf("%s|%s|%s", handler, string(rawParams), nonce)
+	hasher := hmac.New(sha512.New, []byte(apiKey))
+	_, err = hasher.Write([]byte(hashTarget))
+	if err != nil {
+		return err
+	}
+	signature := hex.EncodeToString(hasher.Sum(nil))
+
+	// perform request
+	values := url.Values{}
+	values.Set("handler", handler)
+	values.Set("req", string(rawParams))
+	values.Set("signature", signature)
+	values.Set("nonce", nonce)
+	byteBuffer := new(bytes.Buffer)
+	byteBuffer.Write([]byte(values.Encode()))
+	response, err := http.Post(targetUrl, "application/x-www-form-urlencoded", byteBuffer)
+	if err != nil {
+		return err
+	}
+	responseBytes, err := ioutil.ReadAll(response.Body)
+	if err != nil {
+		return err
+	}
+	response.Body.Close()
+
+	// decode JSON
+	// we first decode into generic response for error checking; then into specific response to return
+	var genericResponse struct {
+		Success string `json:"success"`
+		Error   string `json:"error"`
+	}
+
+	err = json.Unmarshal(responseBytes, &genericResponse)
+
+	if err != nil {
+		return err
+	} else if genericResponse.Success != "yes" {
+		if genericResponse.Error != "" {
+			return fmt.Errorf(genericResponse.Error)
+		} else {
+			return fmt.Errorf("backend call failed for unknown reason")
+		}
+	}
+
+	if target != nil {
+		err = json.Unmarshal(responseBytes, target)
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func getFreeFloatingIP(apiID string, apiKey string, region string) (string, error) {
+	var response LunaFloatingList
+	if err := request(apiID, apiKey, "floating", "list", nil, &response); err != nil {
+		return "", err
+	}
+	for _, ip := range response.IPs {
+		if ip.AttachedType == "unattached" && ip.Region == region {
+			return ip.IP, nil
+		}
+	}
+	return "", nil
+}