moved go files back to root

Signed-off-by: Adrien Duermael <adrien@duermael.com>

Author: aduermael

Dockerfile

@@ -9,8 +9,8 @@ RUN curl -sSL -o docker.tgz https://get.docker.com/builds/Linux/x86_64/docker-${
 	ln -s /bin/docker /bin/docker-${DOCKER_VERSION}
 
 # Copy Go code and install applications
-COPY ./go /go/src/dockercraft
-WORKDIR /go/src/dockercraft
+WORKDIR /go/src/github.com/docker/dockercraft
+COPY . .
 RUN go install
 
 # Download Cuberite server (Minecraft C++ server)
@@ -21,6 +21,9 @@ RUN ln -s /srv/cuberite_server/Cuberite /usr/bin/cuberite
 COPY ./world world
 COPY ./docs/img/logo64x64.png logo.png
 
+EXPOSE 25565
+
 COPY ./start.sh start.sh
+
 CMD ["/bin/sh", "/srv/start.sh"]
-EXPOSE 25565
+

go/proxy.go renamed to daemon.go

@@ -16,14 +16,18 @@ import (
 	"github.com/fsouza/go-dockerclient"
 )
 
+// TCPMessage defines what a message that can be
+// sent or received to/from LUA scripts
 type TCPMessage struct {
 	Cmd  string   `json:"cmd,omitempty"`
 	Args []string `json:"args,omitempty"`
 	// Id is used to associate requests & responses
-	Id   int         `json:"id,omitempty"`
+	ID   int         `json:"id,omitempty"`
 	Data interface{} `json:"data,omitempty"`
 }
 
