Adding GitHub actions

.github/workflows/main.yml

@@ -0,0 +1,37 @@
+name: CI
+
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+    branches: [ master ]
+
+jobs:
+
+  build:
+    name: Build
+    runs-on: ubuntu-latest
+    steps:
+
+    - name: Set up Go 1.x
+      uses: actions/setup-go@v2
+      with:
+        go-version: ^1.13
+      id: go
+
+    - name: Check out code into the Go module directory
+      uses: actions/checkout@v2
+
+    - name: Get dependencies
+      run: |
+        go get -v -t -d ./...
+        if [ -f Gopkg.toml ]; then
+            curl https://raw.githubusercontent.com/golang/dep/master/install.sh | sh
+            dep ensure
+        fi
+
+    - name: Build
+      run: go build -v .
+
+    - name: Test
+      run: go test ./test/registryapilayer_test.go ./test/schedulerapilayer_test.go ./test/caching_test.go

Dockerfile

@@ -1,5 +1,5 @@
 FROM alpine
-
+RUN apk add --no-cache tzdata
 COPY ukiyo .
 COPY dbs .
 RUN chmod 777 ./ukiyo

README.md

@@ -2,18 +2,17 @@
 
 ## Idea incubation
 
-- ukiyo will act as a watcher for docker containers. It will run alongside with the other running containers and will be responsible for automatic updates. Updates will be based on push based model compared to existing solutions such as [watchtower](https://github.com/containrrr/watchtower) and [ouroboros](https://github.com/pyouroboros/ouroboros)
+- ukiyo will act as a watcher for docker containers. It will run alongside with the other running containers and will be responsible for automatic updates and schedule the container deployment time. Updates will be based on push based model compared to existing solutions such as [watchtower](https://github.com/containrrr/watchtower) and [ouroboros](https://github.com/pyouroboros/ouroboros)
 
 - Push events will be recived from ukiyo via webhooks. Docker registries provide webhooks to subscribe and listen to image changes. Locally running images will change only after such an event is received by ukiyo.
 
-- Pull based model can be implemented as an optional way of updating the running containers.
+- ukiyo itself runs as a Docker container or else runs as a separate background process a daemon.
 
 ## Components
 
 - Container manager
 - Push manager (webhooks configuration) 
 - Scheduler 
-- OPTIONAL - Pull based update implementation
 
 ## Execution modes
 
@@ -22,14 +21,6 @@ Two modes of execution
 - As a container running alongside other containers (Should mount docker.sock to run docker commands inside the ukiyo docker container)
 - As a standalone executable
 
-## Language
-
-- Go lang
-
-### Go style guide
-
-- https://github.com/rajikaimal/go-styleguide
-
 ## Dev Setup Guide
 
 Setup docker
@@ -47,33 +38,142 @@ $ go build -ldflags="-s -w" -o ukiyo main.go
 
 Docker build command
 ```sh
-$ docker build -f Dockerfile -t agentukiyo/ukiyo .
-$ docker push agentukiyo/ukiyo
-$ docker run -p 8080:8080 \
+$ docker build -f Dockerfile -t agentukiyo/ukiyo:tag .
+$ docker push agentukiyo/ukiyo:tag
+```
+
+The ukiyo-agent is available at https://hub.docker.com/r/agentukiyo/ukiyo
+
+Run ukiyo-agent
+```sh
+$ docker run -d \
+     -p 8080:8080 \
+     -- name ukiyo \
      -v /var/run/docker.sock:/var/run/docker.sock \
-     -v /home/reinventor/dbs:/dbs \
-     agentukiyo/ukiyo
+     -v /home/ukiyo/dbs:/dbs \
+     agentukiyo/ukiyo:tag
 ```
 
 Add webhook to your dockerhub repository
 ```
 http:{serverIP}:8080/ukiyo-web-hook
 ```
+For pull the containers, require the save Docker Hub authentications inside the ukiyo agent. Therefore you need to use curl or postman request to save the Docker keys.
 
 Add your own docker registy details
 ```
-http:{serverIP}:8080/add-container
+http:{serverIP}:8080/save-container-access-keys
 {
-     "username":"agentukiyo",
-     "repoName":"Ukiyo Docker registry",
-     "accessToken":"f44e334e-1440-4166-a16f-d8fc9d0eb188",
-     "email":"[email protected]",
+     "username":"docker registry name"
+     "desc":"docker registry description"
+     "accessToken":"docker registry accesstoken"
+     "email":"your email"
      "serverAddress":"http://docker.io/v1"
 }
+```
+
+```sh
+curl -X POST  \
+-H "Accept: Application/json" \
+-H "Content-Type: application/json" http://{serverIP}:8080/save-container-access-keys \
+-d  '{"username":"docker registry name","desc":"docker registry description",
+"accessToken":"docker registry accesstoken","email":"your email",
+"serverAddress":"http://docker.io/v1"}'
+```
+
+Update your own docker registy details
+```
+http:{serverIP}:8080/edit-container-access-keys
+{
+     "username":"docker registry name"
+     "desc":"edited description"
+     "accessToken":"new docker registry accesstoken"
+     "email":"new email"
+     "serverAddress":"http://docker.io/v1"
+}
+```
+
+```sh
+curl -X POST  \
+-H "Accept: Application/json" \
+-H "Content-Type: application/json" http://{serverIP}:8080/edit-container-access-keys \
+-d  '{"username":"docker registry name","desc":"docker registry description",
+"accessToken":"docker registry accesstoken","email":"your email",
+"serverAddress":"http://docker.io/v1"}'
+```
+
+Delete your docker registy details
+```
+http://{serverIP}:8080/delete-container-access-keys/{registryname}
+```
+
+```sh
+curl -X DELETE  \
+-H "Accept: Application/json" \
+-H "Content-Type: application/json" http://{serverIP}:8080/delete-container-access-keys/{registryname}
+```
+
+Ukiyo will do the deployment in order to configured deployment details. Using save-repository-scheduled-time API you can apply the deployment on the fly or scheduled time
+
+Add your deployment details and set schedule deployment time
+```
+http://{serverIP}:8080/save-repository-scheduled-time
+{
+     "name": "repository name",
+     "bindingPort": 
+     [{
+        "exportPort": "8180",
+        "internalPort": "80"
+      },
+      {
+         "exportPort": "443",
+         "internalPort": "443"
+      }],
+      "scheduledTime": "Aug 17 2020 00:40:50 AM",
+      "scheduledDowntime": false
+}
+```
 
-http:{serverIP}:8080/edit-container-token
+```sh
+curl -X POST  \
+-H "Accept: Application/json" \
+-H "Content-Type: application/json" http://{serverIP}:8080/save-repository-scheduled-time \
+-d  '{"name": "repository name","bindingPort": [{ "exportPort": "8180", "internalPort": "80" }, 
+{ "exportPort": "443", "internalPort": "443" }], 
+"scheduledTime": "Aug 17 2020 00:40:50 AM", "scheduledDowntime": false}'
+```
+
+Change the deployment schedule
+```
+http://{serverIP}:8080/edit-repository-scheduled-time
 {
-     "username":"agentukiyo",
-     "accessToken":"f44e334e-1440-4166-a16f-d8fc9d0eb188"
+     "name": "repository name",
+     "bindingPort": 
+     [{
+        "exportPort": "8180",
+        "internalPort": "80"
+     }],
+     "scheduledTime": "Aug 17 2020 00:40:50 AM",
+     "scheduledDowntime": false
 }
 ```
+
+```sh
+curl -X POST  \
+-H "Accept: Application/json" \
+-H "Content-Type: application/json" http://{serverIP}:8080/edit-repository-scheduled-time \
+-d  '{"name": "repository name","bindingPort": [{ "exportPort": "8180", "internalPort": "80" }, 
+{ "exportPort": "443", "internalPort": "443" }], 
+"scheduledTime": "Aug 17 2020 00:40:50 AM", "scheduledDowntime": true}'
+```
+
+Delete your deployment details
+```
+http://{serverIP}:8080/remove-repository-scheduled-time/{repositoryname}
+```
+
+```sh
+curl -X DELETE  \
+-H "Accept: Application/json" \
+-H "Content-Type: application/json" http://{serverIP}:8080/remove-repository-scheduled-time/{repositoryname}
+```

api/registryapilayer/registryapilayer.go

@@ -0,0 +1,101 @@
+package registryapilayer
+
+import (
+	"encoding/json"
+	"github.com/gin-gonic/gin"
+	"github.com/patrickmn/go-cache"
+	"log"
+	"net/http"
+	"time"
+	"ukiyo/internal/containeraccess"
+	"ukiyo/pkg/jencoder"
+)
+
+type History struct {
+	Time    string
+	Action  string
+	Status  int
+	Comment string
+}
+
+const (
+	_TimeZone = "Asia/Kolkata"
+)
+
+func SaveContainerAccessKeys(r *gin.Engine, cache *cache.Cache) {
+	r.POST("/save-container-access-keys", func(c *gin.Context) {
+		var containerKey containeraccess.ContainerKeys
+		var responseObj containeraccess.ResponseObj
+		c.ShouldBindJSON(&containerKey)
+		log.Println("save-container-access-keys | request : " + jencoder.PrintJson(containerKey))
+
+		if len(containerKey.UserName) > 0 && len(containerKey.AccessToken) > 0 && len(containerKey.ServerAddress) > 0 {
+			res := containeraccess.InsertDockerRegData(containerKey)
+			responseObj = res
+		} else {
+			responseObj.ResponseCode = 1
+			responseObj.ResponseDesc = "Invalid Parameter : save-container key"
+		}
+		log.Println("save-container-access-keys | response : " + jencoder.PrintJson(responseObj))
+		SetHistory(responseObj, cache)
+		c.JSON(http.StatusOK, responseObj)
+	})
+}
+
+func EditContainerAccessKeys(r *gin.Engine, cache *cache.Cache) {
+	r.POST("/edit-container-access-keys", func(c *gin.Context) {
+		var containerKey containeraccess.ContainerKeys
+		var responseObj containeraccess.ResponseObj
+		c.ShouldBindJSON(&containerKey)
+		log.Println("edit-container-access-keys | request : " + jencoder.PrintJson(containerKey))
+
+		if len(containerKey.UserName) > 0 && len(containerKey.AccessToken) > 0 {
+			res := containeraccess.UpdateDockerRegData(containerKey)
+			responseObj = res
+		} else {
+			responseObj.ResponseCode = 1
+			responseObj.ResponseDesc = "Invalid Parameter edit-container key"
+		}
+		log.Println("edit-container-access-keys | response :" + jencoder.PrintJson(responseObj))
+		SetHistory(responseObj, cache)
+		c.JSON(http.StatusOK, responseObj)
+	})
+}
+
+func DeleteContainerAccessKeys(r *gin.Engine, cache *cache.Cache) {
+	r.DELETE("/delete-container-access-keys/:userName", func(c *gin.Context) {
+		var responseObj containeraccess.ResponseObj
+		name := c.Param("userName")
+		log.Println("delete-container-access-keys | request : userName=" + name)
+		if len(name) > 0 {
+			res := containeraccess.DeleteDockerRegData(name)
+			responseObj = res
+		} else {
+			responseObj.ResponseCode = 1
+			responseObj.ResponseDesc = "Invalid Parameter delete-container key"
+		}
+		log.Println("delete-container-access-keys | response : " + jencoder.PrintJson(responseObj))
+		SetHistory(responseObj, cache)
+		c.JSON(http.StatusOK, responseObj)
+	})
+}
+
+func SetHistory(obj containeraccess.ResponseObj, cash *cache.Cache) {
+	var historyArray []History
+	var history History
+	loc, _ := time.LoadLocation(_TimeZone)
+	history.Time = time.Now().In(loc).Format("2006-01-02 15:04:05")
+	history.Status = obj.ResponseCode
+	history.Action = obj.ResponseDesc
+	history.Comment = obj.ResponseDesc
+
+	if x, _, found := cash.GetWithExpiration("history"); found {
+		err := json.Unmarshal(jencoder.PassJson(x), &historyArray)
+		if err != nil {
+			log.Println(err)
+		}
+	}
+
+	historyArray = append(historyArray, history)
+	cash.Set("history", historyArray, 5*time.Minute)
+}