Add checking to prevent failed deletion of nonexistent droplets and

unnecessary archiving of droplets in images

dospin.json

@@ -8,6 +8,7 @@
 			"Size": "4gb",
 			"Region": "nyc1",
 			"SshKeys": [513314, 1667247],
+			"UsePersistentImage": false,
 			"ImageSlug": "ubuntu-16-04-x64",
 			"Volumes": ["volume-nyc1-01"],
 			"UserData": "#!/bin/bash\napt-get update\napt-get install -y docker.io\nmkdir -p /mnt/volume-nyc1-01\nmount -o discard,defaults /dev/disk/by-id/scsi-0DO_Volume_volume-nyc1-01 /mnt/volume-nyc1-01\necho /dev/disk/by-id/scsi-0DO_Volume_volume-nyc1-01 /mnt/volume-nyc1-01 ext4 defaults,nofail,discard 0 0 | tee -a /etc/fstab\ndocker run -d --restart=always -p 25565:25565 -v /mnt/volume-nyc1-01/minecraft-server:/minecraft-server -w /minecraft-server -t java:8-alpine sh start.sh"

droplethandler.go

@@ -153,8 +153,8 @@ func (me *DropletHandler) Spinup(name string) (string, error) {
 		}
 
 		// delete the image
-		log.Println("Spinup: Deleting image " + name)
+		if image.ID > 0 {
-		if image.ID > -1 {
+			log.Println("Spinup: Deleting image " + name)
 			_, err = me.client.Images.Delete(image.ID)
 			if err != nil {
 				log.Println("Spinup: Could not delete image: ", err)
@@ -182,7 +182,8 @@ func (me *DropletHandler) Spinup(name string) (string, error) {
 func (me *DropletHandler) Spindown(name string) error {
 	droplet, err := me.getDroplet(name)
 	if err != nil {
-		return err
+		// droplet not existing is not an error
+		return nil
 	}
 
 	// power off
@@ -192,12 +193,14 @@ func (me *DropletHandler) Spindown(name string) error {
 	}
 
 	// snapshot existing droplet
-	log.Println("Spindown: Creating image " + name)
+	if me.settings.Servers[name].UsePersistentImage {
-	action, _, err := me.client.DropletActions.Snapshot(droplet.ID, DROPLET_NS+name)
+		log.Println("Spindown: Creating image " + name)
-	if err != nil || !me.actionWait(action.ID) {
+		action, _, err := me.client.DropletActions.Snapshot(droplet.ID, DROPLET_NS+name)
-		return err
+		if err != nil || !me.actionWait(action.ID) {
+			return err
+		}
+		log.Println("Spindown: Created image " + name)
 	}
-	log.Println("Spindown: Created image " + name)
 
 	// delete droplet
 	log.Println("Spindown: Deleting droplet " + name)

net.go

@@ -11,6 +11,7 @@ import (
 	"io"
 	"log"
 	"net"
+	"time"
 )
 
 const (
@@ -28,19 +29,27 @@ func portForward(wanConn *net.TCPConn, lanIp, port string, connStatus chan ConnS
 	log.Print("Proxy: Connecting to ", lanIp+":"+port)
 	lanConn, err := net.Dial("tcp", lanIp+":"+port)
 	if err != nil {
-		log.Print("Proxy: LAN dial error:", err)
+		log.Print("Proxy: LAN dial error: ", err)
 		return
 	}
 
 	go forwardConn(wanConn, lanConn, done)
 	go forwardConn(lanConn, wanConn, done)
 
-	for i := 0; i < 2; i++ {
+	ticker := time.NewTicker(1 * time.Minute)
-		err = <-done
+	for i := 0; i < 2; {
-		if err != nil {
+		select {
-			log.Print("Proxy:", err)
+		case err = <-done:
+			if err != nil {
+				log.Print("Proxy: ", err)
+			}
+			i++
+		case <-ticker.C:
+			connStatus <- ConnStatus{Status: CONN_ACTIVE}
 		}
 	}
+	log.Print("Proxy: ending connection: ", wanConn.LocalAddr().String())
+	ticker.Stop()
 
 	wanConn.Close()
 	lanConn.Close()

servermanager.go

@@ -38,7 +38,6 @@ type ServerManager struct {
 	done              chan interface{}
 	connStatus        chan ConnStatus
 	lastKeepAliveTime time.Time
-	usageScore        int // spin down server when this reaches 0
 	server            ServerHandler
 }
 
@@ -49,8 +48,8 @@ func NewServerManager(name string, server ServerHandler, settings Settings) *Ser
 	sm.ports = settings.Servers[name].Ports
 	sm.in = make(chan serverManagerEvent)
 	sm.done = make(chan interface{})
-	sm.usageScore = 5
 	sm.server = server
+	sm.lastKeepAliveTime = time.Now()
 
 	return sm
 }
@@ -61,8 +60,8 @@ func NewServerManager(name string, server ServerHandler, settings Settings) *Ser
 func (me *ServerManager) Serve() {
 	// TODO: see if server is currently up, and setup port forwarding if so
 
-	fiveMin := time.Duration(5) * time.Minute
+	activityTimeout := time.Duration(5 * time.Minute)
-	ticker := time.NewTicker(fiveMin)
+	ticker := time.NewTicker(activityTimeout)
 
 	// event loop
 	for running := true; running; {
@@ -74,12 +73,15 @@ func (me *ServerManager) Serve() {
 		case action := <-me.in:
 			running = me.serveAction(action)
 		case <-ticker.C:
-			if time.Since(me.lastKeepAliveTime) > fiveMin {
+			if time.Since(me.lastKeepAliveTime) > activityTimeout {
-				me.Spindown()
+				log.Println("ServerManager: Activity timeout for", me.name, " - killing server")
+				running = me.serveAction(serverManagerEvent{eventType: SERVERMANAGER_SPINDOWN})
 			}
 		}
 	}
 
+	ticker.Stop()
+
 	// notify done
 	me.done <- 42
 }
@@ -141,6 +143,7 @@ func (me *ServerManager) serveAction(event serverManagerEvent) bool {
 	switch event.eventType {
 	case SERVERMANAGER_SPINUP:
 		targetIp, err := me.server.Spinup(me.name)
+		me.lastKeepAliveTime = time.Now()
 		if err == nil {
 			log.Println("ServerManager: Got IP for", me.name+":", targetIp)
 			wanAddr := event.tcpConn.LocalAddr().String()

settings.go

@@ -18,15 +18,16 @@ type Settings struct {
 }
 
 type Server struct {
-	Ports       []int
+	Ports              []int
-	UsePublicIP bool
+	UsePublicIP        bool
-	InitialSize string
+	InitialSize        string
-	Size        string
+	Size               string
-	Region      string
+	Region             string
-	ImageSlug   string
+	UsePersistentImage bool
-	UserData    string
+	ImageSlug          string
-	SshKeys     []int
+	UserData           string
-	Volumes     []string
+	SshKeys            []int
+	Volumes            []string
 }
 
 func loadSettings(path string) (Settings, error) {