Mikalai Chakur

Dockerfile

@@ -0,0 +1,15 @@
+FROM ubuntu
+
+EXPOSE 9090
+
+WORKDIR /usr/src/
+
+COPY ./serv/ /usr/src/serv
+
+COPY ./client/ /usr/src/client
+
+COPY ./docker-entrypoint.sh /usr/local/bin
+
+ENTRYPOINT docker-entrypoint.sh
+
+

Makefile

@@ -0,0 +1,55 @@
+################ Preparation ####################
+REGISTRY := nick1chak
+VERSION := $(shell cat VERSION)
+DOCKER_IMAGE_SERV := $(REGISTRY)/redis:$(VERSION)
+DOCKER_IMAGE_CLI := $(REGISTRY)/red_client:$(VERSION)
+
+REPOSITORY_PATH := /usr/src/redis
+SERVER_PATH := serv
+CLIENT_PATH := client
+
+DOCKER_BUILDER := golang:1.11
+DOCKER_RUNNER =  docker run --rm -v $(CURDIR):$(REPOSITORY_PATH)
+DOCKER_RUNNER += -w $(REPOSITORY_PATH)/
+################ End Preparation ####################
+
+
+
+################ Binary Target ####################
+.PHONY: build
+build: build_cli build_serv
+	docker build -t redis:build .
+
+.PHONY: build_cli
+build_cli:
+	$(DOCKER_RUNNER)$(CLIENT_PATH) $(DOCKER_BUILDER) go build
+
+.PHONY: build_serv
+build_serv:
+	$(DOCKER_RUNNER)$(SERVER_PATH) $(DOCKER_BUILDER) go build
+
+############### Docker Target ####################
+.PHONY: run
+run: build
+	docker run -it --name redis_build redis:build
+
+.PHONY: build_check
+build_check:
+	docker build -t redis:checkSR ./$(SERVER_PATH)
+	docker build -t redis:checkCL ./$(CLIENT_PATH)
+################# Testing ####################
+.PHONY: check
+check: build_check
+	docker run --rm --name redis_checkSR redis:checkSR
+	docker run --rm --name redis_checkCL redis:checkCL
+
+.PHONY: test
+test:
+	$(DOCKER_RUNNER)$(SERVER_PATH) $(DOCKER_BUILDER) go test -cover -coverprofile=coverage.out
+
+.PHONY: clean
+clean:
+	docker rm -f  redis_build &>/dev/null
+	docker rmi -f redis:build &>/dev/null
+	docker rmi -f redis:checkSR &>/dev/null
+	docker rmi -f redis:checkCL &>/dev/null

README.md

@@ -0,0 +1,29 @@
+Server-client solution for storing KV data, lightweight analog of the Redis
+
+MAKEFILE:
+
+    build   - Compiles the binaries for server and for client and creates the ready-to-use docker container (use make run)
+    test    - Runs Unit and Integration tests for the server. File coverage.out will apeear in the serv dir
+    check   - Runs subsequently "go vet", "goimports", "golint" on the project. Fails if any errors occur.
+    run     - Starts the server and the client with default configuration (port: 9090, storage: RAM)
+
+serv:
+
+    -p, --port  - The port for listening on (default 9090)
+    -m, --mode  - The possible storage option
+            memory - use RAM ad a storage (default)
+            disk - use disk as a storage
+
+client:
+
+    -p, --port  - The port for listening on (default 9090)
+    -h, --host  - The host to connect to the server (default: 127.0.0.1)
+
+commands:
+
+    SET key value   - updates one key at a time with the given value.
+    GET key           - returns tuple of the value and the key state.
+    DEL key           - removes one key at a time and returns deleted value.
+
+
+

VERSION

@@ -0,0 +1 @@
+0.2

client/Dockerfile

@@ -0,0 +1,17 @@
+FROM golang:1.11
+
+EXPOSE 9090
+
+WORKDIR /usr/src/client
+
+COPY ./ /usr/src/client
+
+COPY ./docker-entrypoint.sh /usr/local/bin
+
+RUN go get -u golang.org/x/lint/golint
+
+RUN go get -u golang.org/x/tools/cmd/goimports
+
+ENTRYPOINT docker-entrypoint.sh
+
+

client/client.go

@@ -0,0 +1,77 @@
+package main
+
+import (
+	"bufio"
+	"errors"
+	"fmt"
+	"log"
+	"net"
+	"os"
+)
+
+//Reading commands from terminal
+func startup() (addr string, err error) {
+	//default values
+    addr = ""
+	host := "127.0.0.1"
+	port := ":9090"
+	err = nil
+
+	args := os.Args
+	for i := 1; i < len(args); i += 2 {
+		switch args[i] {
+		// -p, --port	: set the port for listening on
+		case "-p", "--port":
+			if args[i+1][0] == ':' {
+				port = args[i+1]
+			} else {
+				port = ":" + args[i+1]
+			}
+		// -m, --mode	: enable mirroring data to the drive
+		case "-h", "--host":
+			host = args[i+1]
+		default:
+			err = errors.New("ERROR: Unknown command")
+			return
+		}
+	}
+    addr = host + port
+	return
+}
+
+
+func main() {
+	addr, cmdErr := startup()
+	if cmdErr == nil {
+		conn, netErr := net.Dial("tcp", addr)
+		if netErr != nil {
+			log.Fatalln(netErr)
+		} else {
+			defer conn.Close()
+			fmt.Println("Connected to", addr)
+			for {
+				// read in input from stdin
+				reader := bufio.NewReader(os.Stdin)
+				command, _ := reader.ReadString('\n')
+				fmt.Fprintf(conn, command)
+				/*
+				var message string
+				for {
+					str, err := bufio.NewReader(conn).ReadString('\n')
+					if err != nil {
+						fmt.Print(err)
+						break
+					}
+					message = message + str + "\n"
+				}
+				*/
+				message, _ := bufio.NewReader(conn).ReadString('\r')
+				fmt.Println(string(message))
+			}
+		}
+
+	} else {
+		//Some CMD error
+		fmt.Println(cmdErr)
+	}
+}

client/docker-entrypoint.sh

@@ -0,0 +1,10 @@
+#!/bin/bash
+set -e
+
+
+echo client go vet
+go vet
+echo client golint
+golint
+echo client goimports
+goimports

docker-entrypoint.sh

@@ -0,0 +1,9 @@
+#!/bin/bash
+set -e
+
+echo starting server
+./serv/serv & &>/dev/nul
+echo 'waiting for cli to start'
+sleep 2
+echo starting client
+./client/client

serv/Dockerfile

@@ -0,0 +1,17 @@
+FROM golang:1.11
+
+EXPOSE 9090
+
+WORKDIR /usr/src/serv
+
+COPY ./ /usr/src/serv
+
+COPY ./docker-entrypoint.sh /usr/local/bin
+
+RUN go get -u golang.org/x/lint/golint
+
+RUN go get -u golang.org/x/tools/cmd/goimports
+
+ENTRYPOINT docker-entrypoint.sh
+
+

serv/docker-entrypoint.sh

@@ -0,0 +1,10 @@
+#!/bin/bash
+set -e
+
+
+echo serv go vet
+go vet
+echo serv golint
+golint
+echo serv goimports
+goimports