+// StatsOptionsEntry is used to collect stats from
+//mthe Docker daemon
 type StatsOptionsEntry struct {
 	statsOptions docker.StatsOptions
 	// statsOptions can only store the one-way channel
@@ -38,26 +42,15 @@ type StatsOptionsEntry struct {
 // It describes a Docker container event. (start, stop, destroy...)
 type ContainerEvent struct {
 	Action    string `json:"action,omitempty"`
-	Id        string `json:"id,omitempty"`
+	ID        string `json:"id,omitempty"`
 	Name      string `json:"name,omitempty"`
 	ImageRepo string `json:"imageRepo,omitempty"`
 	ImageTag  string `json:"imageTag,omitempty"`
-	Cpu       string `json:"cpu,omitempty"`
-	Ram       string `json:"ram,omitempty"`
+	CPU       string `json:"cpu,omitempty"`
+	RAM       string `json:"ram,omitempty"`
 	Running   bool   `json:"running,omitempty"`
 }
 
-// goproxy main purpose is to be a daemon connecting the docker daemon
-// (remote API) and the custom Minecraft server (cubrite using lua scripts).
-// But the cuberite lua scripts also execute goproxy as a short lived process
-// to send requests to the goproxy daemon. If the program is executed without
-// additional arguments it is the daemon "mode".
-//
-// As a daemon, goproxy listens for events from the docker daemon and send
-// them to the cuberite server. It also listen for requests from the
-// cuberite server, convert them into docker daemon remote API calls and send
-// them to the docker daemon.
-
 // Daemon maintains state when the dockercraft daemon is running
 type Daemon struct {
 	// Client is an instance of the DockerClient
@@ -120,6 +113,8 @@ func (d *Daemon) Init() error {
 	return nil
 }
 
+// Serve exposes a TCP server on port 25566 to handle
+// connections from the LUA scripts
 func (d *Daemon) Serve() {
 
 	tcpAddr, err := net.ResolveTCPAddr("tcp", ":25566")
@@ -139,6 +134,9 @@ func (d *Daemon) Serve() {
 	}
 }
 
+// StartMonitoringEvents listens for events from the
+// Docker daemon and uses callback to transmit them
+// to LUA scripts.
 func (d *Daemon) StartMonitoringEvents() {
 	go func() {
 		err := d.Client.AddEventListener(d.containerEvents)
@@ -257,7 +255,7 @@ func (d *Daemon) eventCallback(event *docker.APIEvents) {
 
 		containerEvent.Action = "createContainer"
 
-		data, err := containerEventToTcpMsg(containerEvent)
+		data, err := containerEventToTCPMsg(containerEvent)
 		if err != nil {
 			log.Println(err)
 			return
@@ -269,15 +267,15 @@ func (d *Daemon) eventCallback(event *docker.APIEvents) {
 
 		containerEvent.Action = "startContainer"
 
-		data, err := containerEventToTcpMsg(containerEvent)
+		data, err := containerEventToTCPMsg(containerEvent)
 		if err != nil {
 			log.Println(err)
 			return
 		}
 
 		d.tcpMessages <- append(data, '\n')
 
-		d.startStatsMonitoring(containerEvent.Id)
+		d.startStatsMonitoring(containerEvent.ID)
 
 	case "stop":
 		// die event is enough
@@ -295,7 +293,7 @@ func (d *Daemon) eventCallback(event *docker.APIEvents) {
 
 		containerEvent.Action = "stopContainer"
 
-		data, err := containerEventToTcpMsg(containerEvent)
+		data, err := containerEventToTCPMsg(containerEvent)
 		if err != nil {
 			log.Println(err)
 			return
@@ -304,21 +302,21 @@ func (d *Daemon) eventCallback(event *docker.APIEvents) {
 		d.tcpMessages <- append(data, '\n')
 
 		d.Lock()
-		statsOptionsEntry, found := d.statsOptionsStore[containerEvent.Id]
+		statsOptionsEntry, found := d.statsOptionsStore[containerEvent.ID]
 		if found {
 			close(statsOptionsEntry.doneChan)
-			delete(d.statsOptionsStore, containerEvent.Id)
+			delete(d.statsOptionsStore, containerEvent.ID)
 		}
 		d.Unlock()
 
 		// enforce 0% display (Cpu & Ram)
-		d.statCallback(containerEvent.Id, nil)
+		d.statCallback(containerEvent.ID, nil)
 
 	case "destroy":
 
 		containerEvent.Action = "destroyContainer"
 
-		data, err := containerEventToTcpMsg(containerEvent)
+		data, err := containerEventToTCPMsg(containerEvent)
 		if err != nil {
 			log.Println(err)
 			return
@@ -331,32 +329,32 @@ func (d *Daemon) eventCallback(event *docker.APIEvents) {
 // the cuberite server
 func (d *Daemon) statCallback(id string, stats *docker.Stats, args ...interface{}) {
 	containerEvent := ContainerEvent{}
-	containerEvent.Id = id
+	containerEvent.ID = id
 	containerEvent.Action = "stats"
 
 	if stats != nil {
 		memPercent := float64(stats.MemoryStats.Usage) / float64(stats.MemoryStats.Limit) * 100.0
-		var cpuPercent float64 = 0.0
+		var cpuPercent float64
 		if preCPUStats, exists := d.previousCPUStats[id]; exists {
 			cpuPercent = calculateCPUPercent(preCPUStats, &stats.CPUStats)
 		}
 
 		d.previousCPUStats[id] = &CPUStats{TotalUsage: stats.CPUStats.CPUUsage.TotalUsage, SystemUsage: stats.CPUStats.SystemCPUUsage}
 
-		containerEvent.Cpu = strconv.FormatFloat(cpuPercent, 'f', 2, 64) + "%"
-		containerEvent.Ram = strconv.FormatFloat(memPercent, 'f', 2, 64) + "%"
+		containerEvent.CPU = strconv.FormatFloat(cpuPercent, 'f', 2, 64) + "%"
+		containerEvent.RAM = strconv.FormatFloat(memPercent, 'f', 2, 64) + "%"
 	} else {
 		// if stats == nil set Cpu and Ram to 0%
 		// it's a way to enforce these values
 		// when stopping a container
-		containerEvent.Cpu = "0.00%"
-		containerEvent.Ram = "0.00%"
+		containerEvent.CPU = "0.00%"
+		containerEvent.RAM = "0.00%"
 	}
 
 	tcpMsg := TCPMessage{}
 	tcpMsg.Cmd = "event"
 	tcpMsg.Args = []string{"containers"}
-	tcpMsg.Id = 0
+	tcpMsg.ID = 0
 	tcpMsg.Data = &containerEvent
 
 	data, err := json.Marshal(&tcpMsg)
@@ -413,7 +411,7 @@ func (d *Daemon) listContainers() {
 			}
 
 			containerEvent := ContainerEvent{}
-			containerEvent.Id = id
+			containerEvent.ID = id
 			containerEvent.Action = "containerInfos"
 			containerEvent.ImageRepo = imageRepo
 			containerEvent.ImageTag = imageTag
@@ -422,7 +420,7 @@ func (d *Daemon) listContainers() {
 			parts := strings.SplitN(container.Status, " ", 2)
 			containerEvent.Running = len(parts) > 0 && parts[0] == "Up"
 
-			data, err := containerEventToTcpMsg(containerEvent)
+			data, err := containerEventToTCPMsg(containerEvent)
 			if err != nil {
 				log.Println(err)
 				return
@@ -432,10 +430,10 @@ func (d *Daemon) listContainers() {
 
 			if containerEvent.Running {
 				// Monitor stats
-				d.startStatsMonitoring(containerEvent.Id)
+				d.startStatsMonitoring(containerEvent.ID)
 			} else {
 				// enforce 0% display (Cpu & Ram)
-				d.statCallback(containerEvent.Id, nil)
+				d.statCallback(containerEvent.ID, nil)
 			}
 		}
 	}()
@@ -529,23 +527,23 @@ func splitRepoAndTag(repoTag string) (string, string) {
 	return repo, tag
 }
 
-func containerEventToTcpMsg(containerEvent ContainerEvent) ([]byte, error) {
+func containerEventToTCPMsg(containerEvent ContainerEvent) ([]byte, error) {
 	tcpMsg := TCPMessage{}
 	tcpMsg.Cmd = "event"
 	tcpMsg.Args = []string{"containers"}
-	tcpMsg.Id = 0
+	tcpMsg.ID = 0
 	tcpMsg.Data = &containerEvent
 	data, err := json.Marshal(&tcpMsg)
 	if err != nil {
-		return nil, errors.New("containerEventToTcpMsg error: " + err.Error())
+		return nil, errors.New("containerEventToTCPMsg error: " + err.Error())
 	}
 	return data, nil
 }
 
 func (d *Daemon) apiEventToContainerEvent(event *docker.APIEvents) (ContainerEvent, error) {
 
 	containerEvent := ContainerEvent{}
-	containerEvent.Id = event.ID
+	containerEvent.ID = event.ID
 
 	// don't try to inspect container in that case, it's already gone!
 	if event.Action == "destroy" {

dockercraft

@@ -6,6 +6,12 @@ import (
 	"os"
 )
 
+// The main purpose of this application is to connect the docker daemon
+// (remote API) and the custom Minecraft server (cubrite using lua scripts).
+// Docker daemons events are transmitted to the LUA script as JSON messages
+// over TCP transport. The cuberite LUA scripts can also contact this
+// application over the same TCP connection.
+
 var debugFlag = flag.Bool("debug", false, "enable debug logging")
 
 func main() {