На этап сборки docker контейнера возвращено использование репозитория

Обновлены зависимости

.dockerignore

@@ -1,2 +1,5 @@
 # Игнорим данные, т.к. они не нужны для внутреннего содержимого этого контейнера
 data
+
+# Vendor так же не нужен
+vendor

.gitignore

@@ -4,3 +4,6 @@
 # Docker Compose file
 docker-compose.yml
 docker-compose.override.yml
+
+# vendor
+vendor

.gitlab-ci.yml

@@ -0,0 +1,89 @@
+# Предполагается, что между работой "build docker container" и этапом push
+# построенные docker images остаются статичными и никуда не пропадают
+#
+# В противном случае их нужно после каждого этапа билда пушить в registry
+
+stages:
+  - test
+  - build
+  - build_docker_image
+  - push
+  - cleanup
+
+variables:
+  CONTAINER_IMAGE: registry.ely.by/elyby/skinsystem
+
+.golang_template: &setup_go_environment
+  image: golang:1.8.3-stretch
+  before_script:
+    - mkdir -p $GOPATH/src/$CI_PROJECT_NAMESPACE
+    - cp -r $(pwd) $GOPATH/src/$CI_PROJECT_PATH
+    - cd $GOPATH/src/$CI_PROJECT_PATH
+    - go get -u github.com/golang/dep/cmd/dep
+    - $GOPATH/bin/dep ensure
+
+.docker_template: &setup_docker_environment
+  image: docker:latest
+  before_script:
+    - docker login -u gitlab-ci -p $CI_BUILD_TOKEN registry.ely.by
+    - export TEMP_IMAGE_NAME="$CONTAINER_IMAGE:$CI_PIPELINE_ID"
+
+test:
+  <<: *setup_go_environment
+  stage: test
+  script:
+    - ./script/coverage
+
+build executable:
+  <<: *setup_go_environment
+  stage: build
+  script:
+    - env GOOS=linux go build -o $CI_PROJECT_DIR/minecraft-skinsystem main.go
+  artifacts:
+    name: "${CI_JOB_STAGE} executable"
+    paths:
+      - $CI_PROJECT_DIR/minecraft-skinsystem
+    expire_in: 1 day
+
+build docker image:
+  <<: *setup_docker_environment
+  stage: build_docker_image
+  script:
+    - docker build -t $TEMP_IMAGE_NAME .
+  only:
+    - tags
+    - develop
+
+push dev:
+  <<: *setup_docker_environment
+  stage: push
+  variables:
+    GIT_STRATEGY: none
+  script:
+    - export IMAGE_NAME="$CONTAINER_IMAGE:dev"
+    - docker tag $TEMP_IMAGE_NAME $IMAGE_NAME
+    - docker push $IMAGE_NAME
+  only:
+    - develop
+
+push tag:
+  <<: *setup_docker_environment
+  stage: push
+  variables:
+    GIT_STRATEGY: none
+  script:
+    - export IMAGE_NAME="$CONTAINER_IMAGE:$CI_BUILD_TAG"
+    - export LATEST_IMAGE_NAME="$CONTAINER_IMAGE:latest"
+    - docker tag $TEMP_IMAGE_NAME $IMAGE_NAME
+    - docker tag $TEMP_IMAGE_NAME $LATEST_IMAGE_NAME
+    - docker push $IMAGE_NAME
+    - docker push $LATEST_IMAGE_NAME
+  only:
+    - tags
+
+cleanup temp image:
+  <<: *setup_docker_environment
+  stage: cleanup
+  when: always
+  script:
+    - docker rmi $TEMP_IMAGE_NAME || true

Dockerfile

@@ -1,21 +1,6 @@
-FROM golang:1.7-alpine
+FROM scratch
 
-RUN apk add --no-cache git
+COPY ./minecraft-skinsystem /app/
 
-RUN mkdir -p /go/src/elyby/minecraft-skinsystem \
-             /go/src/elyby/minecraft-skinsystem/data/capes \
- && ln -s /go/src/elyby/minecraft-skinsystem /go/src/app
-
-WORKDIR /go/src/app
-
-COPY ./minecraft-skinsystem.go /go/src/app/
-COPY ./lib /go/src/app/lib
-
-RUN go-wrapper download
-RUN go-wrapper install
-
-EXPOSE 80
-
-VOLUME ["/go/src/app"]
-
-CMD ["go-wrapper", "run"]
+ENTRYPOINT ["/app/minecraft-skinsystem"]
+CMD ["serve"]

Dockerfile-dev

@@ -0,0 +1,23 @@
+FROM golang:1.9-alpine
+
+RUN mkdir -p /go/src/elyby/minecraft-skinsystem \
+             /go/src/elyby/minecraft-skinsystem/data/capes \
+ && ln -s /go/src/elyby/minecraft-skinsystem /go/src/app
+
+WORKDIR /go/src/app
+
+COPY ./ /go/src/app/
+
+RUN apk add --no-cache git \
+ && go get -u github.com/golang/dep/cmd/dep \
+ && dep ensure \
+ && go clean -i github.com/golang/dep \
+ && rm -rf $GOPATH/src/github.com/golang/dep \
+ && apk del git \
+ && go build main.go \
+ && mv main /usr/local/bin/minecraft-skinsystem
+
+EXPOSE 80
+
+ENTRYPOINT ["minecraft-skinsystem"]
+CMD ["serve"]

Gopkg.lock

@@ -0,0 +1,171 @@
+# This file is autogenerated, do not edit; changes may be undone by the next 'dep ensure'.
+
+
+[[projects]]
+  name = "github.com/davecgh/go-spew"
+  packages = ["spew"]
+  revision = "346938d642f2ec3594ed81d874461961cd0faa76"
+  version = "v1.1.0"
+
+[[projects]]
+  name = "github.com/fsnotify/fsnotify"
+  packages = ["."]
+  revision = "629574ca2a5df945712d3079857300b5e4da0236"
+  version = "v1.4.2"
+
+[[projects]]
+  name = "github.com/golang/mock"
+  packages = ["gomock"]
+  revision = "13f360950a79f5864a972c786a10a50e44b69541"
+  version = "v1.0.0"
+
+[[projects]]
+  name = "github.com/gorilla/context"
+  packages = ["."]
+  revision = "1ea25387ff6f684839d82767c1733ff4d4d15d0a"
+  version = "v1.1"
+
+[[projects]]
+  name = "github.com/gorilla/mux"
+  packages = ["."]
+  revision = "bcd8bc72b08df0f70df986b97f95590779502d31"
+  version = "v1.4.0"
+
+[[projects]]
+  branch = "master"
+  name = "github.com/hashicorp/hcl"
+  packages = [".","hcl/ast","hcl/parser","hcl/scanner","hcl/strconv","hcl/token","json/parser","json/scanner","json/token"]
+  revision = "392dba7d905ed5d04a5794ba89f558b27e2ba1ca"
+
+[[projects]]
+  name = "github.com/inconshreveable/mousetrap"
+  packages = ["."]
+  revision = "76626ae9c91c4f2a10f34cad8ce83ea42c93bb75"
+  version = "v1.0"
+
+[[projects]]
+  name = "github.com/magiconair/properties"
+  packages = ["."]
+  revision = "be5ece7dd465ab0765a9682137865547526d1dfb"
+  version = "v1.7.3"
+
+[[projects]]
+  branch = "master"
+  name = "github.com/mediocregopher/radix.v2"
+  packages = ["cluster","pool","redis","util"]
+  revision = "ae7309086d191442b36bf69f7f5eeca5fdbd329e"
+
+[[projects]]
+  branch = "master"
+  name = "github.com/mitchellh/mapstructure"
+  packages = ["."]
+  revision = "d0303fe809921458f417bcf828397a65db30a7e4"
+
+[[projects]]
+  branch = "master"
+  name = "github.com/mono83/slf"
+  packages = [".","params","rays","recievers","recievers/ansi","recievers/statsd","wd"]
+  revision = "8188a95c8d6b74c43953abb38b8bd6fdbc412ff5"
+
+[[projects]]
+  branch = "master"
+  name = "github.com/mono83/udpwriter"
+  packages = ["."]
+  revision = "a064bd7e3acfda563ea680b913b9ef24b7a73e15"
+
+[[projects]]
+  name = "github.com/pelletier/go-buffruneio"
+  packages = ["."]
+  revision = "c37440a7cf42ac63b919c752ca73a85067e05992"
+  version = "v0.2.0"
+
+[[projects]]
+  name = "github.com/pelletier/go-toml"
+  packages = ["."]
+  revision = "5ccdfb18c776b740aecaf085c4d9a2779199c279"
+  version = "v1.0.0"
+
+[[projects]]
+  name = "github.com/pmezard/go-difflib"
+  packages = ["difflib"]
+  revision = "792786c7400a136282c1664665ae0a8db921c6c2"
+  version = "v1.0.0"
+
+[[projects]]
+  branch = "master"
+  name = "github.com/spf13/afero"
+  packages = [".","mem"]
+  revision = "9be650865eab0c12963d8753212f4f9c66cdcf12"
+
+[[projects]]
+  name = "github.com/spf13/cast"
+  packages = ["."]
+  revision = "acbeb36b902d72a7a4c18e8f3241075e7ab763e4"
+  version = "v1.1.0"
+
+[[projects]]
+  branch = "master"
+  name = "github.com/spf13/cobra"
+  packages = ["."]
+  revision = "4a7b7e65864c064d48dce82efbbfed2bdc0bf2aa"
+
+[[projects]]
+  branch = "master"
+  name = "github.com/spf13/jwalterweatherman"
+  packages = ["."]
+  revision = "0efa5202c04663c757d84f90f5219c1250baf94f"
+
+[[projects]]
+  name = "github.com/spf13/pflag"
+  packages = ["."]
+  revision = "e57e3eeb33f795204c1ca35f56c44f83227c6e66"
+  version = "v1.0.0"
+
+[[projects]]
+  name = "github.com/spf13/viper"
+  packages = ["."]
+  revision = "25b30aa063fc18e48662b86996252eabdcf2f0c7"
+  version = "v1.0.0"
+
+[[projects]]
+  branch = "master"
+  name = "github.com/streadway/amqp"
+  packages = ["."]
+  revision = "2cbfe40c9341ad63ba23e53013b3ddc7989d801c"
+
+[[projects]]
+  name = "github.com/stretchr/testify"
+  packages = ["assert"]
+  revision = "69483b4bd14f5845b5a1e55bca19e954e827f1d0"
+  version = "v1.1.4"
+
+[[projects]]
+  branch = "master"
+  name = "golang.org/x/sys"
+  packages = ["unix"]
+  revision = "07c182904dbd53199946ba614a412c61d3c548f5"
+
+[[projects]]
+  branch = "master"
+  name = "golang.org/x/text"
+  packages = ["internal/gen","internal/triegen","internal/ucd","transform","unicode/cldr","unicode/norm"]
+  revision = "e56139fd9c5bc7244c76116c68e500765bb6db6b"
+
+[[projects]]
+  name = "gopkg.in/h2non/gock.v1"
+  packages = ["."]
+  revision = "84d599244901620fb3eb96473eb9e50619f69b47"
+  version = "v1.0.6"
+
+[[projects]]
+  branch = "v2"
+  name = "gopkg.in/yaml.v2"
+  packages = ["."]
+  revision = "eb3733d160e74a9c7e442f435eb3bea458e1d19f"
+
+[solve-meta]
+  analyzer-name = "dep"
+  analyzer-version = 1
+  inputs-digest = "75c18193e3b7f0ae90987dc2e69a73c08c4329ab0ea3839112c05d45564d09c3"
+  solver-name = "gps-cdcl"
+  solver-version = 1

Gopkg.toml

@@ -0,0 +1,34 @@
+ignored = ["elyby/minecraft-skinsystem"]
+
+[[constraint]]
+  name = "github.com/gorilla/mux"
+  version = "1.4.0"
+
+[[constraint]]
+  name = "github.com/mediocregopher/radix.v2"
+
+[[constraint]]
+  name = "github.com/mono83/slf"
+
+[[constraint]]
+  name = "github.com/spf13/cobra"
+
+[[constraint]]
+  name = "github.com/spf13/viper"
+
+[[constraint]]
+  name = "github.com/streadway/amqp"
+
+# Testing dependencies
+
+[[constraint]]
+  name = "github.com/stretchr/testify"
+  version = "^1.1.4"
+
+[[constraint]]
+  name = "github.com/golang/mock"
+  version = "^1.0.0"
+
+[[constraint]]
+  name = "gopkg.in/h2non/gock.v1"
+  version = "^1.0.6"

README.md

@@ -36,3 +36,26 @@ docker-compose rm -f app # Удаляем конейтнер
 docker-compose build app # Запускаем билд по новой
 docker-compose up -d app # Поднимаем свежесобранный контейнер обратно
 ```
+
+### Шорткаты для разработки
+
+Потом это надо преобразовать в нормальные доки.
+
+Run Redis:
+
+```sh
+docker run --rm \
+-p 6379:6379 \
+redis:3.0-alpine
+```
+
+Run RabbitMQ:
+
+```sh
+docker run --rm \
+-p 5672:5672 \
+-e RABBITMQ_DEFAULT_USER=ely-skinsystem-app \
+-e RABBITMQ_DEFAULT_PASS=ely-skinsystem-app-password \
+-e RABBITMQ_DEFAULT_VHOST=/ely \
+rabbitmq:3.6
+```

api/accounts/accounts.go

@@ -0,0 +1,166 @@
+package accounts
+
+import (
+	"encoding/json"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"net/http"
+	"net/url"
+	"path"
+	"strings"
+)
+
+type Config struct {
+	Addr   string
+	Id     string
+	Secret string
+	Scopes []string
+
+	Client *http.Client
+}
+
+type Token struct {
+	AccessToken string `json:"access_token"`
+	TokenType   string `json:"token_type"`
+	ExpiresIn   int    `json:"expires_in"`
+	config      *Config
+}
+
+func (config *Config) GetToken() (*Token, error) {
+	form := url.Values{}
+	form.Add("client_id", config.Id)
+	form.Add("client_secret", config.Secret)
+	form.Add("grant_type", "client_credentials")
+	form.Add("scope", strings.Join(config.Scopes, ","))
+
+	response, err := config.getHttpClient().Post(config.getTokenUrl(), "application/x-www-form-urlencoded", strings.NewReader(form.Encode()))
+	if err != nil {
+		return nil, err
+	}
+	defer response.Body.Close()
+
+	var result *Token
+	responseError := handleResponse(response)
+	if responseError != nil {
+		return nil, responseError
+	}
+
+	body, _ := ioutil.ReadAll(response.Body)
+	unmarshalError := json.Unmarshal(body, &result)
+	if unmarshalError != nil {
+		return nil, err
+	}
+
+	result.config = config
+
+	return result, nil
+}
+
+func (config *Config) getTokenUrl() string {
+	return concatenateHostAndPath(config.Addr, "/api/oauth2/v1/token")
+}
+
+func (config *Config) getHttpClient() *http.Client {
+	if config.Client == nil {
+		config.Client = &http.Client{}
+	}
+
+	return config.Client
+}
+
+type AccountInfoResponse struct {
+	Id       int    `json:"id"`
+	Uuid     string `json:"uuid"`
+	Username string `json:"username"`
+	Email    string `json:"email"`
+}
+
+func (token *Token) AccountInfo(attribute string, value string) (*AccountInfoResponse, error) {
+	request := token.newRequest("GET", token.accountInfoUrl(), nil)
+
+	query := request.URL.Query()
+	query.Add(attribute, value)
+	request.URL.RawQuery = query.Encode()
+
+	response, err := token.config.Client.Do(request)
+	if err != nil {
+		return nil, err
+	}
+	defer response.Body.Close()
+
+	var info *AccountInfoResponse
+
+	responseError := handleResponse(response)
+	if responseError != nil {
+		return nil, responseError
+	}
+
+	body, _ := ioutil.ReadAll(response.Body)
+	json.Unmarshal(body, &info)
+
+	return info, nil
+}
+
+func (token *Token) accountInfoUrl() string {
+	return concatenateHostAndPath(token.config.Addr, "/api/internal/accounts/info")
+}
+
+func (token *Token) newRequest(method string, urlStr string, body io.Reader) *http.Request {
+	request, err := http.NewRequest(method, urlStr, body)
+	if err != nil {
+		panic(err)
+	}
+
+	request.Header.Add("Authorization", "Bearer " + token.AccessToken)
+
+	return request
+}
+
+func concatenateHostAndPath(host string, pathToJoin string) string {
+	u, _ := url.Parse(host)
+	u.Path = path.Join(u.Path, pathToJoin)
+
+	return u.String()
+}
+
+type UnauthorizedResponse struct {}
+
+func (err UnauthorizedResponse) Error() string {
+	return "Unauthorized response"
+}
+
+type ForbiddenResponse struct {}
+
+func (err ForbiddenResponse) Error() string {
+	return "Forbidden response"
+}
+
+type NotFoundResponse struct {}
+
+func (err NotFoundResponse) Error() string {
+	return "Not found"
+}
+
+type NotSuccessResponse struct {
+	StatusCode int
+}
+
+func (err NotSuccessResponse) Error() string {
+	return fmt.Sprintf("Response code is \"%d\"", err.StatusCode)
+}
+
+func handleResponse(response *http.Response) error {
+	switch status := response.StatusCode; status {
+	case 200:
+		return nil
+	case 401:
+		return &UnauthorizedResponse{}
+	case 403:
+		return &ForbiddenResponse{}
+	case 404:
+		return &NotFoundResponse{}
+	default:
+		return &NotSuccessResponse{status}
+	}
+}

api/accounts/accounts_test.go

@@ -0,0 +1,98 @@
+package accounts
+
+import (
+	"net/http"
+	"strings"
+	"testing"
+
+	testify "github.com/stretchr/testify/assert"
+	"gopkg.in/h2non/gock.v1"
+)
+
+func TestConfig_GetToken(t *testing.T) {
+	assert := testify.New(t)
+
+	defer gock.Off()
+	gock.New("https://account.ely.by").
+		Post("/api/oauth2/v1/token").
+		Body(strings.NewReader("client_id=mock-id&client_secret=mock-secret&grant_type=client_credentials&scope=scope1%2Cscope2")).
+		Reply(200).
+		JSON(map[string]interface{}{
+			"access_token": "mocked-token",
+			"token_type": "Bearer",
+			"expires_in": 86400,
+		})
+
+	client := &http.Client{}
+	gock.InterceptClient(client)
+
+	config := &Config{
+		Addr: "https://account.ely.by",
+		Id: "mock-id",
+		Secret: "mock-secret",
+		Scopes: []string{"scope1", "scope2"},
+		Client: client,
+	}
+
+	result, err := config.GetToken()
+	if assert.NoError(err) {
+		assert.Equal("mocked-token", result.AccessToken)
+		assert.Equal("Bearer", result.TokenType)
+		assert.Equal(86400, result.ExpiresIn)
+	}
+}
+
+func TestToken_AccountInfo(t *testing.T) {
+	assert := testify.New(t)
+
+	defer gock.Off()
+	// To test valid behavior
+	gock.New("https://account.ely.by").
+		Get("/api/internal/accounts/info").
+		MatchParam("id", "1").
+		MatchHeader("Authorization", "Bearer mock-token").
+		Reply(200).
+		JSON(map[string]interface{}{
+			"id": 1,
+			"uuid": "0f657aa8-bfbe-415d-b700-5750090d3af3",
+			"username": "dummy",
+			"email": "dummy@ely.by",
+		})
+
+	// To test behavior on invalid or expired token
+	gock.New("https://account.ely.by").
+		Get("/api/internal/accounts/info").
+		MatchParam("id", "1").
+		MatchHeader("Authorization", "Bearer mock-token").
+		Reply(401).
+		JSON(map[string]interface{}{
+			"name": "Unauthorized",
+			"message": "Incorrect token",
+			"code": 0,
+			"status": 401,
+		})
+
+	client := &http.Client{}
+	gock.InterceptClient(client)
+
+	token := &Token{
+		AccessToken: "mock-token",
+		config: &Config{
+			Addr: "https://account.ely.by",
+			Client: client,
+		},
+	}
+
+	result, err := token.AccountInfo("id", "1")
+	if assert.NoError(err) {
+		assert.Equal(1, result.Id)
+		assert.Equal("0f657aa8-bfbe-415d-b700-5750090d3af3", result.Uuid)
+		assert.Equal("dummy", result.Username)
+		assert.Equal("dummy@ely.by", result.Email)
+	}
+
+	result2, err2 := token.AccountInfo("id", "1")
+	assert.Nil(result2)
+	assert.Error(err2)
+	assert.IsType(&UnauthorizedResponse{}, err2)
+}

api/accounts/auto-refresh-token.go

@@ -0,0 +1,56 @@
+package accounts
+
+type AutoRefresh struct {
+	token 		 *Token
+	config 		 *Config
+	repeatsCount int
+}
+
+const repeatsLimit = 3
+
+func (config *Config) GetTokenWithAutoRefresh() *AutoRefresh {
+	return &AutoRefresh{
+		config: config,
+	}
+}
+
+func (refresher *AutoRefresh) AccountInfo(attribute string, value string) (*AccountInfoResponse, error) {
+	defer refresher.resetRepeatsCount()
+
+	apiToken, err := refresher.getToken()
+	if err != nil {
+		return nil, err
+	}
+
+	result, err := apiToken.AccountInfo(attribute, value)
+	if err != nil {
+		_, isTokenExpire := err.(*UnauthorizedResponse)
+		if !isTokenExpire || refresher.repeatsCount >= repeatsLimit - 1 {
+			return nil, err
+		}
+
+		refresher.repeatsCount++
+		refresher.token = nil
+
+		return refresher.AccountInfo(attribute, value)
+	}
+
+	return result, nil
+}
+
+func (refresher *AutoRefresh) getToken() (*Token, error) {
+	if refresher.token == nil {
+		newToken, err := refresher.config.GetToken()
+		if err != nil {
+			return nil, err
+		}
+
+		refresher.token = newToken
+	}
+
+	return refresher.token, nil
+}
+
+func (refresher *AutoRefresh) resetRepeatsCount() {
+	refresher.repeatsCount = 0
+}

api/accounts/auto-refresh-token_test.go

@@ -0,0 +1,242 @@
+package accounts
+
+import (
+	"net/http"
+	"strings"
+	"testing"
+
+	testify "github.com/stretchr/testify/assert"
+	"gopkg.in/h2non/gock.v1"
+)
+
+var config = &Config{
+	Addr: "https://account.ely.by",
+	Id: "mock-id",
+	Secret: "mock-secret",
+	Scopes: []string{"scope1", "scope2"},
+}
+
+func TestConfig_GetTokenWithAutoRefresh(t *testing.T) {
+	assert := testify.New(t)
+
+	testConfig := &Config{}
+	*testConfig = *config
+
+	result := testConfig.GetTokenWithAutoRefresh()
+	assert.Equal(testConfig, result.config)
+}
+
+func TestAutoRefresh_AccountInfo(t *testing.T) {
+	assert := testify.New(t)
+
+	defer gock.Off()
+	gock.New("https://account.ely.by").
+		Post("/api/oauth2/v1/token").
+		Body(strings.NewReader("client_id=mock-id&client_secret=mock-secret&grant_type=client_credentials&scope=scope1%2Cscope2")).
+		Reply(200).
+		JSON(map[string]interface{}{
+			"access_token": "mocked-token",
+			"token_type": "Bearer",
+			"expires_in": 86400,
+		})
+
+	gock.New("https://account.ely.by").
+		Get("/api/internal/accounts/info").
+		Times(2).
+		MatchParam("id", "1").
+		MatchHeader("Authorization", "Bearer mocked-token").
+		Reply(200).
+		JSON(map[string]interface{}{
+			"id": 1,
+			"uuid": "0f657aa8-bfbe-415d-b700-5750090d3af3",
+			"username": "dummy",
+			"email": "dummy@ely.by",
+		})
+
+	client := &http.Client{}
+	gock.InterceptClient(client)
+
+	testConfig := &Config{}
+	*testConfig = *config
+	testConfig.Client = client
+
+	autoRefresher := testConfig.GetTokenWithAutoRefresh()
+	result, err := autoRefresher.AccountInfo("id", "1")
+	if assert.NoError(err) {
+		assert.Equal(1, result.Id)
+		assert.Equal("0f657aa8-bfbe-415d-b700-5750090d3af3", result.Uuid)
+		assert.Equal("dummy", result.Username)
+		assert.Equal("dummy@ely.by", result.Email)
+	}
+
+	result2, err2 := autoRefresher.AccountInfo("id", "1")
+	if assert.NoError(err2) {
+		assert.Equal(result, result2, "Results should still be same without token refreshing")
+	}
+}
+
+func TestAutoRefresh_AccountInfo2(t *testing.T) {
+	assert := testify.New(t)
+
+	defer gock.Off()
+	gock.New("https://account.ely.by").
+		Post("/api/oauth2/v1/token").
+		Body(strings.NewReader("client_id=mock-id&client_secret=mock-secret&grant_type=client_credentials&scope=scope1%2Cscope2")).
+		Reply(200).
+		JSON(map[string]interface{}{
+			"access_token": "mocked-token-1",
+			"token_type": "Bearer",
+			"expires_in": 86400,
+		})
+
+	gock.New("https://account.ely.by").
+		Get("/api/internal/accounts/info").
+		MatchParam("id", "1").
+		MatchHeader("Authorization", "Bearer mocked-token-1").
+		Reply(200).
+		JSON(map[string]interface{}{
+			"id": 1,
+			"uuid": "0f657aa8-bfbe-415d-b700-5750090d3af3",
+			"username": "dummy",
+			"email": "dummy@ely.by",
+		})
+
+	gock.New("https://account.ely.by").
+		Get("/api/internal/accounts/info").
+		MatchParam("id", "1").
+		MatchHeader("Authorization", "Bearer mocked-token-1").
+		Reply(401).
+		JSON(map[string]interface{}{
+			"name": "Unauthorized",
+			"message": "Incorrect token",
+			"code": 0,
+			"status": 401,
+		})
+
+	gock.New("https://account.ely.by").
+		Post("/api/oauth2/v1/token").
+		Body(strings.NewReader("client_id=mock-id&client_secret=mock-secret&grant_type=client_credentials&scope=scope1%2Cscope2")).
+		Reply(200).
+		JSON(map[string]interface{}{
+			"access_token": "mocked-token-2",
+			"token_type": "Bearer",
+			"expires_in": 86400,
+		})
+
+	gock.New("https://account.ely.by").
+		Get("/api/internal/accounts/info").
+		MatchParam("id", "1").
+		MatchHeader("Authorization", "Bearer mocked-token-2").
+		Reply(200).
+		JSON(map[string]interface{}{
+			"id": 1,
+			"uuid": "0f657aa8-bfbe-415d-b700-5750090d3af3",
+			"username": "dummy",
+			"email": "dummy@ely.by",
+		})
+
+	client := &http.Client{}
+	gock.InterceptClient(client)
+
+	testConfig := &Config{}
+	*testConfig = *config
+	testConfig.Client = client
+
+	autoRefresher := testConfig.GetTokenWithAutoRefresh()
+	result, err := autoRefresher.AccountInfo("id", "1")
+	if assert.NoError(err) {
+		assert.Equal(1, result.Id)
+		assert.Equal("0f657aa8-bfbe-415d-b700-5750090d3af3", result.Uuid)
+		assert.Equal("dummy", result.Username)
+		assert.Equal("dummy@ely.by", result.Email)
+	}
+
+	result2, err2 := autoRefresher.AccountInfo("id", "1")
+	if assert.NoError(err2) {
+		assert.Equal(result, result2, "Results should still be same with refreshed token")
+	}
+}
+
+func TestAutoRefresh_AccountInfo3(t *testing.T) {
+	assert := testify.New(t)
+
+	defer gock.Off()
+	gock.New("https://account.ely.by").
+		Post("/api/oauth2/v1/token").
+		Body(strings.NewReader("client_id=mock-id&client_secret=mock-secret&grant_type=client_credentials&scope=scope1%2Cscope2")).
+		Reply(200).
+		JSON(map[string]interface{}{
+			"access_token": "mocked-token-1",
+			"token_type": "Bearer",
+			"expires_in": 86400,
+		})
+
+	gock.New("https://account.ely.by").
+		Get("/api/internal/accounts/info").
+		MatchParam("id", "1").
+		MatchHeader("Authorization", "Bearer mocked-token-1").
+		Reply(404).
+		JSON(map[string]interface{}{
+			"name": "Not Found",
+			"message": "Page not found.",
+			"code": 0,
+			"status": 404,
+		})
+
+	client := &http.Client{}
+	gock.InterceptClient(client)
+
+	testConfig := &Config{}
+	*testConfig = *config
+	testConfig.Client = client
+
+	autoRefresher := testConfig.GetTokenWithAutoRefresh()
+	result, err := autoRefresher.AccountInfo("id", "1")
+	assert.Nil(result)
+	assert.Error(err)
+	assert.IsType(&NotFoundResponse{}, err)
+}
+
+func TestAutoRefresh_AccountInfo4(t *testing.T) {
+	assert := testify.New(t)
+
+	defer gock.Off()
+	gock.New("https://account.ely.by").
+		Post("/api/oauth2/v1/token").
+		Times(3).
+		Body(strings.NewReader("client_id=mock-id&client_secret=mock-secret&grant_type=client_credentials&scope=scope1%2Cscope2")).
+		Reply(200).
+		JSON(map[string]interface{}{
+			"access_token": "mocked-token-1",
+			"token_type": "Bearer",
+			"expires_in": 86400,
+		})
+
+	gock.New("https://account.ely.by").
+		Get("/api/internal/accounts/info").
+		Times(3).
+		MatchParam("id", "1").
+		MatchHeader("Authorization", "Bearer mocked-token-1").
+		Reply(401).
+		JSON(map[string]interface{}{
+			"name": "Unauthorized",
+			"message": "Incorrect token",
+			"code": 0,
+			"status": 401,
+		})
+
+	client := &http.Client{}
+	gock.InterceptClient(client)
+
+	testConfig := &Config{}
+	*testConfig = *config
+	testConfig.Client = client
+
+	autoRefresher := testConfig.GetTokenWithAutoRefresh()
+	result, err := autoRefresher.AccountInfo("id", "1")
+	assert.Nil(result)
+	assert.Error(err)
+	if !assert.IsType(&UnauthorizedResponse{}, err) {
+		t.Fatal(err)
+	}
+}

bootstrap/bootstrap.go

@@ -0,0 +1,64 @@
+package bootstrap
+
+import (
+	"fmt"
+	"net/url"
+	"os"
+
+	"github.com/mono83/slf/rays"
+	"github.com/mono83/slf/recievers/ansi"
+	"github.com/mono83/slf/recievers/statsd"
+	"github.com/mono83/slf/wd"
+	"github.com/streadway/amqp"
+)
+
+func CreateLogger(statsdAddr string) (wd.Watchdog, error) {
+	wd.AddReceiver(ansi.New(true, true, false))
+	if statsdAddr != "" {
+		hostname, _ := os.Hostname()
+		statsdReceiver, err := statsd.NewReceiver(statsd.Config{
+			Address: statsdAddr,
+			Prefix: "ely.skinsystem." + hostname + ".app.",
+			FlushEvery: 1,
+		})
+
+		if err != nil {
+			return nil, err
+		}
+
+		wd.AddReceiver(statsdReceiver)
+	}
+
+	return wd.New("", "").WithParams(rays.Host), nil
+}
+
+type RabbitMQConfig struct {
+	Username string
+	Password string
+	Host string
+	Port int
+	Vhost string
+}
+
+func CreateRabbitMQChannel(config *RabbitMQConfig) (*amqp.Channel, error) {
+	addr := fmt.Sprintf(
+		"amqp://%s:%s@%s:%d/%s",
+		config.Username,
+		config.Password,
+		config.Host,
+		config.Port,
+		url.PathEscape(config.Vhost),
+	)
+
+	rabbitConnection, err := amqp.Dial(addr)
+	if err != nil {
+		return nil, err
+	}
+
+	rabbitChannel, err := rabbitConnection.Channel()
+	if err != nil {
+		return nil, err
+	}
+
+	return rabbitChannel, nil
+}

cmd/amqpWorker.go

@@ -0,0 +1,72 @@
+package cmd
+
+import (
+	"fmt"
+	"log"
+
+	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
+
+	"elyby/minecraft-skinsystem/api/accounts"
+	"elyby/minecraft-skinsystem/bootstrap"
+	"elyby/minecraft-skinsystem/db"
+	"elyby/minecraft-skinsystem/worker"
+)
+
+var amqpWorkerCmd = &cobra.Command{
+	Use:   "amqp-worker",
+	Short: "Launches a worker which listens to events and processes them",
+	Run: func(cmd *cobra.Command, args []string) {
+		logger, err := bootstrap.CreateLogger(viper.GetString("statsd.addr"))
+		if err != nil {
+			log.Fatal(fmt.Printf("Cannot initialize logger: %v", err))
+		}
+		logger.Info("Logger successfully initialized")
+
+		storageFactory := db.StorageFactory{Config: viper.GetViper()}
+
+		logger.Info("Initializing skins repository")
+		skinsRepo, err := storageFactory.CreateFactory("redis").CreateSkinsRepository()
+		if err != nil {
+			logger.Emergency(fmt.Sprintf("Error on creating skins repo: %+v", err))
+			return
+		}
+		logger.Info("Skins repository successfully initialized")
+
+		logger.Info("Initializing AMQP connection")
+		amqpChannel, err := bootstrap.CreateRabbitMQChannel(&bootstrap.RabbitMQConfig{
+			Host:     viper.GetString("amqp.host"),
+			Port:     viper.GetInt("amqp.port"),
+			Username: viper.GetString("amqp.username"),
+			Password: viper.GetString("amqp.password"),
+			Vhost:    viper.GetString("amqp.vhost"),
+		})
+		if err != nil {
+			logger.Emergency(fmt.Sprintf("Error on connecting AMQP: %+v", err))
+			return
+		}
+		logger.Info("AMQP connection successfully initialized")
+
+		accountsApi := (&accounts.Config{
+			Addr:   viper.GetString("api.accounts.host"),
+			Id:     viper.GetString("api.accounts.id"),
+			Secret: viper.GetString("api.accounts.secret"),
+			Scopes: viper.GetStringSlice("api.accounts.scopes"),
+		}).GetTokenWithAutoRefresh()
+
+		services := &worker.Services{
+			Logger:      logger,
+			Channel:     amqpChannel,
+			SkinsRepo:   skinsRepo,
+			AccountsAPI: accountsApi,
+		}
+
+		if err := services.Run(); err != nil {
+			logger.Error(fmt.Sprintf("Cannot initialize worker: %+v", err))
+		}
+	},
+}
+
+func init() {
+	RootCmd.AddCommand(amqpWorkerCmd)
+}

cmd/root.go

@@ -0,0 +1,42 @@
+package cmd
+
+import (
+	"fmt"
+	"os"
+
+	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
+)
+
+var cfgFile string
+
+var RootCmd = &cobra.Command{
+	Use:   "",
+	Short: "Nothing here",
+}
+
+// Execute adds all child commands to the root command and sets flags appropriately.
+// This is called by main.main(). It only needs to happen once to the rootCmd.
+func Execute() {
+	if err := RootCmd.Execute(); err != nil {
+		fmt.Println(err)
+		os.Exit(1)
+	}
+}
+
+func init() { 
+	cobra.OnInitialize(initConfig)
+	RootCmd.PersistentFlags().StringVar(&cfgFile, "config", "", "config file (default is $HOME/.test.yaml)")
+}
+
+func initConfig() {
+	if cfgFile != "" {
+		viper.SetConfigFile(cfgFile)
+	}
+
+	viper.AutomaticEnv()
+
+	if err := viper.ReadInConfig(); err == nil {
+		fmt.Println("Using config file:", viper.ConfigFileUsed())
+	}
+}

cmd/serve.go

@@ -0,0 +1,58 @@
+package cmd
+
+import (
+	"fmt"
+	"log"
+
+	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
+
+	"elyby/minecraft-skinsystem/bootstrap"
+	"elyby/minecraft-skinsystem/db"
+	"elyby/minecraft-skinsystem/http"
+)
+
+var serveCmd = &cobra.Command{
+	Use:   "serve",
+	Short: "Runs the system server skins",
+	Run: func(cmd *cobra.Command, args []string) {
+		logger, err := bootstrap.CreateLogger(viper.GetString("statsd.addr"))
+		if err != nil {
+			log.Fatal(fmt.Printf("Cannot initialize logger: %v", err))
+		}
+		logger.Info("Logger successfully initialized")
+
+		storageFactory := db.StorageFactory{Config: viper.GetViper()}
+
+		logger.Info("Initializing skins repository")
+		skinsRepo, err := storageFactory.CreateFactory("redis").CreateSkinsRepository()
+		if err != nil {
+			logger.Emergency(fmt.Sprintf("Error on creating skins repo: %+v", err))
+			return
+		}
+		logger.Info("Skins repository successfully initialized")
+
+		logger.Info("Initializing capes repository")
+		capesRepo, err := storageFactory.CreateFactory("filesystem").CreateCapesRepository()
+		if err != nil {
+			logger.Emergency(fmt.Sprintf("Error on creating capes repo: %v", err))
+			return
+		}
+		logger.Info("Capes repository successfully initialized")
+
+		cfg := &http.Config{
+			ListenSpec: fmt.Sprintf("%s:%d", viper.GetString("server.host"), viper.GetInt("server.port")),
+			SkinsRepo: skinsRepo,
+			CapesRepo: capesRepo,
+			Logger: logger,
+		}
+
+		if err := cfg.Run(); err != nil {
+			logger.Error(fmt.Sprintf("Error in main(): %v", err))
+		}
+	},
+}
+
+func init() {
+	RootCmd.AddCommand(serveCmd)
+}

data/statsd/.gitignore

@@ -0,0 +1,2 @@
+*
+!.gitignore

db/commons.go

@@ -0,0 +1,25 @@
+package db
+
+type ParamRequired struct {
+	Param string
+}
+
+func (e ParamRequired) Error() string {
+	return "Required parameter not provided"
+}
+
+type SkinNotFoundError struct {
+	Who string
+}
+
+func (e SkinNotFoundError) Error() string {
+	return "Skin data not found."
+}
+
+type CapeNotFoundError struct {
+	Who string
+}
+
+func (e CapeNotFoundError) Error() string {
+	return "Cape file not found."
+}

db/factory.go

@@ -0,0 +1,34 @@
+package db
+
+import (
+	"github.com/spf13/viper"
+
+	"elyby/minecraft-skinsystem/interfaces"
+)
+
+type StorageFactory struct {
+	Config *viper.Viper
+}
+
+type RepositoriesCreator interface {
+	CreateSkinsRepository() (interfaces.SkinsRepository, error)
+	CreateCapesRepository() (interfaces.CapesRepository, error)
+}
+
+func (factory *StorageFactory) CreateFactory(backend string) RepositoriesCreator {
+	switch backend {
+	case "redis":
+		return &RedisFactory{
+			Host:     factory.Config.GetString("storage.redis.host"),
+			Port:     factory.Config.GetInt("storage.redis.port"),
+			PoolSize: factory.Config.GetInt("storage.redis.poolSize"),
+		}
+	case "filesystem":
+		return &FilesystemFactory{
+			BasePath    : factory.Config.GetString("storage.filesystem.basePath"),
+			CapesDirName: factory.Config.GetString("storage.filesystem.capesDirName"),
+		}
+	}
+
+	return nil
+}

db/filesystem.go

@@ -0,0 +1,59 @@
+package db
+
+import (
+	"os"
+	"path"
+	"strings"
+
+	"elyby/minecraft-skinsystem/interfaces"
+	"elyby/minecraft-skinsystem/model"
+)
+
+type FilesystemFactory struct {
+	BasePath 	 string
+	CapesDirName string
+}
+
+func (f FilesystemFactory) CreateSkinsRepository() (interfaces.SkinsRepository, error) {
+	panic("skins repository not supported for this storage type")
+}
+
+func (f FilesystemFactory) CreateCapesRepository() (interfaces.CapesRepository, error) {
+	if err := f.validateFactoryConfig(); err != nil {
+		return nil, err
+	}
+
+	return &filesStorage{path: path.Join(f.BasePath, f.CapesDirName)}, nil
+}
+
+func (f FilesystemFactory) validateFactoryConfig() error {
+	if f.BasePath == "" {
+		return &ParamRequired{"basePath"}
+	}
+
+	if f.CapesDirName == "" {
+		f.CapesDirName = "capes"
+	}
+
+	return nil
+}
+
+type filesStorage struct {
+	path string
+}
+
+func (repository *filesStorage) FindByUsername(username string) (*model.Cape, error) {
+	if username == "" {
+		return nil, &CapeNotFoundError{username}
+	}
+
+	capePath := path.Join(repository.path, strings.ToLower(username) + ".png")
+	file, err := os.Open(capePath)
+	if err != nil {
+		return nil, &CapeNotFoundError{username}
+	}
+
+	return &model.Cape{
+		File: file,
+	}, nil
+}

db/redis.go

@@ -0,0 +1,198 @@
+package db
+
+import (
+	"bytes"
+	"compress/zlib"
+	"encoding/json"
+	"fmt"
+	"io"
+	"log"
+	"strings"
+	"time"
+
+	"github.com/mediocregopher/radix.v2/pool"
+	"github.com/mediocregopher/radix.v2/redis"
+	"github.com/mediocregopher/radix.v2/util"
+
+	"elyby/minecraft-skinsystem/interfaces"
+	"elyby/minecraft-skinsystem/model"
+)
+
+type RedisFactory struct {
+	Host       string
+	Port       int
+	PoolSize   int
+	connection util.Cmder
+}
+
+func (f RedisFactory) CreateSkinsRepository() (interfaces.SkinsRepository, error) {
+	connection, err := f.getConnection()
+	if err != nil {
+		return nil, err
+	}
+
+	return &redisDb{connection}, nil
+}
+
+func (f RedisFactory) CreateCapesRepository() (interfaces.CapesRepository, error) {
+	panic("capes repository not supported for this storage type")
+}
+
+func (f RedisFactory) getConnection() (util.Cmder, error) {
+	if f.connection == nil {
+		if f.Host == "" {
+			return nil, &ParamRequired{"host"}
+		}
+
+		if f.Port == 0 {
+			return nil, &ParamRequired{"port"}
+		}
+
+		addr := fmt.Sprintf("%s:%d", f.Host, f.Port)
+		conn, err := createConnection(addr, f.PoolSize)
+		if err != nil {
+			return nil, err
+		}
+
+		f.connection = conn
+
+		go func() {
+			period := 5
+			for {
+				time.Sleep(time.Duration(period) * time.Second)
+				resp := f.connection.Cmd("PING")
+				if resp.Err == nil {
+					continue
+				}
+
+				log.Println("Redis not pinged. Try to reconnect")
+				conn, err := createConnection(addr, f.PoolSize)
+				if err != nil {
+					log.Printf("Cannot reconnect to redis: %v\n", err)
+					log.Printf("Waiting %d seconds to retry\n", period)
+					continue
+				}
+
+				f.connection = conn
+				log.Println("Reconnected")
+			}
+		}()
+	}
+
+	return f.connection, nil
+}
+
+func createConnection(addr string, poolSize int) (util.Cmder, error) {
+	if poolSize > 1 {
+		return pool.New("tcp", addr, poolSize)
+	} else {
+		return redis.Dial("tcp", addr)
+	}
+}
+
+type redisDb struct {
+	conn util.Cmder
+}
+
+const accountIdToUsernameKey string = "hash:username-to-account-id"
+
+func (db *redisDb) FindByUsername(username string) (*model.Skin, error) {
+	if username == "" {
+		return nil, &SkinNotFoundError{username}
+	}
+
+	redisKey := buildKey(username)
+	response := db.conn.Cmd("GET", redisKey)
+	if response.IsType(redis.Nil) {
+		return nil, &SkinNotFoundError{username}
+	}
+
+	encodedResult, err := response.Bytes()
+	if err != nil {
+		return nil, err
+	}
+
+	result, err := zlibDecode(encodedResult)
+	if err != nil {
+		log.Println("Cannot uncompress zlib for key " + redisKey) // TODO: replace with valid error
+		return nil, err
+	}
+
+	var skin *model.Skin
+	err = json.Unmarshal(result, &skin)
+	if err != nil {
+		log.Println("Cannot decode record data for key" + redisKey) // TODO: replace with valid error
+		return nil, nil
+	}
+
+	skin.OldUsername = skin.Username
+
+	return skin, nil
+}
+
+func (db *redisDb) FindByUserId(id int) (*model.Skin, error) {
+	response := db.conn.Cmd("HGET", accountIdToUsernameKey, id)
+	if response.IsType(redis.Nil) {
+		return nil, SkinNotFoundError{"unknown"}
+	}
+
+	username, _ := response.Str()
+
+	return db.FindByUsername(username)
+}
+
+func (db *redisDb) Save(skin *model.Skin) error {
+	conn := db.conn
+	if poolConn, isPool := conn.(*pool.Pool); isPool {
+		conn, _ = poolConn.Get()
+	}
+
+	conn.Cmd("MULTI")
+
+	// Если пользователь сменил ник, то мы должны удать его ключ
+	if skin.OldUsername != "" && skin.OldUsername != skin.Username {
+		conn.Cmd("DEL", buildKey(skin.OldUsername))
+	}
+
+	// Если это новая запись или если пользователь сменил ник, то обновляем значение в хэш-таблице
+	if skin.OldUsername != "" || skin.OldUsername != skin.Username {
+		conn.Cmd("HSET", accountIdToUsernameKey, skin.UserId, skin.Username)
+	}
+
+	str, _ := json.Marshal(skin)
+	conn.Cmd("SET", buildKey(skin.Username), zlibEncode(str))
+
+	conn.Cmd("EXEC")
+
+	skin.OldUsername = skin.Username
+
+	return nil
+}
+
+func buildKey(username string) string {
+	return "username:" + strings.ToLower(username)
+}
+
+//noinspection GoUnusedFunction
+func zlibEncode(str []byte) []byte {
+	var buff bytes.Buffer
+	writer := zlib.NewWriter(&buff)
+	writer.Write(str)
+	writer.Close()
+
+	return buff.Bytes()
+}
+
+func zlibDecode(bts []byte) ([]byte, error) {
+	buff := bytes.NewReader(bts)
+	reader, readError := zlib.NewReader(buff)
+	if readError != nil {
+		return nil, readError
+	}
+
+	resultBuffer := new(bytes.Buffer)
+	io.Copy(resultBuffer, reader)
+	reader.Close()
+
+	return resultBuffer.Bytes(), nil
+}

docker-compose.base.yml

@@ -1,7 +1,7 @@
 version: '2'
 services:
     redis:
-        image: redis:3.0-alpine
+        image: redis:3.2-32bit
         volumes:
             - ./data/redis:/data
 
@@ -11,3 +11,10 @@ services:
             RABBITMQ_DEFAULT_USER: "ely-skinsystem-app"
             RABBITMQ_DEFAULT_PASS: "ely-skinsystem-app-password"
             RABBITMQ_DEFAULT_VHOST: "/ely"
+
+    statsd:
+        image: hopsoft/graphite-statsd
+        volumes:
+            - ./data/statsd:/opt/graphite/storage
+            - ./data/graphite-config:/opt/graphite/conf
+            - ./data/statsd-config/config.json:/opt/statsd/config.js

docker-compose.dev.yml

@@ -11,6 +11,11 @@ services:
         links:
             - redis
             - rabbitmq
+            - statsd
+        environment:
+            ACCOUNTS_API_ID: ""
+            ACCOUNTS_API_SECRET: ""
+            STATSD_ADDR: ""
 
     redis:
         extends:
@@ -21,3 +26,10 @@ services:
         extends:
             file: docker-compose.base.yml
             service: rabbitmq
+
+    statsd:
+        extends:
+            file: docker-compose.base.yml
+            service: statsd
+        ports:
+            - "8123:80"

docker-compose.prod.yml

@@ -8,6 +8,10 @@ services:
             - redis
             - rabbitmq
         restart: always
+        environment:
+            ACCOUNTS_API_ID: ""
+            ACCOUNTS_API_SECRET: ""
+            STATSD_ADDR: ""
 
     redis:
         extends:

http/cape.go

@@ -0,0 +1,38 @@
+package http
+
+import (
+	"io"
+	"net/http"
+
+	"github.com/gorilla/mux"
+)
+
+func (cfg *Config) Cape(response http.ResponseWriter, request *http.Request) {
+	if mux.Vars(request)["converted"] == "" {
+		cfg.Logger.IncCounter("capes.request", 1)
+	}
+
+	username := parseUsername(mux.Vars(request)["username"])
+	rec, err := cfg.CapesRepo.FindByUsername(username)
+	if err != nil {
+		http.Redirect(response, request, "http://skins.minecraft.net/MinecraftCloaks/" + username + ".png", 301)
+		return
+	}
+
+	request.Header.Set("Content-Type", "image/png")
+	io.Copy(response, rec.File)
+}
+
+func (cfg *Config) CapeGET(response http.ResponseWriter, request *http.Request) {
+	cfg.Logger.IncCounter("capes.get_request", 1)
+	username := request.URL.Query().Get("name")
+	if username == "" {
+		response.WriteHeader(http.StatusBadRequest)
+		return
+	}
+
+	mux.Vars(request)["username"] = username
+	mux.Vars(request)["converted"] = "1"
+
+	cfg.Cape(response, request)
+}

http/cape_test.go

@@ -0,0 +1,138 @@
+package http
+
+import (
+	"bytes"
+	"image"
+	"image/png"
+	"io/ioutil"
+	"net/http/httptest"
+	"testing"
+
+	"github.com/golang/mock/gomock"
+	testify "github.com/stretchr/testify/assert"
+
+	"elyby/minecraft-skinsystem/db"
+	"elyby/minecraft-skinsystem/model"
+)
+
+func TestConfig_Cape(t *testing.T) {
+	assert := testify.New(t)
+
+	ctrl := gomock.NewController(t)
+	defer ctrl.Finish()
+
+	config, _, capesRepo, wd := setupMocks(ctrl)
+
+	cape := createCape()
+
+	capesRepo.EXPECT().FindByUsername("mocked_username").Return(&model.Cape{
+		File: bytes.NewReader(cape),
+	}, nil)
+	wd.EXPECT().IncCounter("capes.request", int64(1))
+
+	req := httptest.NewRequest("GET", "http://skinsystem.ely.by/cloaks/mocked_username", nil)
+	w := httptest.NewRecorder()
+
+	config.CreateHandler().ServeHTTP(w, req)
+
+	resp := w.Result()
+	assert.Equal(200, resp.StatusCode)
+	responseData, _ := ioutil.ReadAll(resp.Body)
+	assert.Equal(cape, responseData)
+	assert.Equal("image/png", resp.Header.Get("Content-Type"))
+}
+
+func TestConfig_Cape2(t *testing.T) {
+	assert := testify.New(t)
+
+	ctrl := gomock.NewController(t)
+	defer ctrl.Finish()
+
+	config, _, capesRepo, wd := setupMocks(ctrl)
+
+	capesRepo.EXPECT().FindByUsername("notch").Return(nil, &db.CapeNotFoundError{"notch"})
+	wd.EXPECT().IncCounter("capes.request", int64(1))
+
+	req := httptest.NewRequest("GET", "http://skinsystem.ely.by/cloaks/notch", nil)
+	w := httptest.NewRecorder()
+
+	config.CreateHandler().ServeHTTP(w, req)
+
+	resp := w.Result()
+	assert.Equal(301, resp.StatusCode)
+	assert.Equal("http://skins.minecraft.net/MinecraftCloaks/notch.png", resp.Header.Get("Location"))
+}
+
+func TestConfig_CapeGET(t *testing.T) {
+	assert := testify.New(t)
+
+	ctrl := gomock.NewController(t)
+	defer ctrl.Finish()
+
+	config, _, capesRepo, wd := setupMocks(ctrl)
+
+	cape := createCape()
+
+	capesRepo.EXPECT().FindByUsername("mocked_username").Return(&model.Cape{
+		File: bytes.NewReader(cape),
+	}, nil)
+	wd.EXPECT().IncCounter("capes.request", int64(1)).Times(0)
+	wd.EXPECT().IncCounter("capes.get_request", int64(1))
+
+	req := httptest.NewRequest("GET", "http://skinsystem.ely.by/cloaks?name=mocked_username", nil)
+	w := httptest.NewRecorder()
+
+	config.CreateHandler().ServeHTTP(w, req)
+
+	resp := w.Result()
+	assert.Equal(200, resp.StatusCode)
+	responseData, _ := ioutil.ReadAll(resp.Body)
+	assert.Equal(cape, responseData)
+	assert.Equal("image/png", resp.Header.Get("Content-Type"))
+}
+
+func TestConfig_CapeGET2(t *testing.T) {
+	assert := testify.New(t)
+
+	ctrl := gomock.NewController(t)
+	defer ctrl.Finish()
+
+	config, _, capesRepo, wd := setupMocks(ctrl)
+
+	capesRepo.EXPECT().FindByUsername("notch").Return(nil, &db.CapeNotFoundError{"notch"})
+	wd.EXPECT().IncCounter("capes.request", int64(1)).Times(0)
+	wd.EXPECT().IncCounter("capes.get_request", int64(1))
+
+	req := httptest.NewRequest("GET", "http://skinsystem.ely.by/cloaks?name=notch", nil)
+	w := httptest.NewRecorder()
+
+	config.CreateHandler().ServeHTTP(w, req)
+
+	resp := w.Result()
+	assert.Equal(301, resp.StatusCode)
+	assert.Equal("http://skins.minecraft.net/MinecraftCloaks/notch.png", resp.Header.Get("Location"))
+}
+
+func TestConfig_CapeGET3(t *testing.T) {
+	assert := testify.New(t)
+
+	req := httptest.NewRequest("GET", "http://skinsystem.ely.by/cloaks/?name=notch", nil)
+	w := httptest.NewRecorder()
+
+	(&Config{}).CreateHandler().ServeHTTP(w, req)
+
+	resp := w.Result()
+	assert.Equal(301, resp.StatusCode)
+	assert.Equal("http://skinsystem.ely.by/cloaks?name=notch", resp.Header.Get("Location"))
+}
+
+// Cape md5: 424ff79dce9940af89c28ad80de8aaad
+func createCape() []byte {
+	img := image.NewAlpha(image.Rect(0, 0, 64, 32))
+	writer := &bytes.Buffer{}
+	png.Encode(writer, img)
+
+	pngBytes, _ := ioutil.ReadAll(writer)
+
+	return pngBytes
+}

http/face.go

@@ -0,0 +1,27 @@
+package http
+
+import (
+	"net/http"
+
+	"github.com/gorilla/mux"
+)
+
+const defaultHash = "default"
+
+func (cfg *Config) Face(response http.ResponseWriter, request *http.Request) {
+	cfg.Logger.IncCounter("faces.request", 1)
+	username := parseUsername(mux.Vars(request)["username"])
+	rec, err := cfg.SkinsRepo.FindByUsername(username)
+	var hash string
+	if err != nil || rec.SkinId == 0 {
+		hash = defaultHash
+	} else {
+		hash = rec.Hash
+	}
+
+	http.Redirect(response, request, buildElyUrl(buildFaceUrl(hash)), 301)
+}
+
+func buildFaceUrl(hash string) string {
+	return "/minecraft/skin_buffer/faces/" + hash + ".png"
+}

http/face_test.go

@@ -0,0 +1,53 @@
+package http
+
+import (
+	"net/http/httptest"
+	"testing"
+
+	"github.com/golang/mock/gomock"
+	testify "github.com/stretchr/testify/assert"
+
+	"elyby/minecraft-skinsystem/db"
+)
+
+func TestConfig_Face(t *testing.T) {
+	assert := testify.New(t)
+
+	ctrl := gomock.NewController(t)
+	defer ctrl.Finish()
+
+	config, skinsRepo, _, wd := setupMocks(ctrl)
+
+	skinsRepo.EXPECT().FindByUsername("mock_user").Return(createSkinModel("mock_user", false), nil)
+	wd.EXPECT().IncCounter("faces.request", int64(1))
+
+	req := httptest.NewRequest("GET", "http://skinsystem.ely.by/skins/mock_user/face.png", nil)
+	w := httptest.NewRecorder()
+
+	config.CreateHandler().ServeHTTP(w, req)
+
+	resp := w.Result()
+	assert.Equal(301, resp.StatusCode)
+	assert.Equal("http://ely.by/minecraft/skin_buffer/faces/55d2a8848764f5ff04012cdb093458bd.png", resp.Header.Get("Location"))
+}
+
+func TestConfig_Face2(t *testing.T) {
+	assert := testify.New(t)
+
+	ctrl := gomock.NewController(t)
+	defer ctrl.Finish()
+
+	config, skinsRepo, _, wd := setupMocks(ctrl)
+
+	skinsRepo.EXPECT().FindByUsername("mock_user").Return(nil, &db.SkinNotFoundError{"mock_user"})
+	wd.EXPECT().IncCounter("faces.request", int64(1))
+
+	req := httptest.NewRequest("GET", "http://skinsystem.ely.by/skins/mock_user/face.png", nil)
+	w := httptest.NewRecorder()
+
+	config.CreateHandler().ServeHTTP(w, req)
+
+	resp := w.Result()
+	assert.Equal(301, resp.StatusCode)
+	assert.Equal("http://ely.by/minecraft/skin_buffer/faces/default.png", resp.Header.Get("Location"))
+}

http/http.go

@@ -0,0 +1,91 @@
+package http
+
+import (
+	"fmt"
+	"net"
+	"net/http"
+	"os"
+	"os/signal"
+	"strings"
+	"syscall"
+	"time"
+
+	"github.com/gorilla/mux"
+	"github.com/mono83/slf/wd"
+
+	"elyby/minecraft-skinsystem/interfaces"
+)
+
+type Config struct {
+	ListenSpec string
+
+	SkinsRepo interfaces.SkinsRepository
+	CapesRepo interfaces.CapesRepository
+	Logger    wd.Watchdog
+}
+
+func (cfg *Config) Run() error {
+	cfg.Logger.Info(fmt.Sprintf("Starting, HTTP on: %s\n", cfg.ListenSpec))
+
+	listener, err := net.Listen("tcp", cfg.ListenSpec)
+	if err != nil {
+		return err
+	}
+
+	server := &http.Server{
+		ReadTimeout:    60 * time.Second,
+		WriteTimeout:   60 * time.Second,
+		MaxHeaderBytes: 1 << 16,
+		Handler:        cfg.CreateHandler(),
+	}
+
+	go server.Serve(listener)
+
+	s := waitForSignal()
+	cfg.Logger.Info(fmt.Sprintf("Got signal: %v, exiting.", s))
+
+	return nil
+}
+
+func (cfg *Config) CreateHandler() http.Handler {
+	router := mux.NewRouter().StrictSlash(true)
+
+	router.HandleFunc("/skins/{username}", cfg.Skin).Methods("GET")
+	router.HandleFunc("/cloaks/{username}", cfg.Cape).Methods("GET").Name("cloaks")
+	router.HandleFunc("/textures/{username}", cfg.Textures).Methods("GET")
+	router.HandleFunc("/textures/signed/{username}", cfg.SignedTextures).Methods("GET")
+	router.HandleFunc("/skins/{username}/face", cfg.Face).Methods("GET")
+	router.HandleFunc("/skins/{username}/face.png", cfg.Face).Methods("GET")
+	// Legacy
+	router.HandleFunc("/skins", cfg.SkinGET).Methods("GET")
+	router.HandleFunc("/cloaks", cfg.CapeGET).Methods("GET")
+	// 404
+	router.NotFoundHandler = http.HandlerFunc(cfg.NotFound)
+
+	return router
+}
+
+func parseUsername(username string) string {
+	const suffix = ".png"
+	if strings.HasSuffix(username, suffix) {
+		username = strings.TrimSuffix(username, suffix)
+	}
+
+	return username
+}
+
+func buildElyUrl(route string) string {
+	prefix := "http://ely.by"
+	if !strings.HasPrefix(route, prefix) {
+		route = prefix + route
+	}
+
+	return route
+}
+
+func waitForSignal() os.Signal {
+	ch := make(chan os.Signal)
+	signal.Notify(ch, syscall.SIGINT, syscall.SIGTERM)
+
+	return <-ch
+}

http/http_test.go

@@ -0,0 +1,40 @@
+package http
+
+import (
+	"testing"
+
+	"github.com/golang/mock/gomock"
+	testify "github.com/stretchr/testify/assert"
+
+	"elyby/minecraft-skinsystem/interfaces/mock_interfaces"
+	"elyby/minecraft-skinsystem/interfaces/mock_wd"
+)
+
+func TestParseUsername(t *testing.T) {
+	assert := testify.New(t)
+	assert.Equal("test", parseUsername("test.png"), "Function should trim .png at end")
+	assert.Equal("test", parseUsername("test"), "Function should return string itself, if it not contains .png at end")
+}
+
+func TestBuildElyUrl(t *testing.T) {
+	assert := testify.New(t)
+	assert.Equal("http://ely.by/route", buildElyUrl("/route"), "Function should add prefix to the provided relative url.")
+	assert.Equal("http://ely.by/test/route", buildElyUrl("http://ely.by/test/route"), "Function should do not add prefix to the provided prefixed url.")
+}
+
+func setupMocks(ctrl *gomock.Controller) (
+	*Config,
+	*mock_interfaces.MockSkinsRepository,
+	*mock_interfaces.MockCapesRepository,
+	*mock_wd.MockWatchdog,
+) {
+	skinsRepo := mock_interfaces.NewMockSkinsRepository(ctrl)
+	capesRepo := mock_interfaces.NewMockCapesRepository(ctrl)
+	wd := mock_wd.NewMockWatchdog(ctrl)
+
+	return &Config{
+		SkinsRepo: skinsRepo,
+		CapesRepo: capesRepo,
+		Logger: wd,
+	}, skinsRepo, capesRepo, wd
+}

http/not_found.go

@@ -0,0 +1,18 @@
+package http
+
+import (
+	"encoding/json"
+	"net/http"
+)
+
+func (cfg *Config) NotFound(response http.ResponseWriter, request *http.Request)  {
+	data, _ := json.Marshal(map[string]string{
+		"status": "404",
+		"message": "Not Found",
+		"link": "http://docs.ely.by/skin-system.html",
+	})
+
+	response.Header().Set("Content-Type", "application/json")
+	response.WriteHeader(http.StatusNotFound)
+	response.Write(data)
+}

http/not_found_test.go

@@ -0,0 +1,28 @@
+package http
+
+import (
+	"io/ioutil"
+	"net/http/httptest"
+	"testing"
+
+	testify "github.com/stretchr/testify/assert"
+)
+
+func TestConfig_NotFound(t *testing.T) {
+	assert := testify.New(t)
+
+	req := httptest.NewRequest("GET", "http://skinsystem.ely.by/", nil)
+	w := httptest.NewRecorder()
+
+	(&Config{}).CreateHandler().ServeHTTP(w, req)
+
+	resp := w.Result()
+	assert.Equal(404, resp.StatusCode)
+	assert.Equal("application/json", resp.Header.Get("Content-Type"))
+	response, _ := ioutil.ReadAll(resp.Body)
+	assert.JSONEq(`{
+		"status": "404",
+		"message": "Not Found",
+		"link": "http://docs.ely.by/skin-system.html"
+	}`, string(response))
+}

http/signed_textures.go

@@ -0,0 +1,53 @@
+package http
+
+import (
+	"encoding/json"
+	"net/http"
+	"strings"
+
+	"github.com/gorilla/mux"
+)
+
+type signedTexturesResponse struct {
+	Id    string     `json:"id"`
+	Name  string     `json:"name"`
+	IsEly bool       `json:"ely,omitempty"`
+	Props []property `json:"properties"`
+}
+
+type property struct {
+	Name      string `json:"name"`
+	Signature string `json:"signature,omitempty"`
+	Value     string `json:"value"`
+}
+
+func (cfg *Config) SignedTextures(response http.ResponseWriter, request *http.Request) {
+	cfg.Logger.IncCounter("signed_textures.request", 1)
+	username := parseUsername(mux.Vars(request)["username"])
+
+	rec, err := cfg.SkinsRepo.FindByUsername(username)
+	if err != nil || rec.SkinId == 0 || rec.MojangTextures == "" {
+		response.WriteHeader(http.StatusNoContent)
+		return
+	}
+
+	responseData:= signedTexturesResponse{
+		Id: strings.Replace(rec.Uuid, "-", "", -1),
+		Name: rec.Username,
+		Props: []property{
+			{
+				Name: "textures",
+				Signature: rec.MojangSignature,
+				Value: rec.MojangTextures,
+			},
+			{
+				Name: "ely",
+				Value: "but why are you asking?",
+			},
+		},
+	}
+
+	responseJson,_ := json.Marshal(responseData)
+	response.Header().Set("Content-Type", "application/json")
+	response.Write(responseJson)
+}

http/signed_textures_test.go

@@ -0,0 +1,71 @@
+package http
+
+import (
+	"io/ioutil"
+	"net/http/httptest"
+	"testing"
+
+	"github.com/golang/mock/gomock"
+	testify "github.com/stretchr/testify/assert"
+
+	"elyby/minecraft-skinsystem/db"
+)
+
+func TestConfig_SignedTextures(t *testing.T) {
+	assert := testify.New(t)
+
+	ctrl := gomock.NewController(t)
+	defer ctrl.Finish()
+
+	config, skinsRepo, _, wd := setupMocks(ctrl)
+
+	skinsRepo.EXPECT().FindByUsername("mock_user").Return(createSkinModel("mock_user", false), nil)
+	wd.EXPECT().IncCounter("signed_textures.request", int64(1))
+
+	req := httptest.NewRequest("GET", "http://skinsystem.ely.by/textures/signed/mock_user", nil)
+	w := httptest.NewRecorder()
+
+	config.CreateHandler().ServeHTTP(w, req)
+
+	resp := w.Result()
+	assert.Equal(200, resp.StatusCode)
+	assert.Equal("application/json", resp.Header.Get("Content-Type"))
+	response, _ := ioutil.ReadAll(resp.Body)
+	assert.JSONEq(`{
+		"id": "0f657aa8bfbe415db7005750090d3af3",
+		"name": "mock_user",
+		"properties": [
+			{
+				"name": "textures",
+				"signature": "mocked signature",
+				"value": "mocked textures base64"
+			},
+			{
+				"name": "ely",
+				"value": "but why are you asking?"
+			}
+		]
+	}`, string(response))
+}
+
+func TestConfig_SignedTextures2(t *testing.T) {
+	assert := testify.New(t)
+
+	ctrl := gomock.NewController(t)
+	defer ctrl.Finish()
+
+	config, skinsRepo, _, wd := setupMocks(ctrl)
+
+	skinsRepo.EXPECT().FindByUsername("mock_user").Return(nil, &db.SkinNotFoundError{})
+	wd.EXPECT().IncCounter("signed_textures.request", int64(1))
+
+	req := httptest.NewRequest("GET", "http://skinsystem.ely.by/textures/signed/mock_user", nil)
+	w := httptest.NewRecorder()
+
+	config.CreateHandler().ServeHTTP(w, req)
+
+	resp := w.Result()
+	assert.Equal(204, resp.StatusCode)
+	response, _ := ioutil.ReadAll(resp.Body)
+	assert.Equal("", string(response))
+}

http/skin.go

@@ -0,0 +1,36 @@
+package http
+
+import (
+	"net/http"
+
+	"github.com/gorilla/mux"
+)
+
+func (cfg *Config) Skin(response http.ResponseWriter, request *http.Request) {
+	if mux.Vars(request)["converted"] == "" {
+		cfg.Logger.IncCounter("skins.request", 1)
+	}
+
+	username := parseUsername(mux.Vars(request)["username"])
+	rec, err := cfg.SkinsRepo.FindByUsername(username)
+	if err != nil || rec.SkinId == 0 {
+		http.Redirect(response, request, "http://skins.minecraft.net/MinecraftSkins/" + username + ".png", 301)
+		return
+	}
+
+	http.Redirect(response, request, buildElyUrl(rec.Url), 301)
+}
+
+func (cfg *Config) SkinGET(response http.ResponseWriter, request *http.Request) {
+	cfg.Logger.IncCounter("skins.get_request", 1)
+	username := request.URL.Query().Get("name")
+	if username == "" {
+		response.WriteHeader(http.StatusBadRequest)
+		return
+	}
+
+	mux.Vars(request)["username"] = username
+	mux.Vars(request)["converted"] = "1"
+
+	cfg.Skin(response, request)
+}

http/skin_test.go

@@ -0,0 +1,124 @@
+package http
+
+import (
+	"net/http/httptest"
+	"testing"
+
+	"github.com/golang/mock/gomock"
+	testify "github.com/stretchr/testify/assert"
+
+	"elyby/minecraft-skinsystem/db"
+	"elyby/minecraft-skinsystem/model"
+)
+
+func TestConfig_Skin(t *testing.T) {
+	assert := testify.New(t)
+
+	ctrl := gomock.NewController(t)
+	defer ctrl.Finish()
+
+	config, skinsRepo, _, wd := setupMocks(ctrl)
+
+	skinsRepo.EXPECT().FindByUsername("mock_user").Return(createSkinModel("mock_user", false), nil)
+	wd.EXPECT().IncCounter("skins.request", int64(1))
+
+	req := httptest.NewRequest("GET", "http://skinsystem.ely.by/skins/mock_user", nil)
+	w := httptest.NewRecorder()
+
+	config.CreateHandler().ServeHTTP(w, req)
+
+	resp := w.Result()
+	assert.Equal(301, resp.StatusCode)
+	assert.Equal("http://ely.by/minecraft/skins/skin.png", resp.Header.Get("Location"))
+}
+
+func TestConfig_Skin2(t *testing.T) {
+	assert := testify.New(t)
+
+	ctrl := gomock.NewController(t)
+	defer ctrl.Finish()
+
+	config, skinsRepo, _, wd := setupMocks(ctrl)
+
+	skinsRepo.EXPECT().FindByUsername("notch").Return(nil, &db.SkinNotFoundError{"notch"})
+	wd.EXPECT().IncCounter("skins.request", int64(1))
+
+	req := httptest.NewRequest("GET", "http://skinsystem.ely.by/skins/notch", nil)
+	w := httptest.NewRecorder()
+
+	config.CreateHandler().ServeHTTP(w, req)
+
+	resp := w.Result()
+	assert.Equal(301, resp.StatusCode)
+	assert.Equal("http://skins.minecraft.net/MinecraftSkins/notch.png", resp.Header.Get("Location"))
+}
+
+func TestConfig_SkinGET(t *testing.T) {
+	assert := testify.New(t)
+
+	ctrl := gomock.NewController(t)
+	defer ctrl.Finish()
+
+	config, skinsRepo, _, wd := setupMocks(ctrl)
+
+	skinsRepo.EXPECT().FindByUsername("mock_user").Return(createSkinModel("mock_user", false), nil)
+	wd.EXPECT().IncCounter("skins.get_request", int64(1))
+	wd.EXPECT().IncCounter("skins.request", int64(1)).Times(0)
+
+	req := httptest.NewRequest("GET", "http://skinsystem.ely.by/skins?name=mock_user", nil)
+	w := httptest.NewRecorder()
+
+	config.CreateHandler().ServeHTTP(w, req)
+
+	resp := w.Result()
+	assert.Equal(301, resp.StatusCode)
+	assert.Equal("http://ely.by/minecraft/skins/skin.png", resp.Header.Get("Location"))
+}
+
+func TestConfig_SkinGET2(t *testing.T) {
+	assert := testify.New(t)
+
+	ctrl := gomock.NewController(t)
+	defer ctrl.Finish()
+
+	config, skinsRepo, _, wd := setupMocks(ctrl)
+
+	skinsRepo.EXPECT().FindByUsername("notch").Return(nil, &db.SkinNotFoundError{"notch"})
+	wd.EXPECT().IncCounter("skins.get_request", int64(1))
+	wd.EXPECT().IncCounter("skins.request", int64(1)).Times(0)
+
+	req := httptest.NewRequest("GET", "http://skinsystem.ely.by/skins?name=notch", nil)
+	w := httptest.NewRecorder()
+
+	config.CreateHandler().ServeHTTP(w, req)
+
+	resp := w.Result()
+	assert.Equal(301, resp.StatusCode)
+	assert.Equal("http://skins.minecraft.net/MinecraftSkins/notch.png", resp.Header.Get("Location"))
+}
+
+func TestConfig_SkinGET3(t *testing.T) {
+	assert := testify.New(t)
+
+	req := httptest.NewRequest("GET", "http://skinsystem.ely.by/skins/?name=notch", nil)
+	w := httptest.NewRecorder()
+
+	(&Config{}).CreateHandler().ServeHTTP(w, req)
+
+	resp := w.Result()
+	assert.Equal(301, resp.StatusCode)
+	assert.Equal("http://skinsystem.ely.by/skins?name=notch", resp.Header.Get("Location"))
+}
+
+func createSkinModel(username string, isSlim bool) *model.Skin {
+	return &model.Skin{
+		Username:        username,
+		Uuid:            "0f657aa8-bfbe-415d-b700-5750090d3af3",
+		SkinId:          1,
+		Hash:            "55d2a8848764f5ff04012cdb093458bd",
+		Url:             "http://ely.by/minecraft/skins/skin.png",
+		MojangTextures:  "mocked textures base64",
+		MojangSignature: "mocked signature",
+		IsSlim:          isSlim,
+	}
+}

http/textures.go

@@ -0,0 +1,104 @@
+package http
+
+import (
+	"crypto/md5"
+	"encoding/hex"
+	"encoding/json"
+	"io"
+	"net/http"
+	"strconv"
+	"time"
+
+	"github.com/gorilla/mux"
+
+	"elyby/minecraft-skinsystem/model"
+)
+
+type texturesResponse struct {
+	Skin *Skin `json:"SKIN"`
+	Cape *Cape `json:"CAPE,omitempty"`
+}
+
+type Skin struct {
+	Url      string        `json:"url"`
+	Hash     string        `json:"hash"`
+	Metadata *skinMetadata `json:"metadata,omitempty"`
+}
+
+type skinMetadata struct {
+	Model string `json:"model"`
+}
+
+type Cape struct {
+	Url  string `json:"url"`
+	Hash string `json:"hash"`
+}
+
+func (cfg *Config) Textures(response http.ResponseWriter, request *http.Request) {
+	cfg.Logger.IncCounter("textures.request", 1)
+	username := parseUsername(mux.Vars(request)["username"])
+
+	skin, err := cfg.SkinsRepo.FindByUsername(username)
+	if err != nil || skin.SkinId == 0 {
+		if skin == nil {
+			skin = &model.Skin{}
+		}
+
+		skin.Url = "http://skins.minecraft.net/MinecraftSkins/" + username + ".png"
+		skin.Hash = string(buildNonElyTexturesHash(username))
+	} else {
+		skin.Url = buildElyUrl(skin.Url)
+	}
+
+	textures := texturesResponse{
+		Skin: &Skin{
+			Url:  skin.Url,
+			Hash: skin.Hash,
+		},
+	}
+
+	if skin.IsSlim {
+		textures.Skin.Metadata = &skinMetadata{
+			Model: "slim",
+		}
+	}
+
+	cape, err := cfg.CapesRepo.FindByUsername(username)
+	if err == nil {
+		var scheme string = "http://"
+		if request.TLS != nil {
+			scheme = "https://"
+		}
+
+		textures.Cape = &Cape{
+			Url:  scheme + request.Host + "/cloaks/" + username,
+			Hash: calculateCapeHash(cape),
+		}
+	}
+
+	responseData, _ := json.Marshal(textures)
+	response.Header().Set("Content-Type", "application/json")
+	response.Write(responseData)
+}
+
+func calculateCapeHash(cape *model.Cape) string {
+	hasher := md5.New()
+	io.Copy(hasher, cape.File)
+
+	return hex.EncodeToString(hasher.Sum(nil))
+}
+
+func buildNonElyTexturesHash(username string) string {
+	hour := getCurrentHour()
+	hasher := md5.New()
+	hasher.Write([]byte("non-ely-" + strconv.FormatInt(hour, 10) + "-" + username))
+
+	return hex.EncodeToString(hasher.Sum(nil))
+}
+
+var timeNow = time.Now
+
+func getCurrentHour() int64 {
+	n := timeNow()
+	return time.Date(n.Year(), n.Month(), n.Day(), n.Hour(), 0, 0, 0, time.UTC).Unix()
+}

http/textures_test.go

@@ -0,0 +1,166 @@
+package http
+
+import (
+	"bytes"
+	"io/ioutil"
+	"net/http/httptest"
+	"testing"
+	"time"
+
+	"github.com/golang/mock/gomock"
+	testify "github.com/stretchr/testify/assert"
+
+	"elyby/minecraft-skinsystem/db"
+	"elyby/minecraft-skinsystem/model"
+)
+
+func TestConfig_Textures(t *testing.T) {
+	assert := testify.New(t)
+
+	ctrl := gomock.NewController(t)
+	defer ctrl.Finish()
+
+	config, skinsRepo, capesRepo, wd := setupMocks(ctrl)
+
+	skinsRepo.EXPECT().FindByUsername("mock_user").Return(createSkinModel("mock_user", false), nil)
+	capesRepo.EXPECT().FindByUsername("mock_user").Return(nil, &db.CapeNotFoundError{"mock_user"})
+	wd.EXPECT().IncCounter("textures.request", int64(1))
+
+	req := httptest.NewRequest("GET", "http://skinsystem.ely.by/textures/mock_user", nil)
+	w := httptest.NewRecorder()
+
+	config.CreateHandler().ServeHTTP(w, req)
+
+	resp := w.Result()
+	assert.Equal(200, resp.StatusCode)
+	assert.Equal("application/json", resp.Header.Get("Content-Type"))
+	response, _ := ioutil.ReadAll(resp.Body)
+	assert.JSONEq(`{
+		"SKIN": {
+			"url": "http://ely.by/minecraft/skins/skin.png",
+			"hash": "55d2a8848764f5ff04012cdb093458bd"
+		}
+	}`, string(response))
+}
+
+func TestConfig_Textures2(t *testing.T) {
+	assert := testify.New(t)
+
+	ctrl := gomock.NewController(t)
+	defer ctrl.Finish()
+
+	config, skinsRepo, capesRepo, wd := setupMocks(ctrl)
+
+	skinsRepo.EXPECT().FindByUsername("mock_user").Return(createSkinModel("mock_user", true), nil)
+	capesRepo.EXPECT().FindByUsername("mock_user").Return(nil, &db.CapeNotFoundError{"mock_user"})
+	wd.EXPECT().IncCounter("textures.request", int64(1))
+
+	req := httptest.NewRequest("GET", "http://skinsystem.ely.by/textures/mock_user", nil)
+	w := httptest.NewRecorder()
+
+	config.CreateHandler().ServeHTTP(w, req)
+
+	resp := w.Result()
+	assert.Equal(200, resp.StatusCode)
+	assert.Equal("application/json", resp.Header.Get("Content-Type"))
+	response, _ := ioutil.ReadAll(resp.Body)
+	assert.JSONEq(`{
+		"SKIN": {
+			"url": "http://ely.by/minecraft/skins/skin.png",
+			"hash": "55d2a8848764f5ff04012cdb093458bd",
+			"metadata": {
+				"model": "slim"
+			}
+		}
+	}`, string(response))
+}
+
+func TestConfig_Textures3(t *testing.T) {
+	assert := testify.New(t)
+
+	ctrl := gomock.NewController(t)
+	defer ctrl.Finish()
+
+	config, skinsRepo, capesRepo, wd := setupMocks(ctrl)
+
+	skinsRepo.EXPECT().FindByUsername("mock_user").Return(createSkinModel("mock_user", false), nil)
+	capesRepo.EXPECT().FindByUsername("mock_user").Return(&model.Cape{
+		File: bytes.NewReader(createCape()),
+	}, nil)
+	wd.EXPECT().IncCounter("textures.request", int64(1))
+
+	req := httptest.NewRequest("GET", "http://skinsystem.ely.by/textures/mock_user", nil)
+	w := httptest.NewRecorder()
+
+	config.CreateHandler().ServeHTTP(w, req)
+
+	resp := w.Result()
+	assert.Equal(200, resp.StatusCode)
+	assert.Equal("application/json", resp.Header.Get("Content-Type"))
+	response, _ := ioutil.ReadAll(resp.Body)
+	assert.JSONEq(`{
+		"SKIN": {
+			"url": "http://ely.by/minecraft/skins/skin.png",
+			"hash": "55d2a8848764f5ff04012cdb093458bd"
+		},
+		"CAPE": {
+			"url": "http://skinsystem.ely.by/cloaks/mock_user",
+			"hash": "424ff79dce9940af89c28ad80de8aaad"
+		}
+	}`, string(response))
+}
+
+func TestConfig_Textures4(t *testing.T) {
+	assert := testify.New(t)
+
+	ctrl := gomock.NewController(t)
+	defer ctrl.Finish()
+
+	config, skinsRepo, capesRepo, wd := setupMocks(ctrl)
+
+	skinsRepo.EXPECT().FindByUsername("notch").Return(nil, &db.SkinNotFoundError{})
+	capesRepo.EXPECT().FindByUsername("notch").Return(nil, &db.CapeNotFoundError{})
+	wd.EXPECT().IncCounter("textures.request", int64(1))
+	timeNow = func() time.Time {
+		return time.Date(2017, time.August, 20, 0, 15, 54, 0, time.UTC)
+	}
+
+	req := httptest.NewRequest("GET", "http://skinsystem.ely.by/textures/notch", nil)
+	w := httptest.NewRecorder()
+
+	config.CreateHandler().ServeHTTP(w, req)
+
+	resp := w.Result()
+	assert.Equal(200, resp.StatusCode)
+	assert.Equal("application/json", resp.Header.Get("Content-Type"))
+	response, _ := ioutil.ReadAll(resp.Body)
+	assert.JSONEq(`{
+		"SKIN": {
+			"url": "http://skins.minecraft.net/MinecraftSkins/notch.png",
+			"hash": "5923cf3f7fa170a279e4d7a9483cfc52"
+		}
+	}`, string(response))
+}
+
+func TestBuildNonElyTexturesHash(t *testing.T) {
+	assert := testify.New(t)
+	timeNow = func() time.Time {
+		return time.Date(2017, time.November, 30, 16, 15, 34, 0, time.UTC)
+	}
+
+	assert.Equal("686d788a5353cb636e8fdff727634d88", buildNonElyTexturesHash("username"), "Function should return fixed hash by username-time pair")
+	assert.Equal("fb876f761683a10accdb17d403cef64c", buildNonElyTexturesHash("another-username"), "Function should return fixed hash by username-time pair")
+
+	timeNow = func() time.Time {
+		return time.Date(2017, time.November, 30, 16, 20, 12, 0, time.UTC)
+	}
+
+	assert.Equal("686d788a5353cb636e8fdff727634d88", buildNonElyTexturesHash("username"), "Function should do not change it's value if hour the same")
+	assert.Equal("fb876f761683a10accdb17d403cef64c", buildNonElyTexturesHash("another-username"), "Function should return fixed hash by username-time pair")
+
+	timeNow = func() time.Time {
+		return time.Date(2017, time.November, 30, 17, 1, 3, 0, time.UTC)
+	}
+
+	assert.Equal("42277892fd24bc0ed86285b3bb8b8fad", buildNonElyTexturesHash("username"), "Function should change it's value if hour changed")
+}

interfaces/api.go

@@ -0,0 +1,9 @@
+package interfaces
+
+import (
+	"elyby/minecraft-skinsystem/api/accounts"
+)
+
+type AccountsAPI interface {
+	AccountInfo(attribute string, value string) (*accounts.AccountInfoResponse, error)
+}

interfaces/mock_interfaces/mock_api.go

@@ -0,0 +1,46 @@
+// Code generated by MockGen. DO NOT EDIT.
+// Source: interfaces/api.go
+
+package mock_interfaces
+
+import (
+	accounts "elyby/minecraft-skinsystem/api/accounts"
+	gomock "github.com/golang/mock/gomock"
+	reflect "reflect"
+)
+
+// MockAccountsAPI is a mock of AccountsAPI interface
+type MockAccountsAPI struct {
+	ctrl     *gomock.Controller
+	recorder *MockAccountsAPIMockRecorder
+}
+
+// MockAccountsAPIMockRecorder is the mock recorder for MockAccountsAPI
+type MockAccountsAPIMockRecorder struct {
+	mock *MockAccountsAPI
+}
+
+// NewMockAccountsAPI creates a new mock instance
+func NewMockAccountsAPI(ctrl *gomock.Controller) *MockAccountsAPI {
+	mock := &MockAccountsAPI{ctrl: ctrl}
+	mock.recorder = &MockAccountsAPIMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use
+func (_m *MockAccountsAPI) EXPECT() *MockAccountsAPIMockRecorder {
+	return _m.recorder
+}
+
+// AccountInfo mocks base method
+func (_m *MockAccountsAPI) AccountInfo(attribute string, value string) (*accounts.AccountInfoResponse, error) {
+	ret := _m.ctrl.Call(_m, "AccountInfo", attribute, value)
+	ret0, _ := ret[0].(*accounts.AccountInfoResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// AccountInfo indicates an expected call of AccountInfo
+func (_mr *MockAccountsAPIMockRecorder) AccountInfo(arg0, arg1 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCallWithMethodType(_mr.mock, "AccountInfo", reflect.TypeOf((*MockAccountsAPI)(nil).AccountInfo), arg0, arg1)
+}

interfaces/mock_interfaces/mock_interfaces.go

@@ -0,0 +1,107 @@
+// Code generated by MockGen. DO NOT EDIT.
+// Source: interfaces/repositories.go
+
+package mock_interfaces
+
+import (
+	model "elyby/minecraft-skinsystem/model"
+	gomock "github.com/golang/mock/gomock"
+	reflect "reflect"
+)
+
+// MockSkinsRepository is a mock of SkinsRepository interface
+type MockSkinsRepository struct {
+	ctrl     *gomock.Controller
+	recorder *MockSkinsRepositoryMockRecorder
+}
+
+// MockSkinsRepositoryMockRecorder is the mock recorder for MockSkinsRepository
+type MockSkinsRepositoryMockRecorder struct {
+	mock *MockSkinsRepository
+}
+
+// NewMockSkinsRepository creates a new mock instance
+func NewMockSkinsRepository(ctrl *gomock.Controller) *MockSkinsRepository {
+	mock := &MockSkinsRepository{ctrl: ctrl}
+	mock.recorder = &MockSkinsRepositoryMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use
+func (_m *MockSkinsRepository) EXPECT() *MockSkinsRepositoryMockRecorder {
+	return _m.recorder
+}
+
+// FindByUsername mocks base method
+func (_m *MockSkinsRepository) FindByUsername(username string) (*model.Skin, error) {
+	ret := _m.ctrl.Call(_m, "FindByUsername", username)
+	ret0, _ := ret[0].(*model.Skin)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// FindByUsername indicates an expected call of FindByUsername
+func (_mr *MockSkinsRepositoryMockRecorder) FindByUsername(arg0 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCallWithMethodType(_mr.mock, "FindByUsername", reflect.TypeOf((*MockSkinsRepository)(nil).FindByUsername), arg0)
+}
+
+// FindByUserId mocks base method
+func (_m *MockSkinsRepository) FindByUserId(id int) (*model.Skin, error) {
+	ret := _m.ctrl.Call(_m, "FindByUserId", id)
+	ret0, _ := ret[0].(*model.Skin)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// FindByUserId indicates an expected call of FindByUserId
+func (_mr *MockSkinsRepositoryMockRecorder) FindByUserId(arg0 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCallWithMethodType(_mr.mock, "FindByUserId", reflect.TypeOf((*MockSkinsRepository)(nil).FindByUserId), arg0)
+}
+
+// Save mocks base method
+func (_m *MockSkinsRepository) Save(skin *model.Skin) error {
+	ret := _m.ctrl.Call(_m, "Save", skin)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// Save indicates an expected call of Save
+func (_mr *MockSkinsRepositoryMockRecorder) Save(arg0 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCallWithMethodType(_mr.mock, "Save", reflect.TypeOf((*MockSkinsRepository)(nil).Save), arg0)
+}
+
+// MockCapesRepository is a mock of CapesRepository interface
+type MockCapesRepository struct {
+	ctrl     *gomock.Controller
+	recorder *MockCapesRepositoryMockRecorder
+}
+
+// MockCapesRepositoryMockRecorder is the mock recorder for MockCapesRepository
+type MockCapesRepositoryMockRecorder struct {
+	mock *MockCapesRepository
+}
+
+// NewMockCapesRepository creates a new mock instance
+func NewMockCapesRepository(ctrl *gomock.Controller) *MockCapesRepository {
+	mock := &MockCapesRepository{ctrl: ctrl}
+	mock.recorder = &MockCapesRepositoryMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use
+func (_m *MockCapesRepository) EXPECT() *MockCapesRepositoryMockRecorder {
+	return _m.recorder
+}
+
+// FindByUsername mocks base method
+func (_m *MockCapesRepository) FindByUsername(username string) (*model.Cape, error) {
+	ret := _m.ctrl.Call(_m, "FindByUsername", username)
+	ret0, _ := ret[0].(*model.Cape)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// FindByUsername indicates an expected call of FindByUsername
+func (_mr *MockCapesRepositoryMockRecorder) FindByUsername(arg0 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCallWithMethodType(_mr.mock, "FindByUsername", reflect.TypeOf((*MockCapesRepository)(nil).FindByUsername), arg0)
+}

interfaces/mock_wd/mock_wd.go

@@ -0,0 +1,218 @@
+// Code generated by MockGen. DO NOT EDIT.
+// Source: github.com/mono83/slf/wd (interfaces: Watchdog)
+
+package mock_wd
+
+import (
+	gomock "github.com/golang/mock/gomock"
+	slf "github.com/mono83/slf"
+	wd "github.com/mono83/slf/wd"
+	reflect "reflect"
+	time "time"
+)
+
+// MockWatchdog is a mock of Watchdog interface
+type MockWatchdog struct {
+	ctrl     *gomock.Controller
+	recorder *MockWatchdogMockRecorder
+}
+
+// MockWatchdogMockRecorder is the mock recorder for MockWatchdog
+type MockWatchdogMockRecorder struct {
+	mock *MockWatchdog
+}
+
+// NewMockWatchdog creates a new mock instance
+func NewMockWatchdog(ctrl *gomock.Controller) *MockWatchdog {
+	mock := &MockWatchdog{ctrl: ctrl}
+	mock.recorder = &MockWatchdogMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use
+func (_m *MockWatchdog) EXPECT() *MockWatchdogMockRecorder {
+	return _m.recorder
+}
+
+// Alert mocks base method
+func (_m *MockWatchdog) Alert(_param0 string, _param1 ...slf.Param) {
+	_s := []interface{}{_param0}
+	for _, _x := range _param1 {
+		_s = append(_s, _x)
+	}
+	_m.ctrl.Call(_m, "Alert", _s...)
+}
+
+// Alert indicates an expected call of Alert
+func (_mr *MockWatchdogMockRecorder) Alert(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
+	_s := append([]interface{}{arg0}, arg1...)
+	return _mr.mock.ctrl.RecordCallWithMethodType(_mr.mock, "Alert", reflect.TypeOf((*MockWatchdog)(nil).Alert), _s...)
+}
+
+// Debug mocks base method
+func (_m *MockWatchdog) Debug(_param0 string, _param1 ...slf.Param) {
+	_s := []interface{}{_param0}
+	for _, _x := range _param1 {
+		_s = append(_s, _x)
+	}
+	_m.ctrl.Call(_m, "Debug", _s...)
+}
+
+// Debug indicates an expected call of Debug
+func (_mr *MockWatchdogMockRecorder) Debug(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
+	_s := append([]interface{}{arg0}, arg1...)
+	return _mr.mock.ctrl.RecordCallWithMethodType(_mr.mock, "Debug", reflect.TypeOf((*MockWatchdog)(nil).Debug), _s...)
+}
+
+// Emergency mocks base method
+func (_m *MockWatchdog) Emergency(_param0 string, _param1 ...slf.Param) {
+	_s := []interface{}{_param0}
+	for _, _x := range _param1 {
+		_s = append(_s, _x)
+	}
+	_m.ctrl.Call(_m, "Emergency", _s...)
+}
+
+// Emergency indicates an expected call of Emergency
+func (_mr *MockWatchdogMockRecorder) Emergency(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
+	_s := append([]interface{}{arg0}, arg1...)
+	return _mr.mock.ctrl.RecordCallWithMethodType(_mr.mock, "Emergency", reflect.TypeOf((*MockWatchdog)(nil).Emergency), _s...)
+}
+
+// Error mocks base method
+func (_m *MockWatchdog) Error(_param0 string, _param1 ...slf.Param) {
+	_s := []interface{}{_param0}
+	for _, _x := range _param1 {
+		_s = append(_s, _x)
+	}
+	_m.ctrl.Call(_m, "Error", _s...)
+}
+
+// Error indicates an expected call of Error
+func (_mr *MockWatchdogMockRecorder) Error(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
+	_s := append([]interface{}{arg0}, arg1...)
+	return _mr.mock.ctrl.RecordCallWithMethodType(_mr.mock, "Error", reflect.TypeOf((*MockWatchdog)(nil).Error), _s...)
+}
+
+// IncCounter mocks base method
+func (_m *MockWatchdog) IncCounter(_param0 string, _param1 int64, _param2 ...slf.Param) {
+	_s := []interface{}{_param0, _param1}
+	for _, _x := range _param2 {
+		_s = append(_s, _x)
+	}
+	_m.ctrl.Call(_m, "IncCounter", _s...)
+}
+
+// IncCounter indicates an expected call of IncCounter
+func (_mr *MockWatchdogMockRecorder) IncCounter(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	_s := append([]interface{}{arg0, arg1}, arg2...)
+	return _mr.mock.ctrl.RecordCallWithMethodType(_mr.mock, "IncCounter", reflect.TypeOf((*MockWatchdog)(nil).IncCounter), _s...)
+}
+
+// Info mocks base method
+func (_m *MockWatchdog) Info(_param0 string, _param1 ...slf.Param) {
+	_s := []interface{}{_param0}
+	for _, _x := range _param1 {
+		_s = append(_s, _x)
+	}
+	_m.ctrl.Call(_m, "Info", _s...)
+}
+
+// Info indicates an expected call of Info
+func (_mr *MockWatchdogMockRecorder) Info(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
+	_s := append([]interface{}{arg0}, arg1...)
+	return _mr.mock.ctrl.RecordCallWithMethodType(_mr.mock, "Info", reflect.TypeOf((*MockWatchdog)(nil).Info), _s...)
+}
+
+// RecordTimer mocks base method
+func (_m *MockWatchdog) RecordTimer(_param0 string, _param1 time.Duration, _param2 ...slf.Param) {
+	_s := []interface{}{_param0, _param1}
+	for _, _x := range _param2 {
+		_s = append(_s, _x)
+	}
+	_m.ctrl.Call(_m, "RecordTimer", _s...)
+}
+
+// RecordTimer indicates an expected call of RecordTimer
+func (_mr *MockWatchdogMockRecorder) RecordTimer(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	_s := append([]interface{}{arg0, arg1}, arg2...)
+	return _mr.mock.ctrl.RecordCallWithMethodType(_mr.mock, "RecordTimer", reflect.TypeOf((*MockWatchdog)(nil).RecordTimer), _s...)
+}
+
+// Timer mocks base method
+func (_m *MockWatchdog) Timer(_param0 string, _param1 ...slf.Param) slf.Timer {
+	_s := []interface{}{_param0}
+	for _, _x := range _param1 {
+		_s = append(_s, _x)
+	}
+	ret := _m.ctrl.Call(_m, "Timer", _s...)
+	ret0, _ := ret[0].(slf.Timer)
+	return ret0
+}
+
+// Timer indicates an expected call of Timer
+func (_mr *MockWatchdogMockRecorder) Timer(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
+	_s := append([]interface{}{arg0}, arg1...)
+	return _mr.mock.ctrl.RecordCallWithMethodType(_mr.mock, "Timer", reflect.TypeOf((*MockWatchdog)(nil).Timer), _s...)
+}
+
+// Trace mocks base method
+func (_m *MockWatchdog) Trace(_param0 string, _param1 ...slf.Param) {
+	_s := []interface{}{_param0}
+	for _, _x := range _param1 {
+		_s = append(_s, _x)
+	}
+	_m.ctrl.Call(_m, "Trace", _s...)
+}
+
+// Trace indicates an expected call of Trace
+func (_mr *MockWatchdogMockRecorder) Trace(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
+	_s := append([]interface{}{arg0}, arg1...)
+	return _mr.mock.ctrl.RecordCallWithMethodType(_mr.mock, "Trace", reflect.TypeOf((*MockWatchdog)(nil).Trace), _s...)
+}
+
+// UpdateGauge mocks base method
+func (_m *MockWatchdog) UpdateGauge(_param0 string, _param1 int64, _param2 ...slf.Param) {
+	_s := []interface{}{_param0, _param1}
+	for _, _x := range _param2 {
+		_s = append(_s, _x)
+	}
+	_m.ctrl.Call(_m, "UpdateGauge", _s...)
+}
+
+// UpdateGauge indicates an expected call of UpdateGauge
+func (_mr *MockWatchdogMockRecorder) UpdateGauge(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	_s := append([]interface{}{arg0, arg1}, arg2...)
+	return _mr.mock.ctrl.RecordCallWithMethodType(_mr.mock, "UpdateGauge", reflect.TypeOf((*MockWatchdog)(nil).UpdateGauge), _s...)
+}
+
+// Warning mocks base method
+func (_m *MockWatchdog) Warning(_param0 string, _param1 ...slf.Param) {
+	_s := []interface{}{_param0}
+	for _, _x := range _param1 {
+		_s = append(_s, _x)
+	}
+	_m.ctrl.Call(_m, "Warning", _s...)
+}
+
+// Warning indicates an expected call of Warning
+func (_mr *MockWatchdogMockRecorder) Warning(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
+	_s := append([]interface{}{arg0}, arg1...)
+	return _mr.mock.ctrl.RecordCallWithMethodType(_mr.mock, "Warning", reflect.TypeOf((*MockWatchdog)(nil).Warning), _s...)
+}
+
+// WithParams mocks base method
+func (_m *MockWatchdog) WithParams(_param0 ...slf.Param) wd.Watchdog {
+	_s := []interface{}{}
+	for _, _x := range _param0 {
+		_s = append(_s, _x)
+	}
+	ret := _m.ctrl.Call(_m, "WithParams", _s...)
+	ret0, _ := ret[0].(wd.Watchdog)
+	return ret0
+}
+
+// WithParams indicates an expected call of WithParams
+func (_mr *MockWatchdogMockRecorder) WithParams(arg0 ...interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCallWithMethodType(_mr.mock, "WithParams", reflect.TypeOf((*MockWatchdog)(nil).WithParams), arg0...)
+}

interfaces/repositories.go

@@ -0,0 +1,15 @@
+package interfaces
+
+import (
+	"elyby/minecraft-skinsystem/model"
+)
+
+type SkinsRepository interface {
+	FindByUsername(username string) (*model.Skin, error)
+	FindByUserId(id int) (*model.Skin, error)
+	Save(skin *model.Skin) error
+}
+
+type CapesRepository interface {
+	FindByUsername(username string) (*model.Cape, error)
+}

lib/data/CapeItem.go

@@ -1,43 +0,0 @@
-package data
-
-import (
-	"io"
-	"os"
-	"fmt"
-	"strings"
-	"crypto/md5"
-	"encoding/hex"
-
-	"elyby/minecraft-skinsystem/lib/services"
-)
-
-type CapeItem struct {
-	File *os.File
-}
-
-func FindCapeByUsername(username string) (CapeItem, error) {
-	var record CapeItem
-	file, err := os.Open(services.RootFolder + "/data/capes/" + strings.ToLower(username) + ".png")
-	if (err != nil) {
-		return record, CapeNotFound{username}
-	}
-
-	record.File = file
-
-	return record, err
-}
-
-func (cape *CapeItem) CalculateHash() string {
-	hasher := md5.New()
-	io.Copy(hasher, cape.File)
-
-	return hex.EncodeToString(hasher.Sum(nil))
-}
-
-type CapeNotFound struct {
-	Who string
-}
-
-func (e CapeNotFound) Error() string {
-	return fmt.Sprintf("Cape file not found. Required username \"%v\"", e.Who)
-}

lib/data/SkinItem.go

@@ -1,100 +0,0 @@
-package data
-
-import (
-	"log"
-	"fmt"
-	"encoding/json"
-
-	"elyby/minecraft-skinsystem/lib/services"
-	"elyby/minecraft-skinsystem/lib/tools"
-
-	"github.com/mediocregopher/radix.v2/redis"
-)
-
-type SkinItem struct {
-	UserId      int    `json:"userId"`
-	Username    string `json:"username"`
-	SkinId      int    `json:"skinId"`
-	Url         string `json:"url"`
-	Is1_8       bool   `json:"is1_8"`
-	IsSlim      bool   `json:"isSlim"`
-	Hash        string `json:"hash"`
-	oldUsername string
-}
-
-const accountIdToUsernameKey string = "hash:username-to-account-id"
-
-func (s *SkinItem) Save() {
-	str, _ := json.Marshal(s)
-	pool, _ := services.RedisPool.Get()
-	pool.Cmd("MULTI")
-
-	// Если пользователь сменил ник, то мы должны удать его ключ
-	if (s.oldUsername != "" && s.oldUsername != s.Username) {
-		pool.Cmd("DEL", tools.BuildKey(s.oldUsername))
-	}
-
-	// Если это новая запись или если пользователь сменил ник, то обновляем значение в хэш-таблице
-	if (s.oldUsername != "" || s.oldUsername != s.Username) {
-		pool.Cmd("HSET", accountIdToUsernameKey, s.UserId, s.Username)
-	}
-
-	pool.Cmd("SET", tools.BuildKey(s.Username), str)
-
-	pool.Cmd("EXEC")
-
-	s.oldUsername = s.Username
-}
-
-func (s *SkinItem) Delete() {
-	if (s.oldUsername == "") {
-		return;
-	}
-
-	pool, _ := services.RedisPool.Get()
-	pool.Cmd("MULTI")
-
-	pool.Cmd("DEL", tools.BuildKey(s.oldUsername))
-	pool.Cmd("HDEL", accountIdToUsernameKey, s.UserId)
-
-	pool.Cmd("EXEC")
-}
-
-func FindSkinByUsername(username string) (SkinItem, error) {
-	var record SkinItem;
-	response := services.RedisPool.Cmd("GET", tools.BuildKey(username));
-	if (response.IsType(redis.Nil)) {
-		return record, SkinNotFound{username}
-	}
-
-	result, err := response.Str()
-	if (err == nil) {
-		decodeErr := json.Unmarshal([]byte(result), &record)
-		if (decodeErr != nil) {
-			log.Println("Cannot decode record data")
-		}
-
-		record.oldUsername = record.Username
-	}
-
-	return record, err
-}
-
-func FindSkinById(id int) (SkinItem, error) {
-	response := services.RedisPool.Cmd("HGET", accountIdToUsernameKey, id);
-	if (response.IsType(redis.Nil)) {
-		return SkinItem{}, SkinNotFound{"unknown"}
-	}
-
-	username, _ := response.Str()
-
-	return FindSkinByUsername(username)
-}
-
-type SkinNotFound struct {
-	Who string
-}
-
-func (e SkinNotFound) Error() string {
-	return fmt.Sprintf("Skin data not found. Required username \"%v\"", e.Who)
-}

lib/data/TexturesResponse.go

@@ -1,21 +0,0 @@
-package data
-
-type TexturesResponse struct {
-	Skin *Skin `json:"SKIN"`
-	Cape *Cape `json:"CAPE,omitempty"`
-}
-
-type Skin struct {
-	Url      string        `json:"url"`
-	Hash     string        `json:"hash"`
-	Metadata *SkinMetadata `json:"metadata,omitempty"`
-}
-
-type SkinMetadata struct {
-	Model string `json:"model"`
-}
-
-type Cape struct {
-	Url      string        `json:"url"`
-	Hash     string        `json:"hash"`
-}

lib/routes/Cape.go

@@ -1,35 +0,0 @@
-package routes
-
-import (
-	"io"
-	"log"
-	"net/http"
-
-	"github.com/gorilla/mux"
-
-	"elyby/minecraft-skinsystem/lib/tools"
-	"elyby/minecraft-skinsystem/lib/data"
-)
-
-func Cape(response http.ResponseWriter, request *http.Request) {
-	username := tools.ParseUsername(mux.Vars(request)["username"])
-	log.Println("request cape for username " + username)
-	rec, err := data.FindCapeByUsername(username)
-	if (err != nil) {
-		http.Redirect(response, request, "http://skins.minecraft.net/MinecraftCloaks/" + username + ".png", 301)
-	}
-
-	request.Header.Set("Content-Type", "image/png")
-	io.Copy(response, rec.File)
-}
-
-func CapeGET(w http.ResponseWriter, r *http.Request) {
-	username := r.URL.Query().Get("name")
-	if username == "" {
-		w.WriteHeader(http.StatusBadRequest)
-		return
-	}
-
-	mux.Vars(r)["username"] = username
-	Cape(w, r)
-}

lib/routes/Face.go

@@ -1,31 +0,0 @@
-package routes
-
-import (
-	"log"
-	"net/http"
-
-	"github.com/gorilla/mux"
-
-	"elyby/minecraft-skinsystem/lib/tools"
-	"elyby/minecraft-skinsystem/lib/data"
-)
-
-const defaultHash = "default"
-
-func Face(w http.ResponseWriter, r *http.Request) {
-	username := tools.ParseUsername(mux.Vars(r)["username"])
-	log.Println("request skin for username " + username);
-	rec, err := data.FindSkinByUsername(username)
-	var hash string
-	if (err != nil || rec.SkinId == 0) {
-		hash = defaultHash;
-	} else {
-		hash = rec.Hash
-	}
-
-	http.Redirect(w, r, tools.BuildElyUrl(buildFaceUrl(hash)), 301);
-}
-
-func buildFaceUrl(hash string) string {
-	return "/minecraft/skin_buffer/faces/" + hash + ".png"
-}

lib/routes/MinecraftPHP.go

@@ -1,28 +0,0 @@
-package routes
-
-import (
-	"net/http"
-
-	"github.com/gorilla/mux"
-)
-
-// Метод-наследие от первой версии системы скинов.
-// Всё ещё иногда используется
-// Просто конвертируем данные и отправляем их в основной обработчик
-func MinecraftPHP(w http.ResponseWriter, r *http.Request) {
-	username := r.URL.Query().Get("name")
-	required := r.URL.Query().Get("type")
-	if username == "" || required == "" {
-		w.WriteHeader(http.StatusBadRequest)
-		return
-	}
-
-	mux.Vars(r)["username"] = username
-	switch required {
-	case "skin": Skin(w, r)
-	case "cloack": Cape(w, r)
-	default: {
-		w.WriteHeader(http.StatusNotFound)
-	}
-	}
-}

lib/routes/NotFound.go

@@ -1,18 +0,0 @@
-package routes
-
-import (
-	"net/http"
-	"encoding/json"
-)
-
-func NotFound(w http.ResponseWriter, r *http.Request)  {
-	json, _ := json.Marshal(map[string]string{
-		"status": "404",
-		"message": "Not Found",
-		"link": "http://docs.ely.by/skin-system.html",
-	})
-
-	w.Header().Set("Content-Type", "application/json")
-	w.WriteHeader(http.StatusNotFound)
-	w.Write(json)
-}

lib/routes/SetSkin.go

@@ -1,29 +0,0 @@
-package routes
-
-import (
-	"net/http"
-	"strconv"
-
-	"elyby/minecraft-skinsystem/lib/data"
-)
-
-func SetSkin(w http.ResponseWriter, r *http.Request) {
-	key := r.Header.Get("X-Ely-key")
-	if key != "43fd2ce61b3f5704dfd729c1f2d6ffdb" {
-		w.WriteHeader(http.StatusForbidden)
-		w.Write([]byte("Nice try"))
-		return
-	}
-
-	skin := new(data.SkinItem)
-	skin.Username  = r.PostFormValue("username")
-	skin.UserId, _ = strconv.Atoi(r.PostFormValue("userId"))
-	skin.SkinId, _ = strconv.Atoi(r.PostFormValue("skinId"))
-	skin.Hash      = r.PostFormValue("hash")
-	skin.Is1_8, _  = strconv.ParseBool(r.PostFormValue("is1_8"))
-	skin.IsSlim, _ = strconv.ParseBool(r.PostFormValue("isSlim"))
-	skin.Url       = r.PostFormValue("url")
-	skin.Save()
-
-	w.Write([]byte("OK"))
-}

lib/routes/Skin.go

@@ -1,34 +0,0 @@
-package routes
-
-import (
-	"log"
-	"net/http"
-
-	"github.com/gorilla/mux"
-
-	"elyby/minecraft-skinsystem/lib/tools"
-	"elyby/minecraft-skinsystem/lib/data"
-)
-
-func Skin(w http.ResponseWriter, r *http.Request) {
-	username := tools.ParseUsername(mux.Vars(r)["username"])
-	log.Println("request skin for username " + username);
-	rec, err := data.FindSkinByUsername(username)
-	if (err != nil) {
-		http.Redirect(w, r, "http://skins.minecraft.net/MinecraftSkins/" + username + ".png", 301)
-		return
-	}
-
-	http.Redirect(w, r, tools.BuildElyUrl(rec.Url), 301);
-}
-
-func SkinGET(w http.ResponseWriter, r *http.Request) {
-	username := r.URL.Query().Get("name")
-	if username == "" {
-		w.WriteHeader(http.StatusBadRequest)
-		return
-	}
-
-	mux.Vars(r)["username"] = username
-	Skin(w, r)
-}

lib/routes/Textures.go

@@ -1,61 +0,0 @@
-package routes
-
-import (
-	"log"
-	"net/http"
-	"encoding/json"
-
-	"github.com/gorilla/mux"
-
-	"elyby/minecraft-skinsystem/lib/data"
-	"elyby/minecraft-skinsystem/lib/tools"
-	"elyby/minecraft-skinsystem/lib/services"
-)
-
-func Textures(w http.ResponseWriter, r *http.Request) {
-	username := tools.ParseUsername(mux.Vars(r)["username"])
-	log.Println("request textures for username " + username)
-
-	rec, err := data.FindSkinByUsername(username)
-	if (err != nil || rec.SkinId == 0) {
-		rec.Url = "http://skins.minecraft.net/MinecraftSkins/" + username + ".png"
-		rec.Hash = string(tools.BuildNonElyTexturesHash(username))
-	} else {
-		rec.Url = tools.BuildElyUrl(rec.Url)
-	}
-
-	textures := data.TexturesResponse{
-		Skin: &data.Skin{
-			Url: rec.Url,
-			Hash: rec.Hash,
-		},
-	}
-
-	if (rec.IsSlim) {
-		textures.Skin.Metadata = &data.SkinMetadata{
-			Model: "slim",
-		}
-	}
-
-	capeRec, err := data.FindCapeByUsername(username)
-	if (err == nil) {
-		capeUrl, err := services.Router.Get("cloaks").URL("username", username)
-		if (err != nil) {
-			log.Println(err.Error())
-		}
-
-		var scheme string = "http://";
-		if (r.TLS != nil) {
-			scheme = "https://"
-		}
-
-		textures.Cape = &data.Cape{
-			Url: scheme + r.Host + capeUrl.String(),
-			Hash: capeRec.CalculateHash(),
-		}
-	}
-
-	response,_ := json.Marshal(textures)
-	w.Header().Set("Content-Type", "application/json")
-	w.Write(response)
-}

lib/services/services.go

@@ -1,15 +0,0 @@
-package services
-
-import (
-	"github.com/mediocregopher/radix.v2/pool"
-	"github.com/streadway/amqp"
-	"github.com/gorilla/mux"
-)
-
-var Router *mux.Router
-
-var RedisPool *pool.Pool
-
-var RabbitMQChannel *amqp.Channel
-
-var RootFolder string

lib/tools/tools.go

@@ -1,40 +0,0 @@
-package tools
-
-import (
-	"strings"
-	"time"
-	"crypto/md5"
-	"strconv"
-	"encoding/hex"
-)
-
-func ParseUsername(username string) string {
-	const suffix = ".png"
-	if strings.HasSuffix(username, suffix) {
-		username = strings.TrimSuffix(username, suffix)
-	}
-
-	return username
-}
-
-func BuildNonElyTexturesHash(username string) string {
-	hour := getCurrentHour()
-	hasher := md5.New()
-	hasher.Write([]byte("non-ely-" + strconv.FormatInt(hour, 10) + "-" + username))
-
-	return hex.EncodeToString(hasher.Sum(nil))
-}
-
-func BuildKey(username string) string {
-	return "username:" + strings.ToLower(username)
-}
-
-func BuildElyUrl(route string) string {
-	return "http://ely.by" + route
-}
-
-func getCurrentHour() int64 {
-	n := time.Now()
-	return time.Date(n.Year(), n.Month(), n.Day(), n.Hour(), 0, 0, 0, time.UTC).Unix()
-}
-

lib/tools/tools_test.go

@@ -1,22 +0,0 @@
-package tools_test
-
-import (
-	"testing"
-	. "elyby/minecraft-skinsystem/lib/tools"
-)
-
-func TestParseUsername(t *testing.T) {
-	if ParseUsername("test.png") != "test" {
-		t.Error("Function should trim .png at end")
-	}
-
-	if ParseUsername("test") != "test" {
-		t.Error("Function should return string itself, if it not contains .png at end")
-	}
-}
-
-func TestBuildKey(t *testing.T) {
-	if BuildKey("Test") != "username:test" {
-		t.Error("Function shound convert string to lower case and concatenate it with usernmae:")
-	}
-}

lib/worker/handlers.go

@@ -1,52 +0,0 @@
-package worker
-
-import (
-	"elyby/minecraft-skinsystem/lib/data"
-	"log"
-)
-
-func handleChangeUsername(model usernameChanged) (bool) {
-	if (model.OldUsername == "") {
-		record := data.SkinItem{
-			UserId: model.AccountId,
-			Username: model.NewUsername,
-		}
-
-		record.Save()
-
-		return true
-	}
-
-	record, err := data.FindSkinByUsername(model.OldUsername)
-	if (err != nil) {
-		log.Println("Exit by not found record")
-		// TODO: я не уверен, что это валидное поведение
-		// Суть в том, что здесь может возникнуть ошибка в том случае, если записи в базе нету
-		// а значит его нужно, как минимум, зарегистрировать
-		return true
-	}
-
-	record.Username = model.NewUsername
-	record.Save()
-
-	log.Println("all saved!")
-
-	return true
-}
-
-func handleSkinChanged(model skinChanged) (bool) {
-	record, err := data.FindSkinById(model.AccountId)
-	if (err != nil) {
-		return true
-	}
-
-	record.SkinId = model.SkinId
-	record.Hash   = model.Hash
-	record.Is1_8  = model.Is1_8
-	record.IsSlim = model.IsSlim
-	record.Url    = model.Url
-
-	record.Save()
-
-	return true
-}

lib/worker/models.go

@@ -1,17 +0,0 @@
-package worker
-
-type usernameChanged struct {
-	AccountId   int    `json:"accountId"`
-	OldUsername string `json:"oldUsername"`
-	NewUsername string `json:"newUsername"`
-}
-
-type skinChanged struct {
-	AccountId int    `json:"userId"`
-	SkinId    int    `json:"skinId"`
-	OldSkinId int    `json:"oldSkinId"`
-	Hash      string `json:"hash"`
-	Is1_8     bool   `json:"is1_8"`
-	IsSlim    bool   `json:"isSlim"`
-	Url       string `json:"url"`
-}

lib/worker/worker.go

@@ -1,88 +0,0 @@
-package worker
-
-import (
-	"log"
-
-	"encoding/json"
-
-	"elyby/minecraft-skinsystem/lib/services"
-)
-
-const exchangeName string = "events"
-const queueName string = "skinsystem-accounts-events"
-
-func Listen() {
-	var err error
-	ch := services.RabbitMQChannel
-
-	err = ch.ExchangeDeclare(
-		exchangeName, // name
-		"topic",      // type
-		true,         // durable
-		false,        // auto-deleted
-		false,        // internal
-		false,        // no-wait
-		nil,          // arguments
-	)
-	failOnError(err, "Failed to declare an exchange")
-
-	_, err = ch.QueueDeclare(
-		queueName, // name
-		true,      // durable
-		false,     // delete when usused
-		false,     // exclusive
-		false,     // no-wait
-		nil,       // arguments
-	)
-	failOnError(err, "Failed to declare a queue")
-
-	err = ch.QueueBind(queueName, "accounts.username-changed", exchangeName, false, nil)
-	failOnError(err, "Failed to bind a queue")
-
-	err = ch.QueueBind(queueName, "accounts.skin-changed", exchangeName, false, nil)
-	failOnError(err, "Failed to bind a queue")
-
-	msgs, err := ch.Consume(
-		queueName, // queue
-		"",        // consumer
-		false,     // auto-ack
-		false,     // exclusive
-		false,     // no-local
-		false,     // no-wait
-		nil,       // args
-	)
-	failOnError(err, "Failed to register a consumer")
-
-	forever := make(chan bool)
-
-	go func() {
-		for d := range msgs {
-			log.Println("Incoming message with routing key " + d.RoutingKey)
-			var result bool = true;
-			switch d.RoutingKey {
-			case "accounts.username-changed":
-				var model usernameChanged
-				json.Unmarshal(d.Body, &model)
-				result = handleChangeUsername(model)
-			case "accounts.skin-changed":
-				var model skinChanged
-				json.Unmarshal(d.Body, &model)
-				result = handleSkinChanged(model)
-			}
-
-			if (result) {
-				d.Ack(false)
-			} else {
-				d.Reject(true)
-			}
-		}
-	}()
-
-	<-forever
-}
-
-func failOnError(err error, msg string) {
-	if err != nil {
-		log.Fatalf("%s: %s", msg, err)
-	}
-}

main.go

@@ -0,0 +1,12 @@
+package main
+
+import (
+	"runtime"
+
+	"elyby/minecraft-skinsystem/cmd"
+)
+
+func main() {
+	runtime.GOMAXPROCS(runtime.NumCPU())
+	cmd.Execute()
+}

minecraft-skinsystem.go

@@ -1,108 +0,0 @@
-package main
-
-import (
-	"os"
-	"log"
-	"runtime"
-	"time"
-	"net/http"
-	"path/filepath"
-
-	"github.com/gorilla/mux"
-	"github.com/streadway/amqp"
-	"github.com/mediocregopher/radix.v2/pool"
-
-	"elyby/minecraft-skinsystem/lib/routes"
-	"elyby/minecraft-skinsystem/lib/services"
-	"elyby/minecraft-skinsystem/lib/worker"
-)
-
-const redisPoolSize int = 10
-
-func main() {
-	log.Println("Starting...")
-
-	runtime.GOMAXPROCS(runtime.NumCPU())
-
-	log.Println("Connecting to redis")
-
-	var redisString = os.Getenv("REDIS_ADDR")
-	if (redisString == "") {
-		redisString = "redis:6379"
-	}
-
-	redisPool, redisErr := pool.New("tcp", redisString, redisPoolSize)
-	if (redisErr != nil) {
-		log.Fatal("Redis unavailable")
-	}
-	log.Println("Connected to redis")
-
-	log.Println("Connecting to rabbitmq")
-	// TODO: rabbitmq становится доступен не сразу. Нужно дождаться, пока он станет доступен, периодически повторяя запросы
-
-	var rabbitmqString = os.Getenv("RABBITMQ_ADDR")
-	if (rabbitmqString == "") {
-		rabbitmqString = "amqp://ely-skinsystem-app:ely-skinsystem-app-password@rabbitmq:5672/%2fely"
-	}
-
-	rabbitConnection, rabbitmqErr := amqp.Dial(rabbitmqString)
-	if (rabbitmqErr != nil) {
-		log.Fatalf("%s", rabbitmqErr)
-	}
-	log.Println("Connected to rabbitmq. Trying to open a channel")
-	rabbitChannel, rabbitmqErr := rabbitConnection.Channel()
-	if (rabbitmqErr != nil) {
-		log.Fatalf("%s", rabbitmqErr)
-	}
-	log.Println("Connected to rabbitmq channel")
-
-	router := mux.NewRouter().StrictSlash(true)
-	router.HandleFunc("/skins/{username}", routes.Skin).Methods("GET").Name("skins")
-	router.HandleFunc("/cloaks/{username}", routes.Cape).Methods("GET").Name("cloaks")
-	router.HandleFunc("/textures/{username}", routes.Textures).Methods("GET").Name("textures")
-	router.HandleFunc("/skins/{username}/face", routes.Face).Methods("GET").Name("faces")
-	router.HandleFunc("/skins/{username}/face.png", routes.Face).Methods("GET").Name("faces")
-	// Legacy
-	router.HandleFunc("/minecraft.php", routes.MinecraftPHP).Methods("GET")
-	router.HandleFunc("/skins/", routes.SkinGET).Methods("GET")
-	router.HandleFunc("/cloaks/", routes.CapeGET).Methods("GET")
-	// 404
-	router.NotFoundHandler = http.HandlerFunc(routes.NotFound)
-
-	apiRouter := router.PathPrefix("/api").Subrouter()
-	apiRouter.HandleFunc("/user/{username}/skin", routes.SetSkin).Methods("POST")
-
-	services.Router = router
-	services.RedisPool = redisPool
-	services.RabbitMQChannel = rabbitChannel
-
-	_, file, _, _ := runtime.Caller(0)
-	services.RootFolder = filepath.Dir(file)
-
-	go func() {
-		period := 5
-		for {
-			time.Sleep(time.Duration(period) * time.Second)
-
-			resp := services.RedisPool.Cmd("PING")
-			if (resp.Err == nil) {
-				// Если редис успешно пинганулся, значит всё хорошо
-				continue
-			}
-
-			log.Println("Redis not pinged. Try to reconnect")
-			newPool, redisErr := pool.New("tcp", redisString, redisPoolSize)
-			if (redisErr != nil) {
-				log.Printf("Cannot reconnect to redis, waiting %d seconds\n", period)
-			} else {
-				services.RedisPool = newPool
-				log.Println("Reconnected")
-			}
-		}
-	}()
-
-	go worker.Listen()
-
-	log.Println("Started");
-	log.Fatal(http.ListenAndServe(":80", router))
-}

model/cape.go

@@ -0,0 +1,9 @@
+package model
+
+import (
+	"io"
+)
+
+type Cape struct {
+	File io.Reader
+}

model/events.go

@@ -0,0 +1,20 @@
+package model
+
+type UsernameChanged struct {
+	AccountId   int    `json:"accountId"`
+	OldUsername string `json:"oldUsername"`
+	NewUsername string `json:"newUsername"`
+}
+
+type SkinChanged struct {
+	AccountId       int    `json:"userId"`
+	Uuid            string `json:"uuid"`
+	SkinId          int    `json:"skinId"`
+	OldSkinId       int    `json:"oldSkinId"`
+	Hash            string `json:"hash"`
+	Is1_8           bool   `json:"is1_8"`
+	IsSlim          bool   `json:"isSlim"`
+	Url             string `json:"url"`
+	MojangTextures  string `json:"mojangTextures"`
+	MojangSignature string `json:"mojangSignature"`
+}

model/skin.go

@@ -0,0 +1,15 @@
+package model
+
+type Skin struct {
+	UserId          int    `json:"userId"`
+	Uuid            string `json:"uuid"`
+	Username        string `json:"username"`
+	SkinId          int    `json:"skinId"`
+	Url             string `json:"url"`
+	Is1_8           bool   `json:"is1_8"`
+	IsSlim          bool   `json:"isSlim"`
+	Hash            string `json:"hash"`
+	MojangTextures  string `json:"mojangTextures"`
+	MojangSignature string `json:"mojangSignature"`
+	OldUsername     string
+}

script/coverage

@@ -0,0 +1,46 @@
+#!/bin/sh
+# Based on https://github.com/mlafeldt/chef-runner/blob/34269dbb726c243dff9764007e7bd7f0fe9ee331/script/coverage
+# Generate test coverage statistics for Go packages.
+#
+# Works around the fact that `go test -coverprofile` currently does not work
+# with multiple packages, see https://code.google.com/p/go/issues/detail?id=6909
+#
+# Usage: script/coverage [--html]
+#
+#     --html      Additionally create HTML report and open it in browser
+#
+
+set -e
+
+workdir=.cover
+profile="$workdir/cover.out"
+mode=count
+
+generate_cover_data() {
+    rm -rf "$workdir"
+    mkdir "$workdir"
+
+    go test -i "$@" # compile dependencies first before serializing go test invocations
+    for pkg in "$@"; do
+        f="$workdir/$(echo $pkg | tr / -).cover"
+        go test -covermode="$mode" -coverprofile="$f" "$pkg"
+    done
+
+    echo "mode: $mode" >"$profile"
+    grep -h -v "^mode:" "$workdir"/*.cover >>"$profile"
+}
+
+show_cover_report() {
+    go tool cover -${1}="$profile"
+}
+
+generate_cover_data $(go list ./... | grep -v /vendor/)
+show_cover_report func
+case "$1" in
+"")
+    ;;
+--html)
+    show_cover_report html ;;
+*)
+    echo >&2 "error: invalid option: $1"; exit 1 ;;
+esac

script/test

@@ -0,0 +1,27 @@
+#!/bin/sh
+# Based on https://github.com/mlafeldt/chef-runner/blob/34269dbb726c243dff9764007e7bd7f0fe9ee331/script/test
+# Run package tests for a file/directory, or all tests if no argument is passed.
+# Useful to e.g. execute package tests for the file currently open in Vim.
+# Usage: script/test [path]
+
+set -e
+
+go_pkg_from_path() {
+    path=$1
+    if test -d "$path"; then
+        dir="$path"
+    else
+        dir=$(dirname "$path")
+    fi
+    (cd "$dir" && go list)
+}
+
+if test $# -gt 0; then
+    pkg=$(go_pkg_from_path "$1")
+    verbose=-v
+else
+    pkg=$(go list ./... | grep -v /vendor/)
+    verbose=
+fi
+
+exec go test ${GOTESTOPTS:-$verbose} $pkg

worker/worder_test.go

@@ -0,0 +1,159 @@
+package worker
+
+import (
+	"testing"
+
+	"github.com/golang/mock/gomock"
+	testify "github.com/stretchr/testify/assert"
+
+	"elyby/minecraft-skinsystem/api/accounts"
+	"elyby/minecraft-skinsystem/db"
+	"elyby/minecraft-skinsystem/interfaces/mock_interfaces"
+	"elyby/minecraft-skinsystem/interfaces/mock_wd"
+	"elyby/minecraft-skinsystem/model"
+)
+
+func TestServices_HandleChangeUsername(t *testing.T) {
+	assert := testify.New(t)
+
+	ctrl := gomock.NewController(t)
+	defer ctrl.Finish()
+
+	services, skinRepo, _, wd := setupMocks(ctrl)
+
+	resultModel := createSourceModel()
+	resultModel.Username = "new_username"
+
+	// Запись о скине существует, никаких осложнений
+	skinRepo.EXPECT().FindByUserId(1).Return(createSourceModel(), nil)
+	skinRepo.EXPECT().Save(resultModel)
+	wd.EXPECT().IncCounter("worker.change_username", int64(1))
+
+	assert.True(services.HandleChangeUsername(&model.UsernameChanged{
+		AccountId: 1,
+		OldUsername: "mock_user",
+		NewUsername: "new_username",
+	}))
+
+	// Событие с пустым ником, т.е это регистрация, так что нужно создать запись о скине
+	skinRepo.EXPECT().FindByUserId(1).Times(0)
+	skinRepo.EXPECT().Save(&model.Skin{UserId: 1, Username: "new_mock"})
+	wd.EXPECT().IncCounter("worker.change_username", int64(1))
+	wd.EXPECT().IncCounter("worker.change_username_empty_old_username", int64(1))
+
+	assert.True(services.HandleChangeUsername(&model.UsernameChanged{
+		AccountId: 1,
+		OldUsername: "",
+		NewUsername: "new_mock",
+	}))
+
+	// В базе системы скинов нет записи об указанном пользователе, так что её нужно восстановить
+	skinRepo.EXPECT().FindByUserId(1).Return(nil, &db.SkinNotFoundError{})
+	skinRepo.EXPECT().Save(&model.Skin{UserId: 1, Username: "new_mock2"})
+	wd.EXPECT().IncCounter("worker.change_username", int64(1))
+	wd.EXPECT().IncCounter("worker.change_username_id_not_found", int64(1))
+
+	assert.True(services.HandleChangeUsername(&model.UsernameChanged{
+		AccountId: 1,
+		OldUsername: "mock_user",
+		NewUsername: "new_mock2",
+	}))
+}
+
+func TestServices_HandleSkinChanged(t *testing.T) {
+	assert := testify.New(t)
+
+	ctrl := gomock.NewController(t)
+	defer ctrl.Finish()
+
+	services, skinRepo, accountsAPI, wd := setupMocks(ctrl)
+
+	event := &model.SkinChanged{
+		AccountId: 1,
+		Uuid: "cdb907ce-84f4-4c38-801d-1e287dca2623",
+		SkinId: 2,
+		OldSkinId: 1,
+		Hash: "f76caa016e07267a05b7daf9ebc7419c",
+		Is1_8: true,
+		IsSlim: false,
+		Url: "http://ely.by/minecraft/skins/69c6740d2993e5d6f6a7fc92420efc29.png",
+		MojangTextures: "new mocked textures base64",
+		MojangSignature: "new mocked signature",
+	}
+
+	resultModel := createSourceModel()
+	resultModel.SkinId = event.SkinId
+	resultModel.Hash = event.Hash
+	resultModel.Is1_8 = event.Is1_8
+	resultModel.IsSlim = event.IsSlim
+	resultModel.Url = event.Url
+	resultModel.MojangTextures = event.MojangTextures
+	resultModel.MojangSignature = event.MojangSignature
+
+	// Запись о скине существует, никаких осложнений
+	skinRepo.EXPECT().FindByUserId(1).Return(createSourceModel(), nil)
+	skinRepo.EXPECT().Save(resultModel)
+	wd.EXPECT().IncCounter("worker.skin_changed", int64(1))
+
+	assert.True(services.HandleSkinChanged(event))
+
+	// Записи о скине не существует, она должна быть восстановлена
+	skinRepo.EXPECT().FindByUserId(1).Return(nil, &db.SkinNotFoundError{"mock_user"})
+	skinRepo.EXPECT().Save(resultModel)
+	accountsAPI.EXPECT().AccountInfo("id", "1").Return(&accounts.AccountInfoResponse{
+		Id: 1,
+		Username: "mock_user",
+		Uuid: "cdb907ce-84f4-4c38-801d-1e287dca2623",
+		Email: "mock-user@ely.by",
+	}, nil)
+	wd.EXPECT().IncCounter("worker.skin_changed", int64(1))
+	wd.EXPECT().IncCounter("worker.skin_changed_id_not_found", int64(1))
+	wd.EXPECT().IncCounter("worker.skin_changed_id_restored", int64(1))
+	wd.EXPECT().Warning(gomock.Any())
+	wd.EXPECT().Info(gomock.Any())
+
+	assert.True(services.HandleSkinChanged(event))
+
+	// Записи о скине не существует, и Ely.by Accounts internal API не знает о таком пользователе
+	skinRepo.EXPECT().FindByUserId(1).Return(nil, &db.SkinNotFoundError{"mock_user"})
+	accountsAPI.EXPECT().AccountInfo("id", "1").Return(nil, &accounts.NotFoundResponse{})
+	wd.EXPECT().IncCounter("worker.skin_changed", int64(1))
+	wd.EXPECT().IncCounter("worker.skin_changed_id_not_found", int64(1))
+	wd.EXPECT().IncCounter("worker.skin_changed_id_not_restored", int64(1))
+	wd.EXPECT().Warning(gomock.Any())
+	wd.EXPECT().Error(gomock.Any())
+
+	assert.True(services.HandleSkinChanged(event))
+}
+
+func createSourceModel() *model.Skin {
+	return &model.Skin{
+		UserId: 1,
+		Uuid: "cdb907ce-84f4-4c38-801d-1e287dca2623",
+		Username: "mock_user",
+		SkinId: 1,
+		Url: "http://ely.by/minecraft/skins/3a345c701f473ac08c8c5b8ecb58ecf3.png",
+		Is1_8: false,
+		IsSlim: false,
+		Hash: "3a345c701f473ac08c8c5b8ecb58ecf3",
+		MojangTextures: "mocked textures base64",
+		MojangSignature: "mocked signature",
+	}
+}
+
+func setupMocks(ctrl *gomock.Controller) (
+	*Services,
+	*mock_interfaces.MockSkinsRepository,
+	*mock_interfaces.MockAccountsAPI,
+	*mock_wd.MockWatchdog,
+) {
+	skinsRepo := mock_interfaces.NewMockSkinsRepository(ctrl)
+	accountApi := mock_interfaces.NewMockAccountsAPI(ctrl)
+	wd := mock_wd.NewMockWatchdog(ctrl)
+
+	return &Services{
+		SkinsRepo: skinsRepo,
+		AccountsAPI: accountApi,
+		Logger: wd,
+	}, skinsRepo, accountApi, wd
+}

worker/worker.go

@@ -0,0 +1,186 @@
+package worker
+
+import (
+	"encoding/json"
+	"fmt"
+	"strconv"
+
+	"github.com/mono83/slf/wd"
+	"github.com/streadway/amqp"
+
+	"elyby/minecraft-skinsystem/interfaces"
+	"elyby/minecraft-skinsystem/model"
+)
+
+type Services struct {
+	Channel     *amqp.Channel
+	SkinsRepo   interfaces.SkinsRepository
+	AccountsAPI interfaces.AccountsAPI
+	Logger      wd.Watchdog
+}
+
+const exchangeName string = "events"
+const queueName string = "skinsystem-accounts-events"
+
+func (service *Services) Run() error {
+	deliveryChannel, err := setupConsume(service.Channel)
+	if err != nil {
+		return err
+	}
+
+	forever := make(chan bool)
+	go func() {
+		for d := range deliveryChannel {
+			service.HandleDelivery(&d)
+		}
+	}()
+	<-forever
+
+	return nil
+}
+
+func (service *Services) HandleDelivery(delivery *amqp.Delivery) {
+	service.Logger.Debug("Incoming message with routing key " + delivery.RoutingKey)
+	var result bool = true
+	switch delivery.RoutingKey {
+	case "accounts.username-changed":
+		var event *model.UsernameChanged
+		json.Unmarshal(delivery.Body, &event)
+		result = service.HandleChangeUsername(event)
+	case "accounts.skin-changed":
+		var event *model.SkinChanged
+		json.Unmarshal(delivery.Body, &event)
+		result = service.HandleSkinChanged(event)
+	default:
+		service.Logger.Info("Unknown delivery with routing key " + delivery.RoutingKey)
+		delivery.Ack(false)
+		return
+	}
+
+	if result {
+		delivery.Ack(false)
+	} else {
+		delivery.Reject(true)
+	}
+}
+
+func (service *Services) HandleChangeUsername(event *model.UsernameChanged) bool {
+	service.Logger.IncCounter("worker.change_username", 1)
+	if event.OldUsername == "" {
+		service.Logger.IncCounter("worker.change_username_empty_old_username", 1)
+		record := &model.Skin{
+			UserId:   event.AccountId,
+			Username: event.NewUsername,
+		}
+
+		service.SkinsRepo.Save(record)
+
+		return true
+	}
+
+	record, err := service.SkinsRepo.FindByUserId(event.AccountId)
+	if err != nil {
+		// TODO: если это не SkinNotFound, то нужно логгировать в Sentry
+		service.Logger.IncCounter("worker.change_username_id_not_found", 1)
+		record = &model.Skin{
+			UserId: event.AccountId,
+		}
+	}
+
+	record.Username = event.NewUsername
+	service.SkinsRepo.Save(record)
+
+	return true
+}
+
+// TODO: возможно стоит добавить проверку на совпадение id аккаунтов
+func (service *Services) HandleSkinChanged(event *model.SkinChanged) bool {
+	service.Logger.IncCounter("worker.skin_changed", 1)
+	var record *model.Skin
+	record, err := service.SkinsRepo.FindByUserId(event.AccountId)
+	if err != nil {
+		service.Logger.IncCounter("worker.skin_changed_id_not_found", 1)
+		service.Logger.Warning("Cannot find user id. Trying to search.")
+		response, err := service.AccountsAPI.AccountInfo("id", strconv.Itoa(event.AccountId))
+		if err != nil {
+			service.Logger.IncCounter("worker.skin_changed_id_not_restored", 1)
+			service.Logger.Error(fmt.Sprintf("Cannot restore user info. %+v\n", err))
+			// TODO: логгировать в какой-нибудь Sentry, если там не 404
+			return true
+		}
+
+		service.Logger.IncCounter("worker.skin_changed_id_restored", 1)
+		service.Logger.Info("User info successfully restored.")
+
+		record = &model.Skin{
+			UserId: response.Id,
+			Username: response.Username,
+		}
+	}
+
+	record.Uuid = event.Uuid
+	record.SkinId = event.SkinId
+	record.Hash = event.Hash
+	record.Is1_8 = event.Is1_8
+	record.IsSlim = event.IsSlim
+	record.Url = event.Url
+	record.MojangTextures = event.MojangTextures
+	record.MojangSignature = event.MojangSignature
+
+	service.SkinsRepo.Save(record)
+
+	return true
+}
+
+func setupConsume(channel *amqp.Channel) (<-chan amqp.Delivery, error) {
+	var err error
+	err = channel.ExchangeDeclare(
+		exchangeName, // name
+		"topic",      // type
+		true,         // durable
+		false,        // auto-deleted
+		false,        // internal
+		false,        // no-wait
+		nil,          // arguments
+	)
+	if err != nil {
+		return nil, err
+	}
+
+	_, err = channel.QueueDeclare(
+		queueName, // name
+		true,      // durable
+		false,     // delete when usused
+		false,     // exclusive
+		false,     // no-wait
+		nil,       // arguments
+	)
+	if err != nil {
+		return nil, err
+	}
+
+	err = channel.QueueBind(queueName, "accounts.username-changed", exchangeName, false, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	err = channel.QueueBind(queueName, "accounts.skin-changed", exchangeName, false, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	deliveryChannel, err := channel.Consume(
+		queueName, // queue
+		"",        // consumer
+		false,     // auto-ack
+		false,     // exclusive
+		false,     // no-local
+		false,     // no-wait
+		nil,       // args
+	)
+	if err != nil {
+		return nil, err
+	}
+
+	return deliveryChannel, nil
+}