Merge branch 'master' into ely

Prepare 4.3.0 release
Bump Go version to 1.13
2025-05-31 14:11:51 +05:30 · 2019-11-08 02:13:05 +03:00 · 2019-11-08 02:12:31 +03:00 · 2019-11-08 02:08:10 +03:00 · 2019-11-08 01:54:16 +03:00 · 2019-11-08 01:32:26 +03:00
82 changed files with 6470 additions and 838 deletions
--- a/.dockerignore
+++ b/.dockerignore
@@ -1,2 +1,2 @@
-# Игнорим данные, т.к. они не нужны для внутреннего содержимого этого контейнера
 data
+vendor
--- a/.gitignore
+++ b/.gitignore
@@ -1,6 +1,5 @@
-# IDEA
-/.idea
-
-# Docker Compose file
+.idea
 docker-compose.yml
 docker-compose.override.yml
+vendor
+.cover
--- a/.travis.yml
+++ b/.travis.yml
@@ -0,0 +1,42 @@
+sudo: required
+
+language: go
+go:
+  - 1.13
+
+services:
+  - docker
+
+stages:
+  - test
+  - name: deploy
+    if: branch = master OR tag IS present
+
+install:
+  - go get -u github.com/golang/dep/cmd/dep
+  - dep ensure
+
+jobs:
+  include:
+    - stage: test
+      script:
+      - go test -v -race -coverprofile=coverage.txt -covermode=atomic ./...
+      - bash <(curl -s https://codecov.io/bash)
+    - stage: deploy
+      script:
+      - docker login -u="$DOCKER_USERNAME" -p="$DOCKER_PASSWORD"
+      - export DOCKER_TAG="${TRAVIS_TAG:-dev}"
+      - export APP_VERSION="${TRAVIS_TAG:-dev-${TRAVIS_COMMIT:0:7}}"
+      - >
+        env CGO_ENABLED=0 GOOS=linux GOARCH=amd64
+        go build
+        -o release/chrly
+        -ldflags '-extldflags "-static" -X github.com/elyby/chrly/bootstrap.version=$APP_VERSION'
+        main.go
+      - docker build -t elyby/chrly:$DOCKER_TAG .
+      - docker push elyby/chrly:$DOCKER_TAG
+      - |
+        if [ ! -z ${TRAVIS_TAG+x} ] && [[ "$TRAVIS_TAG" != *"-"* ]]; then
+          docker tag elyby/chrly:$DOCKER_TAG elyby/chrly:latest
+          docker push elyby/chrly:latest
+        fi
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -0,0 +1,83 @@
+# Changelog
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased] - xxxx-xx-xx
+
+## [4.3.0] - 2019-11-08
+### Added
+- 403 Forbidden errors from the Mojang's API are now logged
+- `QUEUE_LOOP_DELAY` configuration param to adjust Mojang's textures queue performance
+
+### Changed
+- Mojang's textures queue loop is now has an iteration delay of 2.5 seconds (was 1) 
+- Bumped Go version to 1.13.
+
+## [4.2.3] - 2019-10-03
+### Changed
+- Mojang's textures queue batch size [reduced to 10](https://wiki.vg/index.php?title=Mojang_API&type=revision&diff=14964&oldid=14954).
+- 400 BadRequest errors from the Mojang's API are now logged.
+
+## [4.2.2] - 2019-06-19
+### Fixed
+- GC for in-memory textures cache has not been initialized.
+
+## [4.2.1] - 2019-05-06
+### Changed
+- Improved Keep-Alive settings for HTTP client used to perform requests to Mojang's APIs.
+- Mojang's textures queue now has static delay of 1 second after each iteration to prevent strange `429` errors.
+- Mojang's textures queue now caches even errored responses for signed textures to avoid `429` errors.
+- Mojang's textures queue now caches textures data for 70 seconds to avoid strange `429` errors.
+- Mojang's textures queue now doesn't log timeout errors.
+
+### Fixed
+- Panic when Redis connection is broken.
+- Duplication of Redis connections pool for Mojang's textures queue.
+- Removed validation rules for `hash` field.
+
+## [4.2.0] - 2019-05-02
+### Added
+- `CHANGELOG.md` file.
+- [#1](https://github.com/elyby/chrly/issues/1): Restored Mojang skins proxy.
+- New StatsD metrics:
+  - Counters:
+    - `ely.skinsystem.{hostname}.app.mojang_textures.invalid_username`
+    - `ely.skinsystem.{hostname}.app.mojang_textures.request`
+    - `ely.skinsystem.{hostname}.app.mojang_textures.usernames.cache_hit_nil`
+    - `ely.skinsystem.{hostname}.app.mojang_textures.usernames.queued`
+    - `ely.skinsystem.{hostname}.app.mojang_textures.usernames.cache_hit`
+    - `ely.skinsystem.{hostname}.app.mojang_textures.already_in_queue`
+    - `ely.skinsystem.{hostname}.app.mojang_textures.usernames.uuid_miss`
+    - `ely.skinsystem.{hostname}.app.mojang_textures.usernames.uuid_hit`
+    - `ely.skinsystem.{hostname}.app.mojang_textures.textures.cache_hit`
+    - `ely.skinsystem.{hostname}.app.mojang_textures.textures.request`
+  - Gauges:
+    - `ely.skinsystem.{hostname}.app.mojang_textures.usernames.iteration_size`
+    - `ely.skinsystem.{hostname}.app.mojang_textures.usernames.queue_size`
+  - Timers:
+    - `ely.skinsystem.{hostname}.app.mojang_textures.result_time`
+    - `ely.skinsystem.{hostname}.app.mojang_textures.usernames.round_time`
+    - `ely.skinsystem.{hostname}.app.mojang_textures.textures.request_time`
+
+### Changed
+- Bumped Go version to 1.12.
+- Bumped Alpine version to 3.9.3.
+
+### Fixed
+- `/textures` request no longer proxies request to Mojang in a case when there is no information about the skin,
+  but there is a cape.
+- [#5](https://github.com/elyby/chrly/issues/5): Return Redis connection to the pool after commands are executed
+
+### Removed
+- `hash` field from `/textures` response because the game doesn't use it and calculates hash by getting the filename
+  from the textures link instead.
+- `hash` field from `POST /api/skins` endpoint.
+
+[Unreleased]: https://github.com/elyby/chrly/compare/4.3.0...HEAD
+[4.3.0]: https://github.com/elyby/chrly/compare/4.2.3...4.3.0
+[4.2.3]: https://github.com/elyby/chrly/compare/4.2.2...4.2.3
+[4.2.2]: https://github.com/elyby/chrly/compare/4.2.1...4.2.2
+[4.2.1]: https://github.com/elyby/chrly/compare/4.2.0...4.2.1
+[4.2.0]: https://github.com/elyby/chrly/compare/4.1.1...4.2.0
--- a/27
+++ b/27
@@ -1,21 +1,14 @@
-FROM golang:1.7-alpine
-
-RUN apk add --no-cache git
-
-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
+FROM alpine:3.9.3

 EXPOSE 80

-VOLUME ["/go/src/app"]
+RUN apk add --no-cache ca-certificates

-CMD ["go-wrapper", "run"]
+ENV STORAGE_REDIS_HOST=redis
+ENV STORAGE_FILESYSTEM_HOST=/data
+
+COPY docker-entrypoint.sh /usr/local/bin/
+COPY release/chrly /usr/local/bin/
+
+ENTRYPOINT ["docker-entrypoint.sh"]
+CMD ["serve"]
--- a/Gopkg.lock
+++ b/Gopkg.lock
@@ -0,0 +1,334 @@
+# This file is autogenerated, do not edit; changes may be undone by the next 'dep ensure'.
+
+
+[[projects]]
+  digest = "1:8855efc2aff3afd6319da41b22a8ca1cfd1698af05a24852c01636ba65b133f0"
+  name = "github.com/SermoDigital/jose"
+  packages = [
+    ".",
+    "crypto",
+    "jws",
+    "jwt",
+  ]
+  pruneopts = ""
+  revision = "f6df55f235c24f236d11dbcf665249a59ac2021f"
+  version = "1.1"
+
+[[projects]]
+  digest = "1:c7b11da9bf0707e6920e1b361fbbbbe9b277ef3a198377baa4527f6e31049be0"
+  name = "github.com/certifi/gocertifi"
+  packages = ["."]
+  pruneopts = ""
+  revision = "3fd9e1adb12b72d2f3f82191d49be9b93c69f67c"
+  version = "2017.07.27"
+
+[[projects]]
+  digest = "1:56c130d885a4aacae1dd9c7b71cfe39912c7ebc1ff7d2b46083c8812996dc43b"
+  name = "github.com/davecgh/go-spew"
+  packages = ["spew"]
+  pruneopts = ""
+  revision = "346938d642f2ec3594ed81d874461961cd0faa76"
+  version = "v1.1.0"
+
+[[projects]]
+  digest = "1:9f1e571696860f2b4f8a241b43ce91c6085e7aaed849ccca53f590a4dc7b95bd"
+  name = "github.com/fsnotify/fsnotify"
+  packages = ["."]
+  pruneopts = ""
+  revision = "629574ca2a5df945712d3079857300b5e4da0236"
+  version = "v1.4.2"
+
+[[projects]]
+  branch = "master"
+  digest = "1:904b0b847f705de43c15e6c8f3dd639044db5601dedfb2f3fdb3021a28491d15"
+  name = "github.com/getsentry/raven-go"
+  packages = ["."]
+  pruneopts = ""
+  revision = "919484f041ea21e7e27be291cee1d6af7bc98864"
+
+[[projects]]
+  digest = "1:530233672f656641b365f8efb38ed9fba80e420baff2ce87633813ab3755ed6d"
+  name = "github.com/golang/mock"
+  packages = ["gomock"]
+  pruneopts = ""
+  revision = "51421b967af1f557f93a59e0057aaf15ca02e29c"
+  version = "v1.2.0"
+
+[[projects]]
+  digest = "1:65c7ed49d9f36dd4752e43013323fa9229db60b29aa4f5a75aaecda3130c74e2"
+  name = "github.com/gorilla/mux"
+  packages = ["."]
+  pruneopts = ""
+  revision = "c5c6c98bc25355028a63748a498942a6398ccd22"
+  version = "v1.7.1"
+
+[[projects]]
+  digest = "1:5eeb4bfc6db411dbb34a6d9e5d49a9956b160d59fd004ee8f03fe53c9605c082"
+  name = "github.com/h2non/gock"
+  packages = ["."]
+  pruneopts = ""
+  revision = "ba88c4862a27596539531ce469478a91bc5a0511"
+  version = "v1.0.14"
+
+[[projects]]
+  digest = "1:0f31ddb2589297fc1d716f45b34e34bff34e968de1aa239543274c87522e86f4"
+  name = "github.com/h2non/parth"
+  packages = ["."]
+  pruneopts = ""
+  revision = "b4df798d65426f8c8ab5ca5f9987aec5575d26c9"
+  version = "v2.0.1"
+
+[[projects]]
+  branch = "master"
+  digest = "1:8017a99c7fa4dac90c7a34e08d5f890043fc27e91e561f3267a09f65595b158c"
+  name = "github.com/hashicorp/hcl"
+  packages = [
+    ".",
+    "hcl/ast",
+    "hcl/parser",
+    "hcl/printer",
+    "hcl/scanner",
+    "hcl/strconv",
+    "hcl/token",
+    "json/parser",
+    "json/scanner",
+    "json/token",
+  ]
+  pruneopts = ""
+  revision = "8f6b1344a92ff8877cf24a5de9177bf7d0a2a187"
+
+[[projects]]
+  digest = "1:870d441fe217b8e689d7949fef6e43efbc787e50f200cb1e70dbca9204a1d6be"
+  name = "github.com/inconshreveable/mousetrap"
+  packages = ["."]
+  pruneopts = ""
+  revision = "76626ae9c91c4f2a10f34cad8ce83ea42c93bb75"
+  version = "v1.0"
+
+[[projects]]
+  digest = "1:1ce378ab2352c756c6d7a0172c22ecbd387659d32712a4ce3bc474273309a5dc"
+  name = "github.com/magiconair/properties"
+  packages = ["."]
+  pruneopts = ""
+  revision = "be5ece7dd465ab0765a9682137865547526d1dfb"
+  version = "v1.7.3"
+
+[[projects]]
+  branch = "master"
+  digest = "1:19a9f4143462f07553e9bf6ae0f1b8633a2c44763b1df90d4e9e49f51cd8423a"
+  name = "github.com/mediocregopher/radix.v2"
+  packages = [
+    "cluster",
+    "pool",
+    "redis",
+    "util",
+  ]
+  pruneopts = ""
+  revision = "b67df6e626f993b64b3ca9f4b8630900e61002e3"
+
+[[projects]]
+  branch = "master"
+  digest = "1:c9ede10a9ded782d25d1f0be87c680e11409c23554828f19a19d691a95e76130"
+  name = "github.com/mitchellh/mapstructure"
+  packages = ["."]
+  pruneopts = ""
+  revision = "d0303fe809921458f417bcf828397a65db30a7e4"
+
+[[projects]]
+  branch = "master"
+  digest = "1:c62e653e0a78bcf08fd56c764e5725e604693ffbd35b2b283b360f174d073a75"
+  name = "github.com/mono83/slf"
+  packages = [
+    ".",
+    "filters",
+    "params",
+    "rays",
+    "recievers",
+    "recievers/sentry",
+    "recievers/statsd",
+    "recievers/writer",
+    "wd",
+  ]
+  pruneopts = ""
+  revision = "79153e9636db86e1c6b74d74dd04176f257a4f2d"
+
+[[projects]]
+  branch = "master"
+  digest = "1:270261c28f6e71a8a31b9d308ec9145147040fd80d21563307767a8e844bfabc"
+  name = "github.com/mono83/udpwriter"
+  packages = ["."]
+  pruneopts = ""
+  revision = "a064bd7e3acfda563ea680b913b9ef24b7a73e15"
+
+[[projects]]
+  digest = "1:049b5bee78dfdc9628ee0e557219c41f683e5b06c5a5f20eaba0105ccc586689"
+  name = "github.com/pelletier/go-buffruneio"
+  packages = ["."]
+  pruneopts = ""
+  revision = "c37440a7cf42ac63b919c752ca73a85067e05992"
+  version = "v0.2.0"
+
+[[projects]]
+  digest = "1:6d5a9728ae27e477a07bb69f02ea0bade74eb8b0c7346d046337904bbf7af065"
+  name = "github.com/pelletier/go-toml"
+  packages = ["."]
+  pruneopts = ""
+  revision = "5ccdfb18c776b740aecaf085c4d9a2779199c279"
+  version = "v1.0.0"
+
+[[projects]]
+  digest = "1:256484dbbcd271f9ecebc6795b2df8cad4c458dd0f5fd82a8c2fa0c29f233411"
+  name = "github.com/pmezard/go-difflib"
+  packages = ["difflib"]
+  pruneopts = ""
+  revision = "792786c7400a136282c1664665ae0a8db921c6c2"
+  version = "v1.0.0"
+
+[[projects]]
+  branch = "master"
+  digest = "1:c189f11a84aa8b868a4b7cd4605653160424ab299cf7cfb1c5bd2740b949928f"
+  name = "github.com/spf13/afero"
+  packages = [
+    ".",
+    "mem",
+  ]
+  pruneopts = ""
+  revision = "ee1bd8ee15a1306d1f9201acc41ef39cd9f99a1b"
+
+[[projects]]
+  digest = "1:6ff9b74bfea2625f805edec59395dc37e4a06458dd3c14e3372337e3d35a2ed6"
+  name = "github.com/spf13/cast"
+  packages = ["."]
+  pruneopts = ""
+  revision = "acbeb36b902d72a7a4c18e8f3241075e7ab763e4"
+  version = "v1.1.0"
+
+[[projects]]
+  digest = "1:a1403cc8a94b8d7956ee5e9694badef0e7b051af289caad1cf668331e3ffa4f6"
+  name = "github.com/spf13/cobra"
+  packages = ["."]
+  pruneopts = ""
+  revision = "ef82de70bb3f60c65fb8eebacbb2d122ef517385"
+  version = "v0.0.3"
+
+[[projects]]
+  branch = "master"
+  digest = "1:5cb42b990db5dc48b8bc23b6ee77b260713ba3244ca495cd1ed89533dc482a49"
+  name = "github.com/spf13/jwalterweatherman"
+  packages = ["."]
+  pruneopts = ""
+  revision = "12bd96e66386c1960ab0f74ced1362f66f552f7b"
+
+[[projects]]
+  digest = "1:cbaf13cdbfef0e4734ed8a7504f57fe893d471d62a35b982bf6fb3f036449a66"
+  name = "github.com/spf13/pflag"
+  packages = ["."]
+  pruneopts = ""
+  revision = "298182f68c66c05229eb03ac171abe6e309ee79a"
+  version = "v1.0.3"
+
+[[projects]]
+  digest = "1:90fe60ab6f827e308b0c8cc1e11dce8ff1e96a927c8b171271a3cb04dd517606"
+  name = "github.com/spf13/viper"
+  packages = ["."]
+  pruneopts = ""
+  revision = "9e56dacc08fbbf8c9ee2dbc717553c758ce42bc9"
+  version = "v1.3.2"
+
+[[projects]]
+  digest = "1:711eebe744c0151a9d09af2315f0bb729b2ec7637ef4c410fa90a18ef74b65b6"
+  name = "github.com/stretchr/objx"
+  packages = ["."]
+  pruneopts = ""
+  revision = "477a77ecc69700c7cdeb1fa9e129548e1c1c393c"
+  version = "v0.1.1"
+
+[[projects]]
+  digest = "1:381bcbeb112a51493d9d998bbba207a529c73dbb49b3fd789e48c63fac1f192c"
+  name = "github.com/stretchr/testify"
+  packages = [
+    "assert",
+    "mock",
+    "require",
+    "suite",
+  ]
+  pruneopts = ""
+  revision = "ffdc059bfe9ce6a4e144ba849dbedead332c6053"
+  version = "v1.3.0"
+
+[[projects]]
+  branch = "master"
+  digest = "1:86e6712cfd4070a2120c03fcec41cfcbbc51813504a74e28d74479edfaf669ee"
+  name = "github.com/tevino/abool"
+  packages = ["."]
+  pruneopts = ""
+  revision = "9b9efcf221b50905aab9bbabd3daed56dc10f339"
+
+[[projects]]
+  digest = "1:061754b9de261d8e1cf804970dff7b3e105d1cb4883ef446dbe911489ba8e9eb"
+  name = "github.com/thedevsaddam/govalidator"
+  packages = ["."]
+  pruneopts = ""
+  revision = "0413a0eb80cac8ab2d666639130658ce49a0c967"
+  version = "v1.9.6"
+
+[[projects]]
+  branch = "master"
+  digest = "1:19adc71218d62052cd18b83ebaab77961378876094081f4b1581ca28ef80395d"
+  name = "golang.org/x/sys"
+  packages = ["unix"]
+  pruneopts = ""
+  revision = "7ddbeae9ae08c6a06a59597f0c9edbc5ff2444ce"
+
+[[projects]]
+  branch = "master"
+  digest = "1:653926785eac385fd1d61dc16360a5194c68d4bf2541234363a9375d2e88a039"
+  name = "golang.org/x/text"
+  packages = [
+    "internal/gen",
+    "internal/triegen",
+    "internal/ucd",
+    "transform",
+    "unicode/cldr",
+    "unicode/norm",
+  ]
+  pruneopts = ""
+  revision = "bd91bbf73e9a4a801adbfb97133c992678533126"
+
+[[projects]]
+  branch = "v2"
+  digest = "1:81314a486195626940617e43740b4fa073f265b0715c9f54ce2027fee1cb5f61"
+  name = "gopkg.in/yaml.v2"
+  packages = ["."]
+  pruneopts = ""
+  revision = "eb3733d160e74a9c7e442f435eb3bea458e1d19f"
+
+[solve-meta]
+  analyzer-name = "dep"
+  analyzer-version = 1
+  input-imports = [
+    "github.com/SermoDigital/jose/crypto",
+    "github.com/SermoDigital/jose/jws",
+    "github.com/getsentry/raven-go",
+    "github.com/golang/mock/gomock",
+    "github.com/gorilla/mux",
+    "github.com/h2non/gock",
+    "github.com/mediocregopher/radix.v2/pool",
+    "github.com/mediocregopher/radix.v2/redis",
+    "github.com/mediocregopher/radix.v2/util",
+    "github.com/mono83/slf",
+    "github.com/mono83/slf/rays",
+    "github.com/mono83/slf/recievers/sentry",
+    "github.com/mono83/slf/recievers/statsd",
+    "github.com/mono83/slf/recievers/writer",
+    "github.com/mono83/slf/wd",
+    "github.com/spf13/cobra",
+    "github.com/spf13/viper",
+    "github.com/stretchr/testify/assert",
+    "github.com/stretchr/testify/mock",
+    "github.com/stretchr/testify/suite",
+    "github.com/tevino/abool",
+    "github.com/thedevsaddam/govalidator",
+  ]
+  solver-name = "gps-cdcl"
+  solver-version = 1
--- a/Gopkg.toml
+++ b/Gopkg.toml
@@ -0,0 +1,51 @@
+ignored = ["github.com/elyby/chrly"]
+
+[[constraint]]
+  name = "github.com/gorilla/mux"
+  version = "^1.6.1"
+
+[[constraint]]
+  name = "github.com/mediocregopher/radix.v2"
+  branch = "master"
+
+[[constraint]]
+  name = "github.com/mono83/slf"
+  branch = "master"
+
+[[constraint]]
+  name = "github.com/spf13/cobra"
+  version = "^0.0.3"
+
+[[constraint]]
+  name = "github.com/spf13/viper"
+  version = "^1.0.0"
+
+[[constraint]]
+  name = "github.com/getsentry/raven-go"
+  branch = "master"
+
+[[constraint]]
+  name = "github.com/SermoDigital/jose"
+  version = "~1.1.0"
+
+[[constraint]]
+  name = "github.com/thedevsaddam/govalidator"
+  version = "^1.9.6"
+
+[[constraint]]
+  name = "github.com/tevino/abool"
+  branch = "master"
+
+# Testing dependencies
+
+[[constraint]]
+  name = "github.com/stretchr/testify"
+  version = "^1.3.0"
+
+[[constraint]]
+  name = "github.com/golang/mock"
+  version = "^1.0.0"
+
+[[constraint]]
+  name = "github.com/h2non/gock"
+  version = "^1.0.6"
--- a/201
+++ b/201
@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2018 Ely.by (http://ely.by)
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
--- a/README.md
+++ b/README.md
@@ -1,38 +1,271 @@
-# Это заготовка для нормального файла
+# Chrly

-Для настройки Dev-окружения нужно склонировать проект в удобное место,
-за тем сделать символьную ссылку в свой GOPATH:
+[![Written in Go][ico-lang]][link-go]
+[![Build Status][ico-build]][link-build]
+[![Coverage][ico-coverage]][link-coverage]
+[![Keep a Changelog][ico-changelog]](CHANGELOG.md)
+[![Software License][ico-license]](LICENSE)

-```sh
-# Выполнять, находясь внутри директории репозитория
-mkdir -p $GOPATH/src/elyby
-ln -s $PWD $GOPATH/src/elyby/minecraft-skinsystem
+Chrly is a lightweight implementation of Minecraft skins system server with ability to proxy requests to Mojang's
+skins system. It's packaged and distributed as a Docker image and can be downloaded from
+[Dockerhub](https://hub.docker.com/r/elyby/chrly/). App is written in Go, can withstand heavy loads and is
+production ready.
+
+## Installation
+
+You can easily install Chrly using [docker-compose](https://docs.docker.com/compose/). The configuration below (save
+it as `docker-compose.yml`) can be used to start a Chrly server. It relies on `CHRLY_SECRET` environment variable
+that you must set before running `docker-compose up -d`. Other possible variables are described below.
+
+```yml
+version: '2'
+services:
+  app:
+    image: elyby/chrly
+    hostname: chrly0
+    restart: always
+    links:
+      - redis
+    volumes:
+      - ./data/capes:/data/capes
+    ports:
+      - "80:80"
+    environment:
+      CHRLY_SECRET: replace_this_value_in_production
+
+  redis:
+    image: redis:4.0-32bit
+    restart: always
+    volumes:
+      - ./data/redis:/data
 ```

-Или можно склонировать репозиторий сразу в нужную локацию:
+Chrly uses some volumes to persist storage for capes and Redis database. The configuration above mounts them to
+the host machine to do not lose data on container recreations.
+
+### Config
+
+Application's configuration is based on the environment variables. You can adjust config by modifying `environment` key
+inside your `docker-compose.yml` file. After value will have been changed, container should be stopped and recreated.
+If environment variables have been changed, Docker will automatically recreate the container, so you only need to `stop`
+and `up` it:

 ```sh
-git clone git@bitbucket.org:elyby/minecraft-skinsystem.git $GOPATH/src/elyby/minecraft-skinsystem
+docker-compose stop app
+docker-compose up -d app
 ```

-Нужно скопировать правильный docker-compose файл для желаемого окружения:
+**Variables to adjust:**

-```sh
-cp docker-compose.dev.yml docker-compose.yml  # dev env
-cp docker-compose.prod.yml docker-compose.yml # prod env
+| ENV                | Description                                                                                     | Example                                   |
+|--------------------|-------------------------------------------------------------------------------------------------|-------------------------------------------|
+| STORAGE_REDIS_POOL | By default, Chrly creates pool with 10 connection, but you may want to increase it              | `20`                                      |
+| STATSD_ADDR        | StatsD can be used to collect metrics                                                           | `localhost:8125`                          |
+| SENTRY_DSN         | Sentry can be used to collect app errors                                                        | `https://public:private@your.sentry.io/1` |
+| QUEUE_LOOP_DELAY   | Parameter is sets the delay before each iteration of the Mojang's textures queue (milliseconds) | `3200`                                    |
+
+If something goes wrong, you can always access logs by executing `docker-compose logs -f app`.
+
+## Endpoints
+
+Each endpoint that accepts `username` as a part of an url takes it case insensitive. `.png` part can be omitted too.
+
+#### `GET /skins/{username}.png`
+
+This endpoint responds to requested `username` with a skin texture. If user's skin was set as texture's link, then it'll
+respond with the `301` redirect to that url. If the skin entry isn't found, it'll request textures information from
+Mojang's API and if it has a skin, than it'll return a `301` redirect to it.
+
+#### `GET /cloaks/{username}.png`
+
+It responds to requested `username` with a cape texture. If the cape entry isn't found, it'll request textures
+information from Mojang's API and if it has a cape, than it'll return a `301` redirect to it.
+
+#### `GET /textures/{username}`
+
+This endpoint forms response payloads as if it was the `textures`' property, but without base64 encoding. For example:
+
+```json
+{
+    "SKIN": {
+        "url": "http://example.com/skin.png",
+        "metadata": {
+            "model": "slim"
+        }
+    },
+    "CAPE": {
+        "url": "http://example.com/cape.png"
+    }
+}
 ```

-И за тем всё это поднять:
+If both the skin and the cape entries aren't found, it'll request textures information from Mojang's API and if it has
+a textures property, than it'll return decoded contents.
+
+That request is handy in case when your server implements authentication for a game server (e.g. join/hasJoined
+operation) and you have to respond with hasJoined request with an actual user textures. You have to simply send request
+to the Chrly server and put the result in your hasJoined response.
+
+#### `GET /textures/signed/{username}`
+
+Actually, it's [Ely.by](http://ely.by) feature called [Server Skins System](http://ely.by/server-skins-system), but if
+you have your own source of Mojang's signatures, then you can pass it with textures and it'll be displayed in response
+of this endpoint. Received response should be directly sent to the client without any modification via game server API.
+
+Response example:
+
+```json
+{
+    "id": "0f657aa8bfbe415db7005750090d3af3",
+    "name": "username",
+    "properties": [
+        {
+            "name": "textures",
+            "signature": "signature value",
+            "value": "base64 encoded value"
+        },
+        {
+            "name": "chrly",
+            "value": "how do you tame a horse in Minecraft?"
+        }
+    ]
+}
+```
+
+If there is no requested `username` or `mojangSignature` field isn't set, `204` status code will be sent.
+
+You can adjust URL to `/textures/signed/{username}?proxy=true` to obtain textures information for provided username
+from Mojang's API. The textures will contain unmodified json with addition property with name "chrly" as shown in
+the example above.
+
+#### `GET /skins?name={username}`
+
+Equivalent of the `GET /skins/{username}.png`, but constructed especially for old Minecraft versions, where username
+placeholder wasn't used.
+
+#### `GET /cloaks?name={username}`
+
+Equivalent of the `GET /cloaks/{username}.png`, but constructed especially for old Minecraft versions, where username
+placeholder wasn't used.
+
+### Records manipulating API
+
+Each request to the internal API should be performed with the Bearer authorization header. Example curl request:

 ```sh
+curl -X POST -i http://chrly.domain.com/api/skins \
+  -H "Authorization: Bearer Ym9zY236Ym9zY28="
+```
+
+You can obtain token by executing `docker-compose run --rm app token`.
+
+#### `POST /api/skins`
+
+> **Warning**: skin uploading via `skin` field is not implemented for now.
+
+Endpoint allows you to create or update skin record for a username. To upload skin, you have to send multipart
+form data. `form-urlencoded` also supported, but, as you may know, it doesn't support files uploading.
+
+**Request params:**
+
+| Field           | Type   | Description                                                                    |
+|-----------------|--------|--------------------------------------------------------------------------------|
+| identityId      | int    | Unique record identifier.                                                      |
+| username        | string | Username. Case insensitive.                                                    |
+| uuid            | uuid   | UUID of the user.                                                              |
+| skinId          | int    | Skin identifier.                                                               |
+| is1_8           | bool   | Does the skin have the new format (64x64).                                     |
+| isSlim          | bool   | Does skin have slim arms (Alex model).                                         |
+| mojangTextures  | string | Mojang textures field. It must be a base64 encoded json string. Not required.  |
+| mojangSignature | string | Signature for Mojang textures, which is required when `mojangTextures` passed. |
+| url             | string | Actual url of the skin. You have to pass this parameter or `skin`.             |
+| skin            | file   | Skin file. You have to pass this parameter or `url`.                           |
+
+If successful you'll receive `201` status code. In the case of failure there will be `400` status code and errors list
+as json:
+
+```json
+{
+    "errors": {
+        "identityId": [
+            "The identityId field must be numeric"
+        ]
+    }
+}
+```
+
+#### `DELETE /api/skins/id:{identityId}`
+
+Performs record removal by identity id. Request body is not required. On success you will receive `204` status code.
+On failure it'll be `404` with the json body:
+
+```json
+{
+    "error": "Cannot find record for requested user id"
+}
+```
+
+#### `DELETE /api/skins/{username}`
+
+Same endpoint as above but it removes record by identity's username. Have the same behavior, but in case of failure
+response will be:
+
+```json
+{
+    "error": "Cannot find record for requested username"
+}
+```
+
+## Development
+
+First of all you should install the [latest stable version of Go](https://golang.org/doc/install) and set `GOPATH`
+environment variable.
+
+This project uses [`dep`](https://github.com/golang/dep) for dependencies management, so it
+[should be installed](https://github.com/golang/dep#installation) too.
+
+Then you must fork this repository. Now follow these steps:
+
+```sh
+# Get the source code
+go get github.com/elyby/chrly
+# Switch to the project folder
+cd $GOPATH/src/github.com/elyby/chrly
+# Install dependencies (it can take a while)
+dep ensure
+# Add your fork link as a remote
+git remote add fork git@github.com:your-username/chrly.git
+# Create a new branch for your task
+git checkout -b iss-123
+```
+
+You only need to execute `go run main.go` to run the project, but without Redis database and a secret key it won't work
+for very long. You have to export `CHRLY_SECRET` environment variable globally or pass it via `env`:
+
+```sh
+env CHRLY_SECRET=some_local_secret go run main.go serve
+```
+
+Redis can be installed manually, but if you have [Docker installed](https://docs.docker.com/install/), you can run
+predefined docker-compose service. Simply execute the next commands:
+
+```sh
+cp docker-compose.dev.yml docker-compose.yml
 docker-compose up -d
 ```

-Если нужно пересобрать весь контейнер, то выполняем следующее:
+If your Redis instance isn't located at the `localhost`, you can change host by editing environment variable
+`STORAGE_REDIS_HOST`.

-```
-docker-compose stop app  # Останавливаем конейтнер, если он ещё работает
-docker-compose rm -f app # Удаляем конейтнер
-docker-compose build app # Запускаем билд по новой
-docker-compose up -d app # Поднимаем свежесобранный контейнер обратно
-```
+After all of that `go run main.go serve` should successfully start the application.
+To run tests execute `go test ./...`. If your Go version is older than 1.9, then run a `/script/test`.
+
+[ico-lang]: https://img.shields.io/badge/lang-go%201.12-blue.svg?style=flat-square
+[ico-build]: https://img.shields.io/travis/elyby/chrly.svg?style=flat-square
+[ico-coverage]: https://img.shields.io/codecov/c/github/elyby/chrly.svg?style=flat-square
+[ico-changelog]: https://img.shields.io/badge/keep%20a-changelog-orange.svg?style=flat-square
+[ico-license]: https://img.shields.io/github/license/elyby/chrly.svg?style=flat-square
+
+[link-go]: https://golang.org
+[link-build]: https://travis-ci.org/elyby/chrly
+[link-coverage]: https://codecov.io/gh/elyby/chrly
--- a/api/mojang/mojang.go
+++ b/api/mojang/mojang.go
@@ -0,0 +1,205 @@
+package mojang
+
+import (
+	"bytes"
+	"encoding/json"
+	"io/ioutil"
+	"net/http"
+	"time"
+)
+
+var HttpClient = &http.Client{
+	Timeout: 3 * time.Second,
+	Transport: &http.Transport{
+		MaxIdleConnsPerHost: 1024,
+	},
+}
+
+type SignedTexturesResponse struct {
+	Id              string      `json:"id"`
+	Name            string      `json:"name"`
+	Props           []*Property `json:"properties"`
+	decodedTextures *TexturesProp
+}
+
+func (t *SignedTexturesResponse) DecodeTextures() *TexturesProp {
+	if t.decodedTextures == nil {
+		var texturesProp string
+		for _, prop := range t.Props {
+			if prop.Name == "textures" {
+				texturesProp = prop.Value
+				break
+			}
+		}
+
+		if texturesProp == "" {
+			return nil
+		}
+
+		decodedTextures, _ := DecodeTextures(texturesProp)
+		t.decodedTextures = decodedTextures
+	}
+
+	return t.decodedTextures
+}
+
+type Property struct {
+	Name      string `json:"name"`
+	Signature string `json:"signature,omitempty"`
+	Value     string `json:"value"`
+}
+
+type ProfileInfo struct {
+	Id       string `json:"id"`
+	Name     string `json:"name"`
+	IsLegacy bool   `json:"legacy,omitempty"`
+	IsDemo   bool   `json:"demo,omitempty"`
+}
+
+// Exchanges usernames array to array of uuids
+// See https://wiki.vg/Mojang_API#Playernames_-.3E_UUIDs
+func UsernamesToUuids(usernames []string) ([]*ProfileInfo, error) {
+	requestBody, _ := json.Marshal(usernames)
+	request, _ := http.NewRequest("POST", "https://api.mojang.com/profiles/minecraft", bytes.NewBuffer(requestBody))
+
+	request.Header.Set("Content-Type", "application/json")
+
+	response, err := HttpClient.Do(request)
+	if err != nil {
+		return nil, err
+	}
+	defer response.Body.Close()
+
+	if responseErr := validateResponse(response); responseErr != nil {
+		return nil, responseErr
+	}
+
+	var result []*ProfileInfo
+
+	body, _ := ioutil.ReadAll(response.Body)
+	_ = json.Unmarshal(body, &result)
+
+	return result, nil
+}
+
+// Obtains textures information for provided uuid
+// See https://wiki.vg/Mojang_API#UUID_-.3E_Profile_.2B_Skin.2FCape
+func UuidToTextures(uuid string, signed bool) (*SignedTexturesResponse, error) {
+	url := "https://sessionserver.mojang.com/session/minecraft/profile/" + uuid
+	if signed {
+		url += "?unsigned=false"
+	}
+
+	request, _ := http.NewRequest("GET", url, nil)
+
+	response, err := HttpClient.Do(request)
+	if err != nil {
+		return nil, err
+	}
+	defer response.Body.Close()
+
+	if responseErr := validateResponse(response); responseErr != nil {
+		return nil, responseErr
+	}
+
+	var result *SignedTexturesResponse
+
+	body, _ := ioutil.ReadAll(response.Body)
+	_ = json.Unmarshal(body, &result)
+
+	return result, nil
+}
+
+func validateResponse(response *http.Response) error {
+	switch {
+	case response.StatusCode == 204:
+		return &EmptyResponse{}
+	case response.StatusCode == 400:
+		type errorResponse struct {
+			Error   string `json:"error"`
+			Message string `json:"errorMessage"`
+		}
+
+		var decodedError *errorResponse
+		body, _ := ioutil.ReadAll(response.Body)
+		_ = json.Unmarshal(body, &decodedError)
+
+		return &BadRequestError{ErrorType: decodedError.Error, Message: decodedError.Message}
+	case response.StatusCode == 403:
+		return &ForbiddenError{}
+	case response.StatusCode == 429:
+		return &TooManyRequestsError{}
+	case response.StatusCode >= 500:
+		return &ServerError{Status: response.StatusCode}
+	}
+
+	return nil
+}
+
+type ResponseError interface {
+	IsMojangError() bool
+}
+
+// Mojang API doesn't return a 404 Not Found error for non-existent data identifiers
+// Instead, they return 204 with an empty body
+type EmptyResponse struct {
+}
+
+func (*EmptyResponse) Error() string {
+	return "Empty Response"
+}
+
+func (*EmptyResponse) IsMojangError() bool {
+	return true
+}
+
+// When passed request params are invalid, Mojang returns 400 Bad Request error
+type BadRequestError struct {
+	ResponseError
+	ErrorType string
+	Message   string
+}
+
+func (e *BadRequestError) Error() string {
+	return e.Message
+}
+
+func (*BadRequestError) IsMojangError() bool {
+	return true
+}
+
+// When Mojang decides you're such a bad guy, this error appears (even if the request has no authorization)
+type ForbiddenError struct {
+	ResponseError
+}
+
+func (*ForbiddenError) Error() string {
+	return "Forbidden"
+}
+
+// When you exceed the set limit of requests, this error will be returned
+type TooManyRequestsError struct {
+	ResponseError
+}
+
+func (*TooManyRequestsError) Error() string {
+	return "Too Many Requests"
+}
+
+func (*TooManyRequestsError) IsMojangError() bool {
+	return true
+}
+
+// ServerError happens when Mojang's API returns any response with 50* status
+type ServerError struct {
+	ResponseError
+	Status int
+}
+
+func (e *ServerError) Error() string {
+	return "Server error"
+}
+
+func (*ServerError) IsMojangError() bool {
+	return true
+}
--- a/api/mojang/mojang_test.go
+++ b/api/mojang/mojang_test.go
@@ -0,0 +1,310 @@
+package mojang
+
+import (
+	"net/http"
+	"testing"
+
+	"github.com/h2non/gock"
+	testify "github.com/stretchr/testify/assert"
+)
+
+func TestSignedTexturesResponse(t *testing.T) {
+	t.Run("DecodeTextures", func(t *testing.T) {
+		obj := &SignedTexturesResponse{
+			Id:   "00000000000000000000000000000000",
+			Name: "mock",
+			Props: []*Property{
+				{
+					Name:  "textures",
+					Value: "eyJ0aW1lc3RhbXAiOjE1NTU4NTYzMDc0MTIsInByb2ZpbGVJZCI6IjNlM2VlNmMzNWFmYTQ4YWJiNjFlOGNkOGM0MmZjMGQ5IiwicHJvZmlsZU5hbWUiOiJFcmlja1NrcmF1Y2giLCJ0ZXh0dXJlcyI6eyJTS0lOIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvZmMxNzU3NjMzN2ExMDZkOWMyMmFjNzgyZTM2MmMxNmM0ZTBlNDliZTUzZmFhNDE4NTdiZmYzMzJiNzc5MjgxZSJ9fX0=",
+				},
+			},
+		}
+		textures := obj.DecodeTextures()
+		testify.Equal(t, "3e3ee6c35afa48abb61e8cd8c42fc0d9", textures.ProfileID)
+	})
+
+	t.Run("DecodedTextures without textures prop", func(t *testing.T) {
+		obj := &SignedTexturesResponse{
+			Id:    "00000000000000000000000000000000",
+			Name:  "mock",
+			Props: []*Property{},
+		}
+		textures := obj.DecodeTextures()
+		testify.Nil(t, textures)
+	})
+}
+
+func TestUsernamesToUuids(t *testing.T) {
+	t.Run("exchange usernames to uuids", func(t *testing.T) {
+		assert := testify.New(t)
+
+		defer gock.Off()
+		gock.New("https://api.mojang.com").
+			Post("/profiles/minecraft").
+			JSON([]string{"Thinkofdeath", "maksimkurb"}).
+			Reply(200).
+			JSON([]map[string]interface{}{
+				{
+					"id":     "4566e69fc90748ee8d71d7ba5aa00d20",
+					"name":   "Thinkofdeath",
+					"legacy": false,
+					"demo":   true,
+				},
+				{
+					"id":   "0d252b7218b648bfb86c2ae476954d32",
+					"name": "maksimkurb",
+					// There is no legacy or demo fields
+				},
+			})
+
+		client := &http.Client{}
+		gock.InterceptClient(client)
+
+		HttpClient = client
+
+		result, err := UsernamesToUuids([]string{"Thinkofdeath", "maksimkurb"})
+		if assert.NoError(err) {
+			assert.Len(result, 2)
+			assert.Equal("4566e69fc90748ee8d71d7ba5aa00d20", result[0].Id)
+			assert.Equal("Thinkofdeath", result[0].Name)
+			assert.False(result[0].IsLegacy)
+			assert.True(result[0].IsDemo)
+
+			assert.Equal("0d252b7218b648bfb86c2ae476954d32", result[1].Id)
+			assert.Equal("maksimkurb", result[1].Name)
+			assert.False(result[1].IsLegacy)
+			assert.False(result[1].IsDemo)
+		}
+	})
+
+	t.Run("handle bad request response", func(t *testing.T) {
+		assert := testify.New(t)
+
+		defer gock.Off()
+		gock.New("https://api.mojang.com").
+			Post("/profiles/minecraft").
+			Reply(400).
+			JSON(map[string]interface{}{
+				"error":        "IllegalArgumentException",
+				"errorMessage": "profileName can not be null or empty.",
+			})
+
+		client := &http.Client{}
+		gock.InterceptClient(client)
+
+		HttpClient = client
+
+		result, err := UsernamesToUuids([]string{""})
+		assert.Nil(result)
+		assert.IsType(&BadRequestError{}, err)
+		assert.EqualError(err, "profileName can not be null or empty.")
+		assert.Implements((*ResponseError)(nil), err)
+	})
+
+	t.Run("handle forbidden response", func(t *testing.T) {
+		assert := testify.New(t)
+
+		defer gock.Off()
+		gock.New("https://api.mojang.com").
+			Post("/profiles/minecraft").
+			Reply(403).
+			BodyString("just because")
+
+		client := &http.Client{}
+		gock.InterceptClient(client)
+
+		HttpClient = client
+
+		result, err := UsernamesToUuids([]string{"Thinkofdeath", "maksimkurb"})
+		assert.Nil(result)
+		assert.IsType(&ForbiddenError{}, err)
+		assert.EqualError(err, "Forbidden")
+		assert.Implements((*ResponseError)(nil), err)
+	})
+
+	t.Run("handle too many requests response", func(t *testing.T) {
+		assert := testify.New(t)
+
+		defer gock.Off()
+		gock.New("https://api.mojang.com").
+			Post("/profiles/minecraft").
+			Reply(429).
+			JSON(map[string]interface{}{
+				"error":        "TooManyRequestsException",
+				"errorMessage": "The client has sent too many requests within a certain amount of time",
+			})
+
+		client := &http.Client{}
+		gock.InterceptClient(client)
+
+		HttpClient = client
+
+		result, err := UsernamesToUuids([]string{"Thinkofdeath", "maksimkurb"})
+		assert.Nil(result)
+		assert.IsType(&TooManyRequestsError{}, err)
+		assert.EqualError(err, "Too Many Requests")
+		assert.Implements((*ResponseError)(nil), err)
+	})
+
+	t.Run("handle server error", func(t *testing.T) {
+		assert := testify.New(t)
+
+		defer gock.Off()
+		gock.New("https://api.mojang.com").
+			Post("/profiles/minecraft").
+			Reply(500).
+			BodyString("500 Internal Server Error")
+
+		client := &http.Client{}
+		gock.InterceptClient(client)
+
+		HttpClient = client
+
+		result, err := UsernamesToUuids([]string{"Thinkofdeath", "maksimkurb"})
+		assert.Nil(result)
+		assert.IsType(&ServerError{}, err)
+		assert.EqualError(err, "Server error")
+		assert.Equal(500, err.(*ServerError).Status)
+		assert.Implements((*ResponseError)(nil), err)
+	})
+}
+
+func TestUuidToTextures(t *testing.T) {
+	t.Run("obtain not signed textures", func(t *testing.T) {
+		assert := testify.New(t)
+
+		defer gock.Off()
+		gock.New("https://sessionserver.mojang.com").
+			Get("/session/minecraft/profile/4566e69fc90748ee8d71d7ba5aa00d20").
+			Reply(200).
+			JSON(map[string]interface{}{
+				"id":   "4566e69fc90748ee8d71d7ba5aa00d20",
+				"name": "Thinkofdeath",
+				"properties": []interface{}{
+					map[string]interface{}{
+						"name":  "textures",
+						"value": "eyJ0aW1lc3RhbXAiOjE1NDMxMDczMDExODUsInByb2ZpbGVJZCI6IjQ1NjZlNjlmYzkwNzQ4ZWU4ZDcxZDdiYTVhYTAwZDIwIiwicHJvZmlsZU5hbWUiOiJUaGlua29mZGVhdGgiLCJ0ZXh0dXJlcyI6eyJTS0lOIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvNzRkMWUwOGIwYmI3ZTlmNTkwYWYyNzc1ODEyNWJiZWQxNzc4YWM2Y2VmNzI5YWVkZmNiOTYxM2U5OTExYWU3NSJ9LCJDQVBFIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvYjBjYzA4ODQwNzAwNDQ3MzIyZDk1M2EwMmI5NjVmMWQ2NWExM2E2MDNiZjY0YjE3YzgwM2MyMTQ0NmZlMTYzNSJ9fX0=",
+					},
+				},
+			})
+
+		client := &http.Client{}
+		gock.InterceptClient(client)
+
+		HttpClient = client
+
+		result, err := UuidToTextures("4566e69fc90748ee8d71d7ba5aa00d20", false)
+		if assert.NoError(err) {
+			assert.Equal("4566e69fc90748ee8d71d7ba5aa00d20", result.Id)
+			assert.Equal("Thinkofdeath", result.Name)
+			assert.Equal(1, len(result.Props))
+			assert.Equal("textures", result.Props[0].Name)
+			assert.Equal(476, len(result.Props[0].Value))
+			assert.Equal("", result.Props[0].Signature)
+		}
+	})
+
+	t.Run("obtain signed textures", func(t *testing.T) {
+		assert := testify.New(t)
+
+		defer gock.Off()
+		gock.New("https://sessionserver.mojang.com").
+			Get("/session/minecraft/profile/4566e69fc90748ee8d71d7ba5aa00d20").
+			MatchParam("unsigned", "false").
+			Reply(200).
+			JSON(map[string]interface{}{
+				"id":   "4566e69fc90748ee8d71d7ba5aa00d20",
+				"name": "Thinkofdeath",
+				"properties": []interface{}{
+					map[string]interface{}{
+						"name":      "textures",
+						"signature": "signature string",
+						"value":     "eyJ0aW1lc3RhbXAiOjE1NDMxMDczMDExODUsInByb2ZpbGVJZCI6IjQ1NjZlNjlmYzkwNzQ4ZWU4ZDcxZDdiYTVhYTAwZDIwIiwicHJvZmlsZU5hbWUiOiJUaGlua29mZGVhdGgiLCJ0ZXh0dXJlcyI6eyJTS0lOIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvNzRkMWUwOGIwYmI3ZTlmNTkwYWYyNzc1ODEyNWJiZWQxNzc4YWM2Y2VmNzI5YWVkZmNiOTYxM2U5OTExYWU3NSJ9LCJDQVBFIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvYjBjYzA4ODQwNzAwNDQ3MzIyZDk1M2EwMmI5NjVmMWQ2NWExM2E2MDNiZjY0YjE3YzgwM2MyMTQ0NmZlMTYzNSJ9fX0=",
+					},
+				},
+			})
+
+		client := &http.Client{}
+		gock.InterceptClient(client)
+
+		HttpClient = client
+
+		result, err := UuidToTextures("4566e69fc90748ee8d71d7ba5aa00d20", true)
+		if assert.NoError(err) {
+			assert.Equal("4566e69fc90748ee8d71d7ba5aa00d20", result.Id)
+			assert.Equal("Thinkofdeath", result.Name)
+			assert.Equal(1, len(result.Props))
+			assert.Equal("textures", result.Props[0].Name)
+			assert.Equal(476, len(result.Props[0].Value))
+			assert.Equal("signature string", result.Props[0].Signature)
+		}
+	})
+
+	t.Run("handle empty response", func(t *testing.T) {
+		assert := testify.New(t)
+
+		defer gock.Off()
+		gock.New("https://sessionserver.mojang.com").
+			Get("/session/minecraft/profile/4566e69fc90748ee8d71d7ba5aa00d20").
+			Reply(204).
+			BodyString("")
+
+		client := &http.Client{}
+		gock.InterceptClient(client)
+
+		HttpClient = client
+
+		result, err := UuidToTextures("4566e69fc90748ee8d71d7ba5aa00d20", false)
+		assert.Nil(result)
+		assert.IsType(&EmptyResponse{}, err)
+		assert.EqualError(err, "Empty Response")
+		assert.Implements((*ResponseError)(nil), err)
+	})
+
+	t.Run("handle too many requests response", func(t *testing.T) {
+		assert := testify.New(t)
+
+		defer gock.Off()
+		gock.New("https://sessionserver.mojang.com").
+			Get("/session/minecraft/profile/4566e69fc90748ee8d71d7ba5aa00d20").
+			Reply(429).
+			JSON(map[string]interface{}{
+				"error":        "TooManyRequestsException",
+				"errorMessage": "The client has sent too many requests within a certain amount of time",
+			})
+
+		client := &http.Client{}
+		gock.InterceptClient(client)
+
+		HttpClient = client
+
+		result, err := UuidToTextures("4566e69fc90748ee8d71d7ba5aa00d20", false)
+		assert.Nil(result)
+		assert.IsType(&TooManyRequestsError{}, err)
+		assert.EqualError(err, "Too Many Requests")
+		assert.Implements((*ResponseError)(nil), err)
+	})
+
+	t.Run("handle server error", func(t *testing.T) {
+		assert := testify.New(t)
+
+		defer gock.Off()
+		gock.New("https://sessionserver.mojang.com").
+			Get("/session/minecraft/profile/4566e69fc90748ee8d71d7ba5aa00d20").
+			Reply(500).
+			BodyString("500 Internal Server Error")
+
+		client := &http.Client{}
+		gock.InterceptClient(client)
+
+		HttpClient = client
+
+		result, err := UuidToTextures("4566e69fc90748ee8d71d7ba5aa00d20", false)
+		assert.Nil(result)
+		assert.IsType(&ServerError{}, err)
+		assert.EqualError(err, "Server error")
+		assert.Equal(500, err.(*ServerError).Status)
+		assert.Implements((*ResponseError)(nil), err)
+	})
+}
--- a/api/mojang/queue/broadcast.go
+++ b/api/mojang/queue/broadcast.go
@@ -0,0 +1,53 @@
+package queue
+
+import (
+	"sync"
+
+	"github.com/elyby/chrly/api/mojang"
+)
+
+type broadcastMap struct {
+	lock      sync.Mutex
+	listeners map[string][]chan *mojang.SignedTexturesResponse
+}
+
+func newBroadcaster() *broadcastMap {
+	return &broadcastMap{
+		listeners: make(map[string][]chan *mojang.SignedTexturesResponse),
+	}
+}
+
+// Returns a boolean value, which will be true if the username passed didn't exist before
+func (c *broadcastMap) AddListener(username string, resultChan chan *mojang.SignedTexturesResponse) bool {
+	c.lock.Lock()
+	defer c.lock.Unlock()
+
+	val, alreadyHasSource := c.listeners[username]
+	if alreadyHasSource {
+		c.listeners[username] = append(val, resultChan)
+		return false
+	}
+
+	c.listeners[username] = []chan *mojang.SignedTexturesResponse{resultChan}
+
+	return true
+}
+
+func (c *broadcastMap) BroadcastAndRemove(username string, result *mojang.SignedTexturesResponse) {
+	c.lock.Lock()
+	defer c.lock.Unlock()
+
+	val, ok := c.listeners[username]
+	if !ok {
+		return
+	}
+
+	for _, channel := range val {
+		go func(channel chan *mojang.SignedTexturesResponse) {
+			channel <- result
+			close(channel)
+		}(channel)
+	}
+
+	delete(c.listeners, username)
+}
--- a/api/mojang/queue/broadcast_test.go
+++ b/api/mojang/queue/broadcast_test.go
@@ -0,0 +1,75 @@
+package queue
+
+import (
+	"github.com/elyby/chrly/api/mojang"
+
+	testify "github.com/stretchr/testify/assert"
+	"testing"
+)
+
+func TestBroadcastMap_GetOrAppend(t *testing.T) {
+	t.Run("first call when username didn't exist before should return true", func(t *testing.T) {
+		assert := testify.New(t)
+
+		broadcaster := newBroadcaster()
+		channel := make(chan *mojang.SignedTexturesResponse)
+		isFirstListener := broadcaster.AddListener("mock", channel)
+
+		assert.True(isFirstListener)
+		listeners, ok := broadcaster.listeners["mock"]
+		assert.True(ok)
+		assert.Len(listeners, 1)
+		assert.Equal(channel, listeners[0])
+	})
+
+	t.Run("subsequent calls should return false", func(t *testing.T) {
+		assert := testify.New(t)
+
+		broadcaster := newBroadcaster()
+		channel1 := make(chan *mojang.SignedTexturesResponse)
+		isFirstListener := broadcaster.AddListener("mock", channel1)
+
+		assert.True(isFirstListener)
+
+		channel2 := make(chan *mojang.SignedTexturesResponse)
+		isFirstListener = broadcaster.AddListener("mock", channel2)
+
+		assert.False(isFirstListener)
+
+		channel3 := make(chan *mojang.SignedTexturesResponse)
+		isFirstListener = broadcaster.AddListener("mock", channel3)
+
+		assert.False(isFirstListener)
+	})
+}
+
+func TestBroadcastMap_BroadcastAndRemove(t *testing.T) {
+	t.Run("should broadcast to all listeners and remove the key", func(t *testing.T) {
+		assert := testify.New(t)
+
+		broadcaster := newBroadcaster()
+		channel1 := make(chan *mojang.SignedTexturesResponse)
+		channel2 := make(chan *mojang.SignedTexturesResponse)
+		broadcaster.AddListener("mock", channel1)
+		broadcaster.AddListener("mock", channel2)
+
+		result := &mojang.SignedTexturesResponse{Id: "mockUuid"}
+		broadcaster.BroadcastAndRemove("mock", result)
+
+		assert.Equal(result, <-channel1)
+		assert.Equal(result, <-channel2)
+
+		channel3 := make(chan *mojang.SignedTexturesResponse)
+		isFirstListener := broadcaster.AddListener("mock", channel3)
+		assert.True(isFirstListener)
+	})
+
+	t.Run("call on not exists username", func(t *testing.T) {
+		assert := testify.New(t)
+
+		assert.NotPanics(func() {
+			broadcaster := newBroadcaster()
+			broadcaster.BroadcastAndRemove("mock", &mojang.SignedTexturesResponse{})
+		})
+	})
+}
--- a/api/mojang/queue/in_memory_textures_storage.go
+++ b/api/mojang/queue/in_memory_textures_storage.go
@@ -0,0 +1,112 @@
+package queue
+
+import (
+	"sync"
+	"time"
+
+	"github.com/elyby/chrly/api/mojang"
+
+	"github.com/tevino/abool"
+)
+
+var inMemoryStorageGCPeriod = 10 * time.Second
+var inMemoryStoragePersistPeriod = time.Minute + 10*time.Second
+var now = time.Now
+
+type inMemoryItem struct {
+	textures  *mojang.SignedTexturesResponse
+	timestamp int64
+}
+
+type inMemoryTexturesStorage struct {
+	lock    sync.Mutex
+	data    map[string]*inMemoryItem
+	working *abool.AtomicBool
+}
+
+func CreateInMemoryTexturesStorage() *inMemoryTexturesStorage {
+	storage := &inMemoryTexturesStorage{
+		data: make(map[string]*inMemoryItem),
+	}
+
+	return storage
+}
+
+func (s *inMemoryTexturesStorage) Start() {
+	if s.working == nil {
+		s.working = abool.New()
+	}
+
+	if !s.working.IsSet() {
+		go func() {
+			time.Sleep(inMemoryStorageGCPeriod)
+			// TODO: this can be reimplemented in future with channels, but right now I have no idea how to make it right
+			for s.working.IsSet() {
+				start := time.Now()
+				s.gc()
+				time.Sleep(inMemoryStorageGCPeriod - time.Since(start))
+			}
+		}()
+	}
+
+	s.working.Set()
+}
+
+func (s *inMemoryTexturesStorage) Stop() {
+	s.working.UnSet()
+}
+
+func (s *inMemoryTexturesStorage) GetTextures(uuid string) (*mojang.SignedTexturesResponse, error) {
+	s.lock.Lock()
+	defer s.lock.Unlock()
+
+	item, exists := s.data[uuid]
+	validRange := getMinimalNotExpiredTimestamp()
+	if !exists || validRange > item.timestamp {
+		return nil, &ValueNotFound{}
+	}
+
+	return item.textures, nil
+}
+
+func (s *inMemoryTexturesStorage) StoreTextures(uuid string, textures *mojang.SignedTexturesResponse) {
+	var timestamp int64
+	if textures != nil {
+		decoded := textures.DecodeTextures()
+		if decoded == nil {
+			panic("unable to decode textures")
+		}
+
+		timestamp = decoded.Timestamp
+	} else {
+		timestamp = unixNanoToUnixMicro(now().UnixNano())
+	}
+
+	s.lock.Lock()
+	defer s.lock.Unlock()
+
+	s.data[uuid] = &inMemoryItem{
+		textures:  textures,
+		timestamp: timestamp,
+	}
+}
+
+func (s *inMemoryTexturesStorage) gc() {
+	s.lock.Lock()
+	defer s.lock.Unlock()
+
+	maxTime := getMinimalNotExpiredTimestamp()
+	for uuid, value := range s.data {
+		if maxTime > value.timestamp {
+			delete(s.data, uuid)
+		}
+	}
+}
+
+func getMinimalNotExpiredTimestamp() int64 {
+	return unixNanoToUnixMicro(now().Add(inMemoryStoragePersistPeriod * time.Duration(-1)).UnixNano())
+}
+
+func unixNanoToUnixMicro(unixNano int64) int64 {
+	return unixNano / 10e5
+}
--- a/api/mojang/queue/in_memory_textures_storage_test.go
+++ b/api/mojang/queue/in_memory_textures_storage_test.go
@@ -0,0 +1,200 @@
+package queue
+
+import (
+	"time"
+
+	"github.com/elyby/chrly/api/mojang"
+
+	testify "github.com/stretchr/testify/assert"
+	"testing"
+)
+
+var texturesWithSkin = &mojang.SignedTexturesResponse{
+	Id:   "dead24f9a4fa4877b7b04c8c6c72bb46",
+	Name: "mock",
+	Props: []*mojang.Property{
+		{
+			Name: "textures",
+			Value: mojang.EncodeTextures(&mojang.TexturesProp{
+				Timestamp:   time.Now().UnixNano() / 10e5,
+				ProfileID:   "dead24f9a4fa4877b7b04c8c6c72bb46",
+				ProfileName: "mock",
+				Textures: &mojang.TexturesResponse{
+					Skin: &mojang.SkinTexturesResponse{
+						Url: "http://textures.minecraft.net/texture/74d1e08b0bb7e9f590af27758125bbed1778ac6cef729aedfcb9613e9911ae75",
+					},
+				},
+			}),
+		},
+	},
+}
+var texturesWithoutSkin = &mojang.SignedTexturesResponse{
+	Id:   "dead24f9a4fa4877b7b04c8c6c72bb46",
+	Name: "mock",
+	Props: []*mojang.Property{
+		{
+			Name: "textures",
+			Value: mojang.EncodeTextures(&mojang.TexturesProp{
+				Timestamp:   time.Now().UnixNano() / 10e5,
+				ProfileID:   "dead24f9a4fa4877b7b04c8c6c72bb46",
+				ProfileName: "mock",
+				Textures:    &mojang.TexturesResponse{},
+			}),
+		},
+	},
+}
+
+func TestInMemoryTexturesStorage_GetTextures(t *testing.T) {
+	t.Run("get error when uuid is not exists", func(t *testing.T) {
+		assert := testify.New(t)
+
+		storage := CreateInMemoryTexturesStorage()
+		result, err := storage.GetTextures("b5d58475007d4f9e9ddd1403e2497579")
+
+		assert.Nil(result)
+		assert.Error(err, "value not found in the storage")
+	})
+
+	t.Run("get textures object, when uuid is stored in the storage", func(t *testing.T) {
+		assert := testify.New(t)
+
+		storage := CreateInMemoryTexturesStorage()
+		storage.StoreTextures("dead24f9a4fa4877b7b04c8c6c72bb46", texturesWithSkin)
+		result, err := storage.GetTextures("dead24f9a4fa4877b7b04c8c6c72bb46")
+
+		assert.Equal(texturesWithSkin, result)
+		assert.Nil(err)
+	})
+
+	t.Run("get error when uuid is exists, but textures are expired", func(t *testing.T) {
+		assert := testify.New(t)
+
+		storage := CreateInMemoryTexturesStorage()
+		storage.StoreTextures("dead24f9a4fa4877b7b04c8c6c72bb46", texturesWithSkin)
+
+		now = func() time.Time {
+			return time.Now().Add(time.Minute * 2)
+		}
+
+		result, err := storage.GetTextures("dead24f9a4fa4877b7b04c8c6c72bb46")
+
+		assert.Nil(result)
+		assert.Error(err, "value not found in the storage")
+
+		now = time.Now
+	})
+}
+
+func TestInMemoryTexturesStorage_StoreTextures(t *testing.T) {
+	t.Run("store textures for previously not existed uuid", func(t *testing.T) {
+		assert := testify.New(t)
+
+		storage := CreateInMemoryTexturesStorage()
+		storage.StoreTextures("dead24f9a4fa4877b7b04c8c6c72bb46", texturesWithSkin)
+		result, err := storage.GetTextures("dead24f9a4fa4877b7b04c8c6c72bb46")
+
+		assert.Equal(texturesWithSkin, result)
+		assert.Nil(err)
+	})
+
+	t.Run("override already existed textures for uuid", func(t *testing.T) {
+		assert := testify.New(t)
+
+		storage := CreateInMemoryTexturesStorage()
+		storage.StoreTextures("dead24f9a4fa4877b7b04c8c6c72bb46", texturesWithoutSkin)
+		storage.StoreTextures("dead24f9a4fa4877b7b04c8c6c72bb46", texturesWithSkin)
+		result, err := storage.GetTextures("dead24f9a4fa4877b7b04c8c6c72bb46")
+
+		assert.NotEqual(texturesWithoutSkin, result)
+		assert.Equal(texturesWithSkin, result)
+		assert.Nil(err)
+	})
+
+	t.Run("store nil textures", func(t *testing.T) {
+		assert := testify.New(t)
+
+		storage := CreateInMemoryTexturesStorage()
+		storage.StoreTextures("dead24f9a4fa4877b7b04c8c6c72bb46", nil)
+		result, err := storage.GetTextures("dead24f9a4fa4877b7b04c8c6c72bb46")
+
+		assert.Nil(result)
+		assert.Nil(err)
+	})
+
+	t.Run("should panic if textures prop is not decoded", func(t *testing.T) {
+		assert := testify.New(t)
+
+		toStore := &mojang.SignedTexturesResponse{
+			Id:    "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
+			Name:  "mock",
+			Props: []*mojang.Property{},
+		}
+
+		assert.PanicsWithValue("unable to decode textures", func() {
+			storage := CreateInMemoryTexturesStorage()
+			storage.StoreTextures("xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", toStore)
+		})
+	})
+}
+
+func TestInMemoryTexturesStorage_GarbageCollection(t *testing.T) {
+	assert := testify.New(t)
+
+	inMemoryStorageGCPeriod = 10 * time.Millisecond
+	inMemoryStoragePersistPeriod = 10 * time.Millisecond
+
+	textures1 := &mojang.SignedTexturesResponse{
+		Id:   "dead24f9a4fa4877b7b04c8c6c72bb46",
+		Name: "mock1",
+		Props: []*mojang.Property{
+			{
+				Name: "textures",
+				Value: mojang.EncodeTextures(&mojang.TexturesProp{
+					Timestamp:   time.Now().Add(inMemoryStorageGCPeriod-time.Millisecond*time.Duration(5)).UnixNano() / 10e5,
+					ProfileID:   "dead24f9a4fa4877b7b04c8c6c72bb46",
+					ProfileName: "mock1",
+					Textures:    &mojang.TexturesResponse{},
+				}),
+			},
+		},
+	}
+	textures2 := &mojang.SignedTexturesResponse{
+		Id:   "b5d58475007d4f9e9ddd1403e2497579",
+		Name: "mock2",
+		Props: []*mojang.Property{
+			{
+				Name: "textures",
+				Value: mojang.EncodeTextures(&mojang.TexturesProp{
+					Timestamp:   time.Now().Add(inMemoryStorageGCPeriod-time.Millisecond*time.Duration(15)).UnixNano() / 10e5,
+					ProfileID:   "b5d58475007d4f9e9ddd1403e2497579",
+					ProfileName: "mock2",
+					Textures:    &mojang.TexturesResponse{},
+				}),
+			},
+		},
+	}
+
+	storage := CreateInMemoryTexturesStorage()
+	storage.StoreTextures("dead24f9a4fa4877b7b04c8c6c72bb46", textures1)
+	storage.StoreTextures("b5d58475007d4f9e9ddd1403e2497579", textures2)
+
+	storage.Start()
+
+	time.Sleep(inMemoryStorageGCPeriod + time.Millisecond) // Let it start first iteration
+
+	_, textures1Err := storage.GetTextures("dead24f9a4fa4877b7b04c8c6c72bb46")
+	_, textures2Err := storage.GetTextures("b5d58475007d4f9e9ddd1403e2497579")
+
+	assert.Nil(textures1Err)
+	assert.Error(textures2Err)
+
+	time.Sleep(inMemoryStorageGCPeriod + time.Millisecond) // Let another iteration happen
+
+	_, textures1Err = storage.GetTextures("dead24f9a4fa4877b7b04c8c6c72bb46")
+	_, textures2Err = storage.GetTextures("b5d58475007d4f9e9ddd1403e2497579")
+
+	assert.Error(textures1Err)
+	assert.Error(textures2Err)
+
+	storage.Stop()
+}
--- a/api/mojang/queue/jobs_structure.go
+++ b/api/mojang/queue/jobs_structure.go
@@ -0,0 +1,56 @@
+// Based on the implementation from https://flaviocopes.com/golang-data-structure-queue/
+
+package queue
+
+import (
+	"sync"
+
+	"github.com/elyby/chrly/api/mojang"
+)
+
+type jobItem struct {
+	Username  string
+	RespondTo chan *mojang.SignedTexturesResponse
+}
+
+type jobsQueue struct {
+	lock  sync.Mutex
+	items []*jobItem
+}
+
+func (s *jobsQueue) New() *jobsQueue {
+	s.items = []*jobItem{}
+	return s
+}
+
+func (s *jobsQueue) Enqueue(t *jobItem) {
+	s.lock.Lock()
+	defer s.lock.Unlock()
+
+	s.items = append(s.items, t)
+}
+
+func (s *jobsQueue) Dequeue(n int) []*jobItem {
+	s.lock.Lock()
+	defer s.lock.Unlock()
+
+	if n > s.Size() {
+		n = s.Size()
+	}
+
+	items := s.items[0:n]
+	s.items = s.items[n:len(s.items)]
+
+	return items
+}
+
+func (s *jobsQueue) IsEmpty() bool {
+	s.lock.Lock()
+	defer s.lock.Unlock()
+
+	return len(s.items) == 0
+}
+
+func (s *jobsQueue) Size() int {
+	return len(s.items)
+}
--- a/api/mojang/queue/jobs_structure_test.go
+++ b/api/mojang/queue/jobs_structure_test.go
@@ -0,0 +1,47 @@
+package queue
+
+import (
+	"testing"
+
+	testify "github.com/stretchr/testify/assert"
+)
+
+func TestEnqueue(t *testing.T) {
+	assert := testify.New(t)
+
+	s := createQueue()
+	s.Enqueue(&jobItem{Username: "username1"})
+	s.Enqueue(&jobItem{Username: "username2"})
+	s.Enqueue(&jobItem{Username: "username3"})
+
+	assert.Equal(3, s.Size())
+}
+
+func TestDequeueN(t *testing.T) {
+	assert := testify.New(t)
+
+	s := createQueue()
+	s.Enqueue(&jobItem{Username: "username1"})
+	s.Enqueue(&jobItem{Username: "username2"})
+	s.Enqueue(&jobItem{Username: "username3"})
+	s.Enqueue(&jobItem{Username: "username4"})
+
+	items := s.Dequeue(2)
+	assert.Len(items, 2)
+	assert.Equal("username1", items[0].Username)
+	assert.Equal("username2", items[1].Username)
+	assert.Equal(2, s.Size())
+
+	items = s.Dequeue(40)
+	assert.Len(items, 2)
+	assert.Equal("username3", items[0].Username)
+	assert.Equal("username4", items[1].Username)
+	assert.True(s.IsEmpty())
+}
+
+func createQueue() *jobsQueue {
+	queue := &jobsQueue{}
+	queue.New()
+
+	return queue
+}
--- a/api/mojang/queue/queue.go
+++ b/api/mojang/queue/queue.go
@@ -0,0 +1,221 @@
+package queue
+
+import (
+	"net"
+	"net/url"
+	"regexp"
+	"strings"
+	"sync"
+	"syscall"
+	"time"
+
+	"github.com/mono83/slf/wd"
+
+	"github.com/elyby/chrly/api/mojang"
+)
+
+var UuidsQueueIterationDelay = 2*time.Second + 500*time.Millisecond
+
+var usernamesToUuids = mojang.UsernamesToUuids
+var uuidToTextures = mojang.UuidToTextures
+var forever = func() bool {
+	return true
+}
+
+// https://help.mojang.com/customer/portal/articles/928638
+var allowedUsernamesRegex = regexp.MustCompile(`^[\w_]{3,16}$`)
+
+type JobsQueue struct {
+	Storage Storage
+	Logger  wd.Watchdog
+
+	onFirstCall sync.Once
+	queue       jobsQueue
+	broadcast   *broadcastMap
+}
+
+func (ctx *JobsQueue) GetTexturesForUsername(username string) chan *mojang.SignedTexturesResponse {
+	// TODO: convert username to lower case
+	ctx.onFirstCall.Do(func() {
+		ctx.queue.New()
+		ctx.broadcast = newBroadcaster()
+		ctx.startQueue()
+	})
+
+	responseChan := make(chan *mojang.SignedTexturesResponse)
+	if !allowedUsernamesRegex.MatchString(username) {
+		ctx.Logger.IncCounter("mojang_textures.invalid_username", 1)
+		go func() {
+			responseChan <- nil
+			close(responseChan)
+		}()
+
+		return responseChan
+	}
+
+	ctx.Logger.IncCounter("mojang_textures.request", 1)
+
+	uuid, err := ctx.Storage.GetUuid(username)
+	if err == nil && uuid == "" {
+		ctx.Logger.IncCounter("mojang_textures.usernames.cache_hit_nil", 1)
+
+		go func() {
+			responseChan <- nil
+			close(responseChan)
+		}()
+
+		return responseChan
+	}
+
+	isFirstListener := ctx.broadcast.AddListener(username, responseChan)
+	if isFirstListener {
+		start := time.Now()
+		// TODO: respond nil if processing takes more than 5 seconds
+
+		resultChan := make(chan *mojang.SignedTexturesResponse)
+		if uuid == "" {
+			ctx.Logger.IncCounter("mojang_textures.usernames.queued", 1)
+			ctx.queue.Enqueue(&jobItem{username, resultChan})
+		} else {
+			ctx.Logger.IncCounter("mojang_textures.usernames.cache_hit", 1)
+			go func() {
+				resultChan <- ctx.getTextures(uuid)
+			}()
+		}
+
+		go func() {
+			result := <-resultChan
+			close(resultChan)
+			ctx.broadcast.BroadcastAndRemove(username, result)
+			ctx.Logger.RecordTimer("mojang_textures.result_time", time.Since(start))
+		}()
+	} else {
+		ctx.Logger.IncCounter("mojang_textures.already_in_queue", 1)
+	}
+
+	return responseChan
+}
+
+func (ctx *JobsQueue) startQueue() {
+	go func() {
+		time.Sleep(UuidsQueueIterationDelay)
+		for forever() {
+			start := time.Now()
+			ctx.queueRound()
+			elapsed := time.Since(start)
+			ctx.Logger.RecordTimer("mojang_textures.usernames.round_time", elapsed)
+			time.Sleep(UuidsQueueIterationDelay)
+		}
+	}()
+}
+
+func (ctx *JobsQueue) queueRound() {
+	if ctx.queue.IsEmpty() {
+		return
+	}
+
+	queueSize := ctx.queue.Size()
+	jobs := ctx.queue.Dequeue(10)
+	ctx.Logger.UpdateGauge("mojang_textures.usernames.iteration_size", int64(len(jobs)))
+	ctx.Logger.UpdateGauge("mojang_textures.usernames.queue_size", int64(queueSize-len(jobs)))
+	var usernames []string
+	for _, job := range jobs {
+		usernames = append(usernames, job.Username)
+	}
+
+	profiles, err := usernamesToUuids(usernames)
+	if err != nil {
+		ctx.handleResponseError(err, "usernames")
+		for _, job := range jobs {
+			job.RespondTo <- nil
+		}
+
+		return
+	}
+
+	for _, job := range jobs {
+		go func(job *jobItem) {
+			var uuid string
+			// The profiles in the response are not ordered, so we must search each username over full array
+			for _, profile := range profiles {
+				if strings.EqualFold(job.Username, profile.Name) {
+					uuid = profile.Id
+					break
+				}
+			}
+
+			_ = ctx.Storage.StoreUuid(job.Username, uuid)
+			if uuid == "" {
+				job.RespondTo <- nil
+				ctx.Logger.IncCounter("mojang_textures.usernames.uuid_miss", 1)
+			} else {
+				job.RespondTo <- ctx.getTextures(uuid)
+				ctx.Logger.IncCounter("mojang_textures.usernames.uuid_hit", 1)
+			}
+		}(job)
+	}
+}
+
+func (ctx *JobsQueue) getTextures(uuid string) *mojang.SignedTexturesResponse {
+	existsTextures, err := ctx.Storage.GetTextures(uuid)
+	if err == nil {
+		ctx.Logger.IncCounter("mojang_textures.textures.cache_hit", 1)
+		return existsTextures
+	}
+
+	ctx.Logger.IncCounter("mojang_textures.textures.request", 1)
+
+	start := time.Now()
+	result, err := uuidToTextures(uuid, true)
+	ctx.Logger.RecordTimer("mojang_textures.textures.request_time", time.Since(start))
+	if err != nil {
+		ctx.handleResponseError(err, "textures")
+	}
+
+	// Mojang can respond with an error, but count it as a hit, so store result even if the textures is nil
+	ctx.Storage.StoreTextures(uuid, result)
+
+	return result
+}
+
+func (ctx *JobsQueue) handleResponseError(err error, threadName string) {
+	ctx.Logger.Debug(":name: Got response error :err", wd.NameParam(threadName), wd.ErrParam(err))
+
+	switch err.(type) {
+	case mojang.ResponseError:
+		if _, ok := err.(*mojang.BadRequestError); ok {
+			ctx.Logger.Warning(":name: Got 400 Bad Request :err", wd.NameParam(threadName), wd.ErrParam(err))
+			return
+		}
+
+		if _, ok := err.(*mojang.ForbiddenError); ok {
+			ctx.Logger.Warning(":name: Got 403 Forbidden :err", wd.NameParam(threadName), wd.ErrParam(err))
+			return
+		}
+
+		if _, ok := err.(*mojang.TooManyRequestsError); ok {
+			ctx.Logger.Warning(":name: Got 429 Too Many Requests :err", wd.NameParam(threadName), wd.ErrParam(err))
+			return
+		}
+
+		return
+	case net.Error:
+		if err.(net.Error).Timeout() {
+			return
+		}
+
+		if _, ok := err.(*url.Error); ok {
+			return
+		}
+
+		if opErr, ok := err.(*net.OpError); ok && (opErr.Op == "dial" || opErr.Op == "read") {
+			return
+		}
+
+		if err == syscall.ECONNREFUSED {
+			return
+		}
+	}
+
+	ctx.Logger.Emergency(":name: Unknown Mojang response error: :err", wd.NameParam(threadName), wd.ErrParam(err))
+}
--- a/api/mojang/queue/queue_test.go
+++ b/api/mojang/queue/queue_test.go
@@ -0,0 +1,525 @@
+package queue
+
+import (
+	"crypto/rand"
+	"encoding/base64"
+	"errors"
+	"net"
+	"net/url"
+	"strings"
+	"syscall"
+	"time"
+
+	"github.com/elyby/chrly/api/mojang"
+
+	"testing"
+
+	"github.com/stretchr/testify/mock"
+	"github.com/stretchr/testify/suite"
+
+	mocks "github.com/elyby/chrly/tests"
+)
+
+type mojangApiMocks struct {
+	mock.Mock
+}
+
+func (o *mojangApiMocks) UsernamesToUuids(usernames []string) ([]*mojang.ProfileInfo, error) {
+	args := o.Called(usernames)
+	var result []*mojang.ProfileInfo
+	if casted, ok := args.Get(0).([]*mojang.ProfileInfo); ok {
+		result = casted
+	}
+
+	return result, args.Error(1)
+}
+
+func (o *mojangApiMocks) UuidToTextures(uuid string, signed bool) (*mojang.SignedTexturesResponse, error) {
+	args := o.Called(uuid, signed)
+	var result *mojang.SignedTexturesResponse
+	if casted, ok := args.Get(0).(*mojang.SignedTexturesResponse); ok {
+		result = casted
+	}
+
+	return result, args.Error(1)
+}
+
+type mockStorage struct {
+	mock.Mock
+}
+
+func (m *mockStorage) GetUuid(username string) (string, error) {
+	args := m.Called(username)
+	return args.String(0), args.Error(1)
+}
+
+func (m *mockStorage) StoreUuid(username string, uuid string) error {
+	args := m.Called(username, uuid)
+	return args.Error(0)
+}
+
+func (m *mockStorage) GetTextures(uuid string) (*mojang.SignedTexturesResponse, error) {
+	args := m.Called(uuid)
+	var result *mojang.SignedTexturesResponse
+	if casted, ok := args.Get(0).(*mojang.SignedTexturesResponse); ok {
+		result = casted
+	}
+
+	return result, args.Error(1)
+}
+
+func (m *mockStorage) StoreTextures(uuid string, textures *mojang.SignedTexturesResponse) {
+	m.Called(uuid, textures)
+}
+
+type queueTestSuite struct {
+	suite.Suite
+	Queue     *JobsQueue
+	Storage   *mockStorage
+	MojangApi *mojangApiMocks
+	Logger    *mocks.WdMock
+	Iterate   func()
+
+	iterateChan chan bool
+	done        func()
+}
+
+func (suite *queueTestSuite) SetupSuite() {
+	UuidsQueueIterationDelay = 0
+}
+
+func (suite *queueTestSuite) SetupTest() {
+	suite.Storage = &mockStorage{}
+	suite.Logger = &mocks.WdMock{}
+
+	suite.Queue = &JobsQueue{Storage: suite.Storage, Logger: suite.Logger}
+
+	suite.iterateChan = make(chan bool)
+	forever = func() bool {
+		return <-suite.iterateChan
+	}
+
+	suite.Iterate = func() {
+		suite.iterateChan <- true
+	}
+
+	suite.done = func() {
+		suite.iterateChan <- false
+	}
+
+	suite.MojangApi = new(mojangApiMocks)
+	usernamesToUuids = suite.MojangApi.UsernamesToUuids
+	uuidToTextures = suite.MojangApi.UuidToTextures
+}
+
+func (suite *queueTestSuite) TearDownTest() {
+	suite.done()
+	time.Sleep(10 * time.Millisecond) // Add delay to let finish all goroutines before assert mocks calls
+	suite.MojangApi.AssertExpectations(suite.T())
+	suite.Storage.AssertExpectations(suite.T())
+	suite.Logger.AssertExpectations(suite.T())
+}
+
+func (suite *queueTestSuite) TestReceiveTexturesForOneUsernameWithoutAnyCache() {
+	expectedResult := &mojang.SignedTexturesResponse{Id: "0d252b7218b648bfb86c2ae476954d32", Name: "maksimkurb"}
+
+	suite.Logger.On("IncCounter", "mojang_textures.request", int64(1)).Once()
+	suite.Logger.On("IncCounter", "mojang_textures.usernames.queued", int64(1)).Once()
+	suite.Logger.On("UpdateGauge", "mojang_textures.usernames.iteration_size", int64(1)).Once()
+	suite.Logger.On("UpdateGauge", "mojang_textures.usernames.queue_size", int64(0)).Once()
+	suite.Logger.On("RecordTimer", "mojang_textures.usernames.round_time", mock.Anything)
+	suite.Logger.On("IncCounter", "mojang_textures.textures.request", int64(1)).Once()
+	suite.Logger.On("RecordTimer", "mojang_textures.textures.request_time", mock.Anything).Once()
+	suite.Logger.On("IncCounter", "mojang_textures.usernames.uuid_hit", int64(1)).Once()
+	suite.Logger.On("RecordTimer", "mojang_textures.result_time", mock.Anything).Once()
+
+	suite.Storage.On("GetUuid", "maksimkurb").Once().Return("", &ValueNotFound{})
+	suite.Storage.On("StoreUuid", "maksimkurb", "0d252b7218b648bfb86c2ae476954d32").Once().Return(nil)
+	suite.Storage.On("GetTextures", "0d252b7218b648bfb86c2ae476954d32").Once().Return(nil, &ValueNotFound{})
+	suite.Storage.On("StoreTextures", "0d252b7218b648bfb86c2ae476954d32", expectedResult).Once()
+
+	suite.MojangApi.On("UsernamesToUuids", []string{"maksimkurb"}).Once().Return([]*mojang.ProfileInfo{
+		{Id: "0d252b7218b648bfb86c2ae476954d32", Name: "maksimkurb"},
+	}, nil)
+	suite.MojangApi.On("UuidToTextures", "0d252b7218b648bfb86c2ae476954d32", true).Once().Return(expectedResult, nil)
+
+	resultChan := suite.Queue.GetTexturesForUsername("maksimkurb")
+
+	suite.Iterate()
+
+	result := <-resultChan
+	suite.Assert().Equal(expectedResult, result)
+}
+
+func (suite *queueTestSuite) TestReceiveTexturesForFewUsernamesWithoutAnyCache() {
+	expectedResult1 := &mojang.SignedTexturesResponse{Id: "0d252b7218b648bfb86c2ae476954d32", Name: "maksimkurb"}
+	expectedResult2 := &mojang.SignedTexturesResponse{Id: "4566e69fc90748ee8d71d7ba5aa00d20", Name: "Thinkofdeath"}
+
+	suite.Logger.On("IncCounter", "mojang_textures.request", int64(1)).Twice()
+	suite.Logger.On("IncCounter", "mojang_textures.usernames.queued", int64(1)).Twice()
+	suite.Logger.On("UpdateGauge", "mojang_textures.usernames.iteration_size", int64(2)).Once()
+	suite.Logger.On("UpdateGauge", "mojang_textures.usernames.queue_size", int64(0)).Once()
+	suite.Logger.On("RecordTimer", "mojang_textures.usernames.round_time", mock.Anything)
+	suite.Logger.On("IncCounter", "mojang_textures.textures.request", int64(1)).Twice()
+	suite.Logger.On("RecordTimer", "mojang_textures.textures.request_time", mock.Anything).Twice()
+	suite.Logger.On("IncCounter", "mojang_textures.usernames.uuid_hit", int64(1)).Twice()
+	suite.Logger.On("RecordTimer", "mojang_textures.result_time", mock.Anything).Twice()
+
+	suite.Storage.On("GetUuid", "maksimkurb").Once().Return("", &ValueNotFound{})
+	suite.Storage.On("GetUuid", "Thinkofdeath").Once().Return("", &ValueNotFound{})
+	suite.Storage.On("StoreUuid", "maksimkurb", "0d252b7218b648bfb86c2ae476954d32").Once().Return(nil)
+	suite.Storage.On("StoreUuid", "Thinkofdeath", "4566e69fc90748ee8d71d7ba5aa00d20").Once().Return(nil)
+	suite.Storage.On("GetTextures", "0d252b7218b648bfb86c2ae476954d32").Once().Return(nil, &ValueNotFound{})
+	suite.Storage.On("GetTextures", "4566e69fc90748ee8d71d7ba5aa00d20").Once().Return(nil, &ValueNotFound{})
+	suite.Storage.On("StoreTextures", "0d252b7218b648bfb86c2ae476954d32", expectedResult1).Once()
+	suite.Storage.On("StoreTextures", "4566e69fc90748ee8d71d7ba5aa00d20", expectedResult2).Once()
+
+	suite.MojangApi.On("UsernamesToUuids", []string{"maksimkurb", "Thinkofdeath"}).Once().Return([]*mojang.ProfileInfo{
+		{Id: "0d252b7218b648bfb86c2ae476954d32", Name: "maksimkurb"},
+		{Id: "4566e69fc90748ee8d71d7ba5aa00d20", Name: "Thinkofdeath"},
+	}, nil)
+	suite.MojangApi.On("UuidToTextures", "0d252b7218b648bfb86c2ae476954d32", true).Once().Return(expectedResult1, nil)
+	suite.MojangApi.On("UuidToTextures", "4566e69fc90748ee8d71d7ba5aa00d20", true).Once().Return(expectedResult2, nil)
+
+	resultChan1 := suite.Queue.GetTexturesForUsername("maksimkurb")
+	resultChan2 := suite.Queue.GetTexturesForUsername("Thinkofdeath")
+
+	suite.Iterate()
+
+	suite.Assert().Equal(expectedResult1, <-resultChan1)
+	suite.Assert().Equal(expectedResult2, <-resultChan2)
+}
+
+func (suite *queueTestSuite) TestReceiveTexturesForUsernameWithCachedUuid() {
+	expectedResult := &mojang.SignedTexturesResponse{Id: "0d252b7218b648bfb86c2ae476954d32", Name: "maksimkurb"}
+
+	suite.Logger.On("IncCounter", "mojang_textures.request", int64(1)).Once()
+	suite.Logger.On("IncCounter", "mojang_textures.usernames.cache_hit", int64(1)).Once()
+	suite.Logger.On("IncCounter", "mojang_textures.textures.request", int64(1)).Once()
+	suite.Logger.On("RecordTimer", "mojang_textures.textures.request_time", mock.Anything).Once()
+	suite.Logger.On("RecordTimer", "mojang_textures.result_time", mock.Anything).Once()
+
+	suite.Storage.On("GetUuid", "maksimkurb").Once().Return("0d252b7218b648bfb86c2ae476954d32", nil)
+	// Storage.StoreUuid shouldn't be called
+	suite.Storage.On("GetTextures", "0d252b7218b648bfb86c2ae476954d32").Once().Return(nil, &ValueNotFound{})
+	suite.Storage.On("StoreTextures", "0d252b7218b648bfb86c2ae476954d32", expectedResult).Once()
+
+	// MojangApi.UsernamesToUuids shouldn't be called
+	suite.MojangApi.On("UuidToTextures", "0d252b7218b648bfb86c2ae476954d32", true).Once().Return(expectedResult, nil)
+
+	resultChan := suite.Queue.GetTexturesForUsername("maksimkurb")
+
+	// Note that there is no iteration
+
+	result := <-resultChan
+	suite.Assert().Equal(expectedResult, result)
+}
+
+func (suite *queueTestSuite) TestReceiveTexturesForUsernameWithFullyCachedResult() {
+	expectedResult := &mojang.SignedTexturesResponse{Id: "0d252b7218b648bfb86c2ae476954d32", Name: "maksimkurb"}
+
+	suite.Logger.On("IncCounter", "mojang_textures.request", int64(1)).Once()
+	suite.Logger.On("IncCounter", "mojang_textures.usernames.cache_hit", int64(1)).Once()
+	suite.Logger.On("IncCounter", "mojang_textures.textures.cache_hit", int64(1)).Once()
+	suite.Logger.On("RecordTimer", "mojang_textures.result_time", mock.Anything).Once()
+
+	suite.Storage.On("GetUuid", "maksimkurb").Once().Return("0d252b7218b648bfb86c2ae476954d32", nil)
+	// Storage.StoreUuid shouldn't be called
+	suite.Storage.On("GetTextures", "0d252b7218b648bfb86c2ae476954d32").Once().Return(expectedResult, nil)
+	// Storage.StoreTextures shouldn't be called
+
+	// MojangApi.UsernamesToUuids shouldn't be called
+	// MojangApi.UuidToTextures shouldn't be called
+
+	resultChan := suite.Queue.GetTexturesForUsername("maksimkurb")
+
+	// Note that there is no iteration
+
+	result := <-resultChan
+	suite.Assert().Equal(expectedResult, result)
+}
+
+func (suite *queueTestSuite) TestReceiveTexturesForUsernameWithCachedUnknownUuid() {
+	suite.Logger.On("IncCounter", "mojang_textures.request", int64(1)).Once()
+	suite.Logger.On("IncCounter", "mojang_textures.usernames.cache_hit_nil", int64(1)).Once()
+
+	suite.Storage.On("GetUuid", "maksimkurb").Once().Return("", nil)
+	// Storage.StoreUuid shouldn't be called
+	// Storage.GetTextures shouldn't be called
+	// Storage.StoreTextures shouldn't be called
+
+	// MojangApi.UsernamesToUuids shouldn't be called
+	// MojangApi.UuidToTextures shouldn't be called
+
+	resultChan := suite.Queue.GetTexturesForUsername("maksimkurb")
+
+	// Note that there is no iteration
+
+	suite.Assert().Nil(<-resultChan)
+}
+
+func (suite *queueTestSuite) TestReceiveTexturesForMoreThan10Usernames() {
+	usernames := make([]string, 12)
+	for i := 0; i < cap(usernames); i++ {
+		usernames[i] = randStr(8)
+	}
+
+	suite.Logger.On("IncCounter", "mojang_textures.request", int64(1)).Times(12)
+	suite.Logger.On("IncCounter", "mojang_textures.usernames.queued", int64(1)).Times(12)
+	suite.Logger.On("UpdateGauge", "mojang_textures.usernames.iteration_size", int64(10)).Once()
+	suite.Logger.On("UpdateGauge", "mojang_textures.usernames.iteration_size", int64(2)).Once()
+	suite.Logger.On("UpdateGauge", "mojang_textures.usernames.queue_size", int64(2)).Once()
+	suite.Logger.On("UpdateGauge", "mojang_textures.usernames.queue_size", int64(0)).Once()
+	suite.Logger.On("RecordTimer", "mojang_textures.usernames.round_time", mock.Anything).Twice()
+	suite.Logger.On("IncCounter", "mojang_textures.usernames.uuid_miss", int64(1)).Times(12)
+	suite.Logger.On("RecordTimer", "mojang_textures.result_time", mock.Anything).Times(12)
+
+	suite.Storage.On("GetUuid", mock.Anything).Times(12).Return("", &ValueNotFound{})
+	suite.Storage.On("StoreUuid", mock.Anything, "").Times(12).Return(nil) // should be called with "" if username is not compared to uuid
+	// Storage.GetTextures and Storage.SetTextures shouldn't be called
+
+	suite.MojangApi.On("UsernamesToUuids", usernames[0:10]).Once().Return([]*mojang.ProfileInfo{}, nil)
+	suite.MojangApi.On("UsernamesToUuids", usernames[10:12]).Once().Return([]*mojang.ProfileInfo{}, nil)
+
+	channels := make([]chan *mojang.SignedTexturesResponse, 12)
+	for i, username := range usernames {
+		channels[i] = suite.Queue.GetTexturesForUsername(username)
+	}
+
+	suite.Iterate()
+	suite.Iterate()
+
+	for _, channel := range channels {
+		<-channel
+	}
+}
+
+func (suite *queueTestSuite) TestReceiveTexturesForTheSameUsernames() {
+	expectedResult := &mojang.SignedTexturesResponse{Id: "0d252b7218b648bfb86c2ae476954d32", Name: "maksimkurb"}
+
+	suite.Logger.On("IncCounter", "mojang_textures.request", int64(1)).Twice()
+	suite.Logger.On("IncCounter", "mojang_textures.usernames.queued", int64(1)).Once()
+	suite.Logger.On("IncCounter", "mojang_textures.already_in_queue", int64(1)).Once()
+	suite.Logger.On("UpdateGauge", "mojang_textures.usernames.iteration_size", int64(1)).Once()
+	suite.Logger.On("UpdateGauge", "mojang_textures.usernames.queue_size", int64(0)).Once()
+	suite.Logger.On("RecordTimer", "mojang_textures.usernames.round_time", mock.Anything)
+	suite.Logger.On("IncCounter", "mojang_textures.textures.request", int64(1)).Once()
+	suite.Logger.On("RecordTimer", "mojang_textures.textures.request_time", mock.Anything).Once()
+	suite.Logger.On("IncCounter", "mojang_textures.usernames.uuid_hit", int64(1)).Once()
+	suite.Logger.On("RecordTimer", "mojang_textures.result_time", mock.Anything).Once()
+
+	suite.Storage.On("GetUuid", "maksimkurb").Twice().Return("", &ValueNotFound{})
+	suite.Storage.On("StoreUuid", "maksimkurb", "0d252b7218b648bfb86c2ae476954d32").Once().Return(nil)
+	suite.Storage.On("GetTextures", "0d252b7218b648bfb86c2ae476954d32").Once().Return(nil, &ValueNotFound{})
+	suite.Storage.On("StoreTextures", "0d252b7218b648bfb86c2ae476954d32", expectedResult).Once()
+	suite.MojangApi.On("UsernamesToUuids", []string{"maksimkurb"}).Once().Return([]*mojang.ProfileInfo{
+		{Id: "0d252b7218b648bfb86c2ae476954d32", Name: "maksimkurb"},
+	}, nil)
+	suite.MojangApi.On("UuidToTextures", "0d252b7218b648bfb86c2ae476954d32", true).Once().Return(expectedResult, nil)
+
+	resultChan1 := suite.Queue.GetTexturesForUsername("maksimkurb")
+	resultChan2 := suite.Queue.GetTexturesForUsername("maksimkurb")
+
+	suite.Iterate()
+
+	suite.Assert().Equal(expectedResult, <-resultChan1)
+	suite.Assert().Equal(expectedResult, <-resultChan2)
+}
+
+func (suite *queueTestSuite) TestReceiveTexturesForUsernameThatAlreadyProcessing() {
+	expectedResult := &mojang.SignedTexturesResponse{Id: "0d252b7218b648bfb86c2ae476954d32", Name: "maksimkurb"}
+
+	suite.Logger.On("IncCounter", "mojang_textures.request", int64(1)).Twice()
+	suite.Logger.On("IncCounter", "mojang_textures.usernames.queued", int64(1)).Once()
+	suite.Logger.On("IncCounter", "mojang_textures.already_in_queue", int64(1)).Once()
+	suite.Logger.On("UpdateGauge", "mojang_textures.usernames.iteration_size", int64(1)).Once()
+	suite.Logger.On("UpdateGauge", "mojang_textures.usernames.queue_size", int64(0)).Once()
+	suite.Logger.On("RecordTimer", "mojang_textures.usernames.round_time", mock.Anything)
+	suite.Logger.On("IncCounter", "mojang_textures.textures.request", int64(1)).Once()
+	suite.Logger.On("RecordTimer", "mojang_textures.textures.request_time", mock.Anything).Once()
+	suite.Logger.On("IncCounter", "mojang_textures.usernames.uuid_hit", int64(1)).Once()
+	suite.Logger.On("RecordTimer", "mojang_textures.result_time", mock.Anything).Once()
+
+	suite.Storage.On("GetUuid", "maksimkurb").Twice().Return("", &ValueNotFound{})
+	suite.Storage.On("StoreUuid", "maksimkurb", "0d252b7218b648bfb86c2ae476954d32").Once().Return(nil)
+	suite.Storage.On("GetTextures", "0d252b7218b648bfb86c2ae476954d32").Once().Return(nil, &ValueNotFound{})
+	suite.Storage.On("StoreTextures", "0d252b7218b648bfb86c2ae476954d32", expectedResult).Once()
+
+	suite.MojangApi.On("UsernamesToUuids", []string{"maksimkurb"}).Once().Return([]*mojang.ProfileInfo{
+		{Id: "0d252b7218b648bfb86c2ae476954d32", Name: "maksimkurb"},
+	}, nil)
+	suite.MojangApi.On("UuidToTextures", "0d252b7218b648bfb86c2ae476954d32", true).
+		Once().
+		After(10*time.Millisecond). // Simulate long round trip
+		Return(expectedResult, nil)
+
+	resultChan1 := suite.Queue.GetTexturesForUsername("maksimkurb")
+
+	// Note that for entire test there is only one iteration
+	suite.Iterate()
+
+	// Let it meet delayed UuidToTextures request
+	time.Sleep(5 * time.Millisecond)
+
+	resultChan2 := suite.Queue.GetTexturesForUsername("maksimkurb")
+
+	suite.Assert().Equal(expectedResult, <-resultChan1)
+	suite.Assert().Equal(expectedResult, <-resultChan2)
+}
+
+func (suite *queueTestSuite) TestDoNothingWhenNoTasks() {
+	suite.Logger.On("IncCounter", "mojang_textures.request", int64(1)).Once()
+	suite.Logger.On("IncCounter", "mojang_textures.usernames.queued", int64(1)).Once()
+	suite.Logger.On("UpdateGauge", "mojang_textures.usernames.iteration_size", int64(1)).Once()
+	suite.Logger.On("UpdateGauge", "mojang_textures.usernames.queue_size", int64(0)).Once()
+	suite.Logger.On("RecordTimer", "mojang_textures.usernames.round_time", mock.Anything)
+	suite.Logger.On("IncCounter", "mojang_textures.usernames.uuid_miss", int64(1)).Once()
+	suite.Logger.On("RecordTimer", "mojang_textures.result_time", mock.Anything).Once()
+
+	suite.Storage.On("GetUuid", "maksimkurb").Once().Return("", &ValueNotFound{})
+	suite.Storage.On("StoreUuid", "maksimkurb", "").Once().Return(nil)
+	// Storage.GetTextures and Storage.StoreTextures shouldn't be called
+
+	suite.MojangApi.On("UsernamesToUuids", []string{"maksimkurb"}).Once().Return([]*mojang.ProfileInfo{}, nil)
+
+	// Perform first iteration and await it finish
+	resultChan := suite.Queue.GetTexturesForUsername("maksimkurb")
+
+	suite.Iterate()
+
+	suite.Assert().Nil(<-resultChan)
+
+	// Let it to perform a few more iterations to ensure, that there is no calls to external APIs
+	suite.Iterate()
+	suite.Iterate()
+}
+
+type timeoutError struct {
+}
+
+func (*timeoutError) Error() string   { return "timeout error" }
+func (*timeoutError) Timeout() bool   { return true }
+func (*timeoutError) Temporary() bool { return false }
+
+var expectedErrors = []error{
+	&mojang.BadRequestError{},
+	&mojang.ForbiddenError{},
+	&mojang.TooManyRequestsError{},
+	&mojang.ServerError{},
+	&timeoutError{},
+	&url.Error{Op: "GET", URL: "http://localhost"},
+	&net.OpError{Op: "read"},
+	&net.OpError{Op: "dial"},
+	syscall.ECONNREFUSED,
+}
+
+func (suite *queueTestSuite) TestShouldNotLogErrorWhenExpectedErrorReturnedFromUsernameToUuidRequest() {
+	suite.Logger.On("IncCounter", mock.Anything, mock.Anything)
+	suite.Logger.On("UpdateGauge", mock.Anything, mock.Anything)
+	suite.Logger.On("RecordTimer", mock.Anything, mock.Anything)
+	suite.Logger.On("Debug", ":name: Got response error :err", mock.Anything, mock.Anything).Times(len(expectedErrors))
+	suite.Logger.On("Warning", ":name: Got 400 Bad Request :err", mock.Anything, mock.Anything).Once()
+	suite.Logger.On("Warning", ":name: Got 403 Forbidden :err", mock.Anything, mock.Anything).Once()
+	suite.Logger.On("Warning", ":name: Got 429 Too Many Requests :err", mock.Anything, mock.Anything).Once()
+
+	suite.Storage.On("GetUuid", "maksimkurb").Return("", &ValueNotFound{})
+
+	for _, err := range expectedErrors {
+		suite.MojangApi.On("UsernamesToUuids", []string{"maksimkurb"}).Once().Return(nil, err)
+
+		resultChan := suite.Queue.GetTexturesForUsername("maksimkurb")
+		suite.Iterate()
+		suite.Assert().Nil(<-resultChan)
+		suite.MojangApi.AssertExpectations(suite.T())
+		suite.MojangApi.ExpectedCalls = nil // https://github.com/stretchr/testify/issues/558#issuecomment-372112364
+	}
+}
+
+func (suite *queueTestSuite) TestShouldLogEmergencyOnUnexpectedErrorReturnedFromUsernameToUuidRequest() {
+	suite.Logger.On("IncCounter", mock.Anything, mock.Anything)
+	suite.Logger.On("UpdateGauge", mock.Anything, mock.Anything)
+	suite.Logger.On("RecordTimer", mock.Anything, mock.Anything)
+	suite.Logger.On("Debug", ":name: Got response error :err", mock.Anything, mock.Anything).Once()
+	suite.Logger.On("Emergency", ":name: Unknown Mojang response error: :err", mock.Anything, mock.Anything).Once()
+
+	suite.Storage.On("GetUuid", "maksimkurb").Return("", &ValueNotFound{})
+
+	suite.MojangApi.On("UsernamesToUuids", []string{"maksimkurb"}).Once().Return(nil, errors.New("unexpected error"))
+
+	resultChan := suite.Queue.GetTexturesForUsername("maksimkurb")
+	suite.Iterate()
+	suite.Assert().Nil(<-resultChan)
+}
+
+func (suite *queueTestSuite) TestShouldNotLogErrorWhenExpectedErrorReturnedFromUuidToTexturesRequest() {
+	suite.Logger.On("IncCounter", mock.Anything, mock.Anything)
+	suite.Logger.On("UpdateGauge", mock.Anything, mock.Anything)
+	suite.Logger.On("RecordTimer", mock.Anything, mock.Anything)
+	suite.Logger.On("Debug", ":name: Got response error :err", mock.Anything, mock.Anything).Times(len(expectedErrors))
+	suite.Logger.On("Warning", ":name: Got 400 Bad Request :err", mock.Anything, mock.Anything).Once()
+	suite.Logger.On("Warning", ":name: Got 403 Forbidden :err", mock.Anything, mock.Anything).Once()
+	suite.Logger.On("Warning", ":name: Got 429 Too Many Requests :err", mock.Anything, mock.Anything).Once()
+
+	suite.Storage.On("GetUuid", "maksimkurb").Return("", &ValueNotFound{})
+	suite.Storage.On("StoreUuid", "maksimkurb", "0d252b7218b648bfb86c2ae476954d32").Return(nil)
+	suite.Storage.On("GetTextures", "0d252b7218b648bfb86c2ae476954d32").Return(nil, &ValueNotFound{})
+	suite.Storage.On("StoreTextures", "0d252b7218b648bfb86c2ae476954d32", (*mojang.SignedTexturesResponse)(nil))
+
+	for _, err := range expectedErrors {
+		suite.MojangApi.On("UsernamesToUuids", []string{"maksimkurb"}).Once().Return([]*mojang.ProfileInfo{
+			{Id: "0d252b7218b648bfb86c2ae476954d32", Name: "maksimkurb"},
+		}, nil)
+		suite.MojangApi.On("UuidToTextures", "0d252b7218b648bfb86c2ae476954d32", true).Once().Return(nil, err)
+
+		resultChan := suite.Queue.GetTexturesForUsername("maksimkurb")
+		suite.Iterate()
+		suite.Assert().Nil(<-resultChan)
+		suite.MojangApi.AssertExpectations(suite.T())
+		suite.MojangApi.ExpectedCalls = nil // https://github.com/stretchr/testify/issues/558#issuecomment-372112364
+	}
+}
+
+func (suite *queueTestSuite) TestShouldLogEmergencyOnUnexpectedErrorReturnedFromUuidToTexturesRequest() {
+	suite.Logger.On("IncCounter", mock.Anything, mock.Anything)
+	suite.Logger.On("UpdateGauge", mock.Anything, mock.Anything)
+	suite.Logger.On("RecordTimer", mock.Anything, mock.Anything)
+	suite.Logger.On("Debug", ":name: Got response error :err", mock.Anything, mock.Anything).Once()
+	suite.Logger.On("Emergency", ":name: Unknown Mojang response error: :err", mock.Anything, mock.Anything).Once()
+
+	suite.Storage.On("GetUuid", "maksimkurb").Return("", &ValueNotFound{})
+	suite.Storage.On("StoreUuid", "maksimkurb", "0d252b7218b648bfb86c2ae476954d32").Return(nil)
+	suite.Storage.On("GetTextures", "0d252b7218b648bfb86c2ae476954d32").Return(nil, &ValueNotFound{})
+	suite.Storage.On("StoreTextures", "0d252b7218b648bfb86c2ae476954d32", (*mojang.SignedTexturesResponse)(nil))
+
+	suite.MojangApi.On("UsernamesToUuids", []string{"maksimkurb"}).Once().Return([]*mojang.ProfileInfo{
+		{Id: "0d252b7218b648bfb86c2ae476954d32", Name: "maksimkurb"},
+	}, nil)
+	suite.MojangApi.On("UuidToTextures", "0d252b7218b648bfb86c2ae476954d32", true).Once().Return(nil, errors.New("unexpected error"))
+
+	resultChan := suite.Queue.GetTexturesForUsername("maksimkurb")
+	suite.Iterate()
+	suite.Assert().Nil(<-resultChan)
+}
+
+func (suite *queueTestSuite) TestReceiveTexturesForNotAllowedMojangUsername() {
+	suite.Logger.On("IncCounter", "mojang_textures.invalid_username", int64(1)).Once()
+
+	resultChan := suite.Queue.GetTexturesForUsername("Not allowed")
+	suite.Assert().Nil(<-resultChan)
+}
+
+func TestJobsQueueSuite(t *testing.T) {
+	suite.Run(t, new(queueTestSuite))
+}
+
+var replacer = strings.NewReplacer("-", "_", "=", "")
+
+// https://stackoverflow.com/a/50581165
+func randStr(len int) string {
+	buff := make([]byte, len)
+	_, _ = rand.Read(buff)
+	str := replacer.Replace(base64.URLEncoding.EncodeToString(buff))
+
+	// Base 64 can be longer than len
+	return str[:len]
+}
--- a/api/mojang/queue/storage.go
+++ b/api/mojang/queue/storage.go
@@ -0,0 +1,53 @@
+package queue
+
+import "github.com/elyby/chrly/api/mojang"
+
+type UuidsStorage interface {
+	GetUuid(username string) (string, error)
+	StoreUuid(username string, uuid string) error
+}
+
+// nil value can be passed to the storage to indicate that there is no textures
+// for uuid and we know about it. Return err only in case, when storage completely
+// unable to load any information about textures
+type TexturesStorage interface {
+	GetTextures(uuid string) (*mojang.SignedTexturesResponse, error)
+	StoreTextures(uuid string, textures *mojang.SignedTexturesResponse)
+}
+
+type Storage interface {
+	UuidsStorage
+	TexturesStorage
+}
+
+// SplittedStorage allows you to use separate storage engines to satisfy
+// the Storage interface
+type SplittedStorage struct {
+	UuidsStorage
+	TexturesStorage
+}
+
+func (s *SplittedStorage) GetUuid(username string) (string, error) {
+	return s.UuidsStorage.GetUuid(username)
+}
+
+func (s *SplittedStorage) StoreUuid(username string, uuid string) error {
+	return s.UuidsStorage.StoreUuid(username, uuid)
+}
+
+func (s *SplittedStorage) GetTextures(uuid string) (*mojang.SignedTexturesResponse, error) {
+	return s.TexturesStorage.GetTextures(uuid)
+}
+
+func (s *SplittedStorage) StoreTextures(uuid string, textures *mojang.SignedTexturesResponse) {
+	s.TexturesStorage.StoreTextures(uuid, textures)
+}
+
+// This error can be used to indicate, that requested
+// value doesn't exists in the storage
+type ValueNotFound struct {
+}
+
+func (*ValueNotFound) Error() string {
+	return "value not found in the storage"
+}
--- a/api/mojang/queue/storage_test.go
+++ b/api/mojang/queue/storage_test.go
@@ -0,0 +1,89 @@
+package queue
+
+import (
+	"github.com/elyby/chrly/api/mojang"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/mock"
+	"testing"
+)
+
+type uuidsStorageMock struct {
+	mock.Mock
+}
+
+func (m *uuidsStorageMock) GetUuid(username string) (string, error) {
+	args := m.Called(username)
+	return args.String(0), args.Error(1)
+}
+
+func (m *uuidsStorageMock) StoreUuid(username string, uuid string) error {
+	m.Called(username, uuid)
+	return nil
+}
+
+type texturesStorageMock struct {
+	mock.Mock
+}
+
+func (m *texturesStorageMock) GetTextures(uuid string) (*mojang.SignedTexturesResponse, error) {
+	args := m.Called(uuid)
+	var result *mojang.SignedTexturesResponse
+	if casted, ok := args.Get(0).(*mojang.SignedTexturesResponse); ok {
+		result = casted
+	}
+
+	return result, args.Error(1)
+}
+
+func (m *texturesStorageMock) StoreTextures(uuid string, textures *mojang.SignedTexturesResponse) {
+	m.Called(uuid, textures)
+}
+
+func TestSplittedStorage(t *testing.T) {
+	createMockedStorage := func() (*SplittedStorage, *uuidsStorageMock, *texturesStorageMock) {
+		uuidsStorage := &uuidsStorageMock{}
+		texturesStorage := &texturesStorageMock{}
+
+		return &SplittedStorage{uuidsStorage, texturesStorage}, uuidsStorage, texturesStorage
+	}
+
+	t.Run("GetUuid", func(t *testing.T) {
+		storage, uuidsMock, _ := createMockedStorage()
+		uuidsMock.On("GetUuid", "username").Once().Return("find me", nil)
+		result, err := storage.GetUuid("username")
+		assert.Nil(t, err)
+		assert.Equal(t, "find me", result)
+		uuidsMock.AssertExpectations(t)
+	})
+
+	t.Run("StoreUuid", func(t *testing.T) {
+		storage, uuidsMock, _ := createMockedStorage()
+		uuidsMock.On("StoreUuid", "username", "result").Once()
+		_ = storage.StoreUuid("username", "result")
+		uuidsMock.AssertExpectations(t)
+	})
+
+	t.Run("GetTextures", func(t *testing.T) {
+		result := &mojang.SignedTexturesResponse{Id: "mock id"}
+		storage, _, texturesMock := createMockedStorage()
+		texturesMock.On("GetTextures", "uuid").Once().Return(result, nil)
+		returned, err := storage.GetTextures("uuid")
+		assert.Nil(t, err)
+		assert.Equal(t, result, returned)
+		texturesMock.AssertExpectations(t)
+	})
+
+	t.Run("StoreTextures", func(t *testing.T) {
+		toStore := &mojang.SignedTexturesResponse{}
+		storage, _, texturesMock := createMockedStorage()
+		texturesMock.On("StoreTextures", "mock id", toStore).Once()
+		storage.StoreTextures("mock id", toStore)
+		texturesMock.AssertExpectations(t)
+	})
+}
+
+func TestValueNotFound_Error(t *testing.T) {
+	err := &ValueNotFound{}
+	assert.Equal(t, "value not found in the storage", err.Error())
+}
--- a/api/mojang/textures.go
+++ b/api/mojang/textures.go
@@ -0,0 +1,51 @@
+package mojang
+
+import (
+	"encoding/base64"
+	"encoding/json"
+)
+
+type TexturesProp struct {
+	Timestamp   int64             `json:"timestamp"`
+	ProfileID   string            `json:"profileId"`
+	ProfileName string            `json:"profileName"`
+	Textures    *TexturesResponse `json:"textures"`
+}
+
+type TexturesResponse struct {
+	Skin *SkinTexturesResponse `json:"SKIN,omitempty"`
+	Cape *CapeTexturesResponse `json:"CAPE,omitempty"`
+}
+
+type SkinTexturesResponse struct {
+	Url      string                `json:"url"`
+	Metadata *SkinTexturesMetadata `json:"metadata,omitempty"`
+}
+
+type SkinTexturesMetadata struct {
+	Model string `json:"model"`
+}
+
+type CapeTexturesResponse struct {
+	Url string `json:"url"`
+}
+
+func DecodeTextures(encodedTextures string) (*TexturesProp, error) {
+	jsonStr, err := base64.URLEncoding.DecodeString(encodedTextures)
+	if err != nil {
+		return nil, err
+	}
+
+	var result *TexturesProp
+	err = json.Unmarshal(jsonStr, &result)
+	if err != nil {
+		return nil, err
+	}
+
+	return result, nil
+}
+
+func EncodeTextures(textures *TexturesProp) string {
+	jsonSerialized, _ := json.Marshal(textures)
+	return base64.URLEncoding.EncodeToString(jsonSerialized)
+}
--- a/api/mojang/textures_test.go
+++ b/api/mojang/textures_test.go
@@ -0,0 +1,112 @@
+package mojang
+
+import (
+	testify "github.com/stretchr/testify/assert"
+	"testing"
+)
+
+type texturesTestCase struct {
+	Name    string
+	Encoded string
+	Decoded *TexturesProp
+}
+
+var texturesTestCases = []*texturesTestCase{
+	{
+		Name:    "property without textures",
+		Encoded: "eyJ0aW1lc3RhbXAiOjE1NTU4NTYwMTA0OTQsInByb2ZpbGVJZCI6IjNlM2VlNmMzNWFmYTQ4YWJiNjFlOGNkOGM0MmZjMGQ5IiwicHJvZmlsZU5hbWUiOiJFcmlja1NrcmF1Y2giLCJ0ZXh0dXJlcyI6e319",
+		Decoded: &TexturesProp{
+			ProfileID:   "3e3ee6c35afa48abb61e8cd8c42fc0d9",
+			ProfileName: "ErickSkrauch",
+			Timestamp:   int64(1555856010494),
+			Textures:    &TexturesResponse{},
+		},
+	},
+	{
+		Name:    "property with classic skin textures",
+		Encoded: "eyJ0aW1lc3RhbXAiOjE1NTU4NTYzMDc0MTIsInByb2ZpbGVJZCI6IjNlM2VlNmMzNWFmYTQ4YWJiNjFlOGNkOGM0MmZjMGQ5IiwicHJvZmlsZU5hbWUiOiJFcmlja1NrcmF1Y2giLCJ0ZXh0dXJlcyI6eyJTS0lOIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvZmMxNzU3NjMzN2ExMDZkOWMyMmFjNzgyZTM2MmMxNmM0ZTBlNDliZTUzZmFhNDE4NTdiZmYzMzJiNzc5MjgxZSJ9fX0=",
+		Decoded: &TexturesProp{
+			ProfileID:   "3e3ee6c35afa48abb61e8cd8c42fc0d9",
+			ProfileName: "ErickSkrauch",
+			Timestamp:   int64(1555856307412),
+			Textures: &TexturesResponse{
+				Skin: &SkinTexturesResponse{
+					Url: "http://textures.minecraft.net/texture/fc17576337a106d9c22ac782e362c16c4e0e49be53faa41857bff332b779281e",
+				},
+			},
+		},
+	},
+	{
+		Name:    "property with alex skin textures",
+		Encoded: "eyJ0aW1lc3RhbXAiOjE1NTU4NTY0OTQ3OTEsInByb2ZpbGVJZCI6IjNlM2VlNmMzNWFmYTQ4YWJiNjFlOGNkOGM0MmZjMGQ5IiwicHJvZmlsZU5hbWUiOiJFcmlja1NrcmF1Y2giLCJ0ZXh0dXJlcyI6eyJTS0lOIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvNjlmNzUzNWY4YzNhMjE1ZDFkZTc3MmIyODdmMTc3M2IzNTg5OGVmNzUyZDI2YmRkZjRhMjVhZGFiNjVjMTg1OSIsIm1ldGFkYXRhIjp7Im1vZGVsIjoic2xpbSJ9fX19",
+		Decoded: &TexturesProp{
+			ProfileID:   "3e3ee6c35afa48abb61e8cd8c42fc0d9",
+			ProfileName: "ErickSkrauch",
+			Timestamp:   int64(1555856494791),
+			Textures: &TexturesResponse{
+				Skin: &SkinTexturesResponse{
+					Url: "http://textures.minecraft.net/texture/69f7535f8c3a215d1de772b287f1773b35898ef752d26bddf4a25adab65c1859",
+					Metadata: &SkinTexturesMetadata{
+						Model: "slim",
+					},
+				},
+			},
+		},
+	},
+	{
+		Name:    "property with skin and cape textures",
+		Encoded: "eyJ0aW1lc3RhbXAiOjE1NTU4NTc2NzUzMzUsInByb2ZpbGVJZCI6ImQ5MGI2OGJjODE3MjQzMjlhMDQ3ZjExODZkY2Q0MzM2IiwicHJvZmlsZU5hbWUiOiJha3Jvbm1hbjEiLCJ0ZXh0dXJlcyI6eyJTS0lOIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvM2U2ZGVmY2I3ZGU1YTBlMDVjNzUyNWM2Y2Q0NmU0YjliNDE2YjkyZTBjZjRiYWExZTBhOWUyMTJhODg3ZjNmNyJ9LCJDQVBFIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvNzBlZmZmYWY4NmZlNWJjMDg5NjA4ZDNjYjI5N2QzZTI3NmI5ZWI3YThmOWYyZmU2NjU5YzIzYTJkOGIxOGVkZiJ9fX0=",
+		Decoded: &TexturesProp{
+			ProfileID:   "d90b68bc81724329a047f1186dcd4336",
+			ProfileName: "akronman1",
+			Timestamp:   int64(1555857675335),
+			Textures: &TexturesResponse{
+				Skin: &SkinTexturesResponse{
+					Url: "http://textures.minecraft.net/texture/3e6defcb7de5a0e05c7525c6cd46e4b9b416b92e0cf4baa1e0a9e212a887f3f7",
+				},
+				Cape: &CapeTexturesResponse{
+					Url: "http://textures.minecraft.net/texture/70efffaf86fe5bc089608d3cb297d3e276b9eb7a8f9f2fe6659c23a2d8b18edf",
+				},
+			},
+		},
+	},
+}
+
+func TestDecodeTextures(t *testing.T) {
+	for _, testCase := range texturesTestCases {
+		t.Run("decode "+testCase.Name, func(t *testing.T) {
+			assert := testify.New(t)
+
+			result, err := DecodeTextures(testCase.Encoded)
+			assert.Nil(err)
+			assert.Equal(testCase.Decoded, result)
+		})
+	}
+
+	t.Run("should return error if invalid base64 passed", func(t *testing.T) {
+		assert := testify.New(t)
+
+		result, err := DecodeTextures("invalid base64")
+		assert.Error(err)
+		assert.Nil(result)
+	})
+
+	t.Run("should return error if invalid json found inside base64", func(t *testing.T) {
+		assert := testify.New(t)
+
+		result, err := DecodeTextures("aW52YWxpZCBqc29u") // encoded "invalid json"
+		assert.Error(err)
+		assert.Nil(result)
+	})
+}
+
+func TestEncodeTextures(t *testing.T) {
+	for _, testCase := range texturesTestCases {
+		t.Run("encode "+testCase.Name, func(t *testing.T) {
+			assert := testify.New(t)
+
+			result := EncodeTextures(testCase.Decoded)
+			assert.Equal(testCase.Encoded, result)
+		})
+	}
+}
--- a/auth/jwt.go
+++ b/auth/jwt.go
@@ -0,0 +1,82 @@
+package auth
+
+import (
+	"errors"
+	"net/http"
+	"strings"
+	"time"
+
+	"github.com/SermoDigital/jose/crypto"
+	"github.com/SermoDigital/jose/jws"
+)
+
+var hashAlg = crypto.SigningMethodHS256
+
+const scopesClaim = "scopes"
+
+type Scope string
+
+var (
+	SkinScope = Scope("skin")
+)
+
+type JwtAuth struct {
+	Key []byte
+}
+
+func (t *JwtAuth) NewToken(scopes ...Scope) ([]byte, error) {
+	if len(t.Key) == 0 {
+		return nil, errors.New("signing key not available")
+	}
+
+	claims := jws.Claims{}
+	claims.Set(scopesClaim, scopes)
+	claims.SetIssuedAt(time.Now())
+	encoder := jws.NewJWT(claims, hashAlg)
+	token, err := encoder.Serialize(t.Key)
+	if err != nil {
+		return nil, err
+	}
+
+	return token, nil
+}
+
+func (t *JwtAuth) Check(req *http.Request) error {
+	if len(t.Key) == 0 {
+		return &Unauthorized{"Signing key not set"}
+	}
+
+	bearerToken := req.Header.Get("Authorization")
+	if bearerToken == "" {
+		return &Unauthorized{"Authentication header not presented"}
+	}
+
+	if !strings.EqualFold(bearerToken[0:7], "BEARER ") {
+		return &Unauthorized{"Cannot recognize JWT token in passed value"}
+	}
+
+	tokenStr := bearerToken[7:]
+	token, err := jws.ParseJWT([]byte(tokenStr))
+	if err != nil {
+		return &Unauthorized{"Cannot parse passed JWT token"}
+	}
+
+	err = token.Validate(t.Key, hashAlg)
+	if err != nil {
+		return &Unauthorized{"JWT token have invalid signature. It may be corrupted or expired."}
+	}
+
+	return nil
+}
+
+type Unauthorized struct {
+	Reason string
+}
+
+func (e *Unauthorized) Error() string {
+	if e.Reason != "" {
+		return e.Reason
+	}
+
+	return "Unauthorized"
+}
--- a/auth/jwt_test.go
+++ b/auth/jwt_test.go
@@ -0,0 +1,97 @@
+package auth
+
+import (
+	"net/http/httptest"
+	"testing"
+
+	testify "github.com/stretchr/testify/assert"
+)
+
+const jwt = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxNTE2NjU4MTkzIiwic2NvcGVzIjoic2tpbiJ9.agbBS0qdyYMBaVfTZJAZcTTRgW1Y0kZty4H3N2JHBO8"
+
+func TestJwtAuth_NewToken_Success(t *testing.T) {
+	assert := testify.New(t)
+
+	jwt := &JwtAuth{[]byte("secret")}
+	token, err := jwt.NewToken(SkinScope)
+	assert.Nil(err)
+	assert.NotNil(token)
+}
+
+func TestJwtAuth_NewToken_KeyNotAvailable(t *testing.T) {
+	assert := testify.New(t)
+
+	jwt := &JwtAuth{}
+	token, err := jwt.NewToken(SkinScope)
+	assert.Error(err, "signing key not available")
+	assert.Nil(token)
+}
+
+func TestJwtAuth_Check_EmptyRequest(t *testing.T) {
+	assert := testify.New(t)
+
+	req := httptest.NewRequest("POST", "http://localhost", nil)
+	jwt := &JwtAuth{[]byte("secret")}
+
+	err := jwt.Check(req)
+	assert.IsType(&Unauthorized{}, err)
+	assert.EqualError(err, "Authentication header not presented")
+}
+
+func TestJwtAuth_Check_NonBearer(t *testing.T) {
+	assert := testify.New(t)
+
+	req := httptest.NewRequest("POST", "http://localhost", nil)
+	req.Header.Add("Authorization", "this is not jwt")
+	jwt := &JwtAuth{[]byte("secret")}
+
+	err := jwt.Check(req)
+	assert.IsType(&Unauthorized{}, err)
+	assert.EqualError(err, "Cannot recognize JWT token in passed value")
+}
+
+func TestJwtAuth_Check_BearerButNotJwt(t *testing.T) {
+	assert := testify.New(t)
+
+	req := httptest.NewRequest("POST", "http://localhost", nil)
+	req.Header.Add("Authorization", "Bearer thisIs.Not.Jwt")
+	jwt := &JwtAuth{[]byte("secret")}
+
+	err := jwt.Check(req)
+	assert.IsType(&Unauthorized{}, err)
+	assert.EqualError(err, "Cannot parse passed JWT token")
+}
+
+func TestJwtAuth_Check_SecretNotAvailable(t *testing.T) {
+	assert := testify.New(t)
+
+	req := httptest.NewRequest("POST", "http://localhost", nil)
+	req.Header.Add("Authorization", "Bearer " + jwt)
+	jwt := &JwtAuth{}
+
+	err := jwt.Check(req)
+	assert.Error(err, "Signing key not set")
+}
+
+func TestJwtAuth_Check_SecretInvalid(t *testing.T) {
+	assert := testify.New(t)
+
+	req := httptest.NewRequest("POST", "http://localhost", nil)
+	req.Header.Add("Authorization", "Bearer " + jwt)
+	jwt := &JwtAuth{[]byte("this is another secret")}
+
+	err := jwt.Check(req)
+	assert.IsType(&Unauthorized{}, err)
+	assert.EqualError(err, "JWT token have invalid signature. It may be corrupted or expired.")
+}
+
+func TestJwtAuth_Check_Valid(t *testing.T) {
+	assert := testify.New(t)
+
+	req := httptest.NewRequest("POST", "http://localhost", nil)
+	req.Header.Add("Authorization", "Bearer " + jwt)
+	jwt := &JwtAuth{[]byte("secret")}
+
+	err := jwt.Check(req)
+	assert.Nil(err)
+}
--- a/bootstrap/bootstrap.go
+++ b/bootstrap/bootstrap.go
@@ -0,0 +1,64 @@
+package bootstrap
+
+import (
+	"os"
+
+	"github.com/getsentry/raven-go"
+	"github.com/mono83/slf/rays"
+	"github.com/mono83/slf/recievers/sentry"
+	"github.com/mono83/slf/recievers/statsd"
+	"github.com/mono83/slf/recievers/writer"
+	"github.com/mono83/slf/wd"
+)
+
+var version = ""
+
+func GetVersion() string {
+	return version
+}
+
+func CreateLogger(statsdAddr string, sentryAddr string) (wd.Watchdog, error) {
+	wd.AddReceiver(writer.New(writer.Options{
+		Marker: false,
+		TimeFormat: "15:04:05.000",
+	}))
+	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)
+	}
+
+	if sentryAddr != "" {
+		ravenClient, err := raven.New(sentryAddr)
+		if err != nil {
+			return nil, err
+		}
+
+		ravenClient.SetEnvironment("production")
+		ravenClient.SetDefaultLoggerName("sentry-watchdog-receiver")
+		programVersion := GetVersion()
+		if programVersion != "" {
+			raven.SetRelease(programVersion)
+		}
+
+		sentryReceiver, err := sentry.NewReceiverWithCustomRaven(ravenClient, &sentry.Config{
+			MinLevel: "warn",
+		})
+		if err != nil {
+			return nil, err
+		}
+
+		wd.AddReceiver(sentryReceiver)
+	}
+
+	return wd.New("", "").WithParams(rays.Host), nil
+}
--- a/cmd/root.go
+++ b/cmd/root.go
@@ -0,0 +1,37 @@
+package cmd
+
+import (
+	"fmt"
+	"os"
+	"strings"
+
+	"github.com/elyby/chrly/bootstrap"
+
+	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
+)
+
+var RootCmd = &cobra.Command{
+	Use:     "chrly",
+	Short:   "Implementation of Minecraft skins system server",
+	Version: bootstrap.GetVersion(),
+}
+
+// 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)
+}
+
+func initConfig() {
+	viper.AutomaticEnv()
+	replacer := strings.NewReplacer(".", "_")
+	viper.SetEnvKeyReplacer(replacer)
+}
--- a/cmd/serve.go
+++ b/cmd/serve.go
@@ -0,0 +1,92 @@
+package cmd
+
+import (
+	"fmt"
+	"log"
+	"time"
+
+	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
+
+	"github.com/elyby/chrly/api/mojang/queue"
+	"github.com/elyby/chrly/auth"
+	"github.com/elyby/chrly/bootstrap"
+	"github.com/elyby/chrly/db"
+	"github.com/elyby/chrly/http"
+)
+
+var serveCmd = &cobra.Command{
+	Use:   "serve",
+	Short: "Starts http handler for the skins system",
+	Run: func(cmd *cobra.Command, args []string) {
+		logger, err := bootstrap.CreateLogger(viper.GetString("statsd.addr"), viper.GetString("sentry.dsn"))
+		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")
+		redisFactory := storageFactory.CreateFactory("redis")
+		skinsRepo, err := redisFactory.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")
+		filesystemFactory := storageFactory.CreateFactory("filesystem")
+		capesRepo, err := filesystemFactory.CreateCapesRepository()
+		if err != nil {
+			logger.Emergency(fmt.Sprintf("Error on creating capes repo: %v", err))
+			return
+		}
+		logger.Info("Capes repository successfully initialized")
+
+		logger.Info("Preparing Mojang's textures queue")
+		mojangUuidsRepository, err := redisFactory.CreateMojangUuidsRepository()
+		if err != nil {
+			logger.Emergency(fmt.Sprintf("Error on creating mojang uuids repo: %v", err))
+			return
+		}
+
+		queue.UuidsQueueIterationDelay = time.Duration(viper.GetInt("queue.loop_delay")) * time.Millisecond
+		texturesStorage := queue.CreateInMemoryTexturesStorage()
+		texturesStorage.Start()
+		mojangTexturesQueue := &queue.JobsQueue{
+			Logger: logger,
+			Storage: &queue.SplittedStorage{
+				UuidsStorage:    mojangUuidsRepository,
+				TexturesStorage: texturesStorage,
+			},
+		}
+		logger.Info("Mojang's textures queue is successfully initialized")
+
+		cfg := &http.Config{
+			ListenSpec:          fmt.Sprintf("%s:%d", viper.GetString("server.host"), viper.GetInt("server.port")),
+			SkinsRepo:           skinsRepo,
+			CapesRepo:           capesRepo,
+			MojangTexturesQueue: mojangTexturesQueue,
+			Logger:              logger,
+			Auth:                &auth.JwtAuth{Key: []byte(viper.GetString("chrly.secret"))},
+		}
+
+		if err := cfg.Run(); err != nil {
+			logger.Error(fmt.Sprintf("Error in main(): %v", err))
+		}
+	},
+}
+
+func init() {
+	RootCmd.AddCommand(serveCmd)
+	viper.SetDefault("server.host", "")
+	viper.SetDefault("server.port", 80)
+	viper.SetDefault("storage.redis.host", "localhost")
+	viper.SetDefault("storage.redis.port", 6379)
+	viper.SetDefault("storage.redis.poll", 10)
+	viper.SetDefault("storage.filesystem.basePath", "data")
+	viper.SetDefault("storage.filesystem.capesDirName", "capes")
+	viper.SetDefault("queue.loop_delay", 2_500)
+}
--- a/cmd/token.go
+++ b/cmd/token.go
@@ -0,0 +1,29 @@
+package cmd
+
+import (
+	"fmt"
+	"log"
+
+	"github.com/elyby/chrly/auth"
+
+	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
+)
+
+var tokenCmd = &cobra.Command{
+	Use:   "token",
+	Short: "Creates a new token, which allows to interact with Chrly API",
+	Run: func(cmd *cobra.Command, args []string) {
+		jwtAuth := &auth.JwtAuth{Key: []byte(viper.GetString("chrly.secret"))}
+		token, err := jwtAuth.NewToken(auth.SkinScope)
+		if err != nil {
+			log.Fatalf("Unable to create new token. The error is %v\n", err)
+		}
+
+		fmt.Printf("%s\n", token)
+	},
+}
+
+func init() {
+	RootCmd.AddCommand(tokenCmd)
+}
--- a/cmd/version.go
+++ b/cmd/version.go
@@ -0,0 +1,23 @@
+package cmd
+
+import (
+	"fmt"
+
+	"github.com/spf13/cobra"
+	"github.com/elyby/chrly/bootstrap"
+	"runtime"
+)
+
+var versionCmd = &cobra.Command{
+	Use:   "version",
+	Short: "Show the Chrly version information",
+	Run: func(cmd *cobra.Command, args []string) {
+		fmt.Printf("Version:    %s\n",    bootstrap.GetVersion())
+		fmt.Printf("Go version: %s\n",    runtime.Version())
+		fmt.Printf("OS/Arch:    %s/%s\n", runtime.GOOS, runtime.GOARCH)
+	},
+}
+
+func init() {
+	RootCmd.AddCommand(versionCmd)
+}
--- a/db/commons.go
+++ b/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."
+}
--- a/db/factory.go
+++ b/db/factory.go
@@ -0,0 +1,36 @@
+package db
+
+import (
+	"github.com/spf13/viper"
+
+	"github.com/elyby/chrly/api/mojang/queue"
+	"github.com/elyby/chrly/interfaces"
+)
+
+type StorageFactory struct {
+	Config *viper.Viper
+}
+
+type RepositoriesCreator interface {
+	CreateSkinsRepository() (interfaces.SkinsRepository, error)
+	CreateCapesRepository() (interfaces.CapesRepository, error)
+	CreateMojangUuidsRepository() (queue.UuidsStorage, 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
+}
--- a/db/filesystem.go
+++ b/db/filesystem.go
@@ -0,0 +1,64 @@
+package db
+
+import (
+	"os"
+	"path"
+	"strings"
+
+	"github.com/elyby/chrly/api/mojang/queue"
+	"github.com/elyby/chrly/interfaces"
+	"github.com/elyby/chrly/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) CreateMojangUuidsRepository() (queue.UuidsStorage, error) {
+	panic("implement me")
+}
+
+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
+}
--- a/db/redis.go
+++ b/db/redis.go
@@ -0,0 +1,307 @@
+package db
+
+import (
+	"bytes"
+	"compress/zlib"
+	"encoding/json"
+	"fmt"
+	"io"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/mediocregopher/radix.v2/pool"
+	"github.com/mediocregopher/radix.v2/redis"
+	"github.com/mediocregopher/radix.v2/util"
+
+	"github.com/elyby/chrly/api/mojang/queue"
+	"github.com/elyby/chrly/interfaces"
+	"github.com/elyby/chrly/model"
+)
+
+type RedisFactory struct {
+	Host     string
+	Port     int
+	PoolSize int
+	pool     *pool.Pool
+}
+
+func (f *RedisFactory) CreateSkinsRepository() (interfaces.SkinsRepository, error) {
+	return f.createInstance()
+}
+
+func (f *RedisFactory) CreateCapesRepository() (interfaces.CapesRepository, error) {
+	panic("capes repository not supported for this storage type")
+}
+
+func (f *RedisFactory) CreateMojangUuidsRepository() (queue.UuidsStorage, error) {
+	return f.createInstance()
+}
+
+func (f *RedisFactory) createInstance() (*redisDb, error) {
+	p, err := f.getPool()
+	if err != nil {
+		return nil, err
+	}
+
+	return &redisDb{p}, nil
+}
+
+func (f *RedisFactory) getPool() (*pool.Pool, error) {
+	if f.pool == 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 := pool.New("tcp", addr, f.PoolSize)
+		if err != nil {
+			return nil, err
+		}
+
+		f.pool = conn
+	}
+
+	return f.pool, nil
+}
+
+type redisDb struct {
+	pool *pool.Pool
+}
+
+const accountIdToUsernameKey = "hash:username-to-account-id"
+const mojangUsernameToUuidKey = "hash:mojang-username-to-uuid"
+
+func (db *redisDb) FindByUsername(username string) (*model.Skin, error) {
+	conn, err := db.pool.Get()
+	if err != nil {
+		return nil, err
+	}
+	defer db.pool.Put(conn)
+
+	return findByUsername(username, conn)
+}
+
+func (db *redisDb) FindByUserId(id int) (*model.Skin, error) {
+	conn, err := db.pool.Get()
+	if err != nil {
+		return nil, err
+	}
+	defer db.pool.Put(conn)
+
+	return findByUserId(id, conn)
+}
+
+func (db *redisDb) Save(skin *model.Skin) error {
+	conn, err := db.pool.Get()
+	if err != nil {
+		return err
+	}
+	defer db.pool.Put(conn)
+
+	return save(skin, conn)
+}
+
+func (db *redisDb) RemoveByUserId(id int) error {
+	conn, err := db.pool.Get()
+	if err != nil {
+		return err
+	}
+	defer db.pool.Put(conn)
+
+	return removeByUserId(id, conn)
+}
+
+func (db *redisDb) RemoveByUsername(username string) error {
+	conn, err := db.pool.Get()
+	if err != nil {
+		return err
+	}
+	defer db.pool.Put(conn)
+
+	return removeByUsername(username, conn)
+}
+
+func (db *redisDb) GetUuid(username string) (string, error) {
+	conn, err := db.pool.Get()
+	if err != nil {
+		return "", err
+	}
+	defer db.pool.Put(conn)
+
+	return findMojangUuidByUsername(username, conn)
+}
+
+func (db *redisDb) StoreUuid(username string, uuid string) error {
+	conn, err := db.pool.Get()
+	if err != nil {
+		return err
+	}
+	defer db.pool.Put(conn)
+
+	return storeMojangUuid(username, uuid, conn)
+}
+
+func findByUsername(username string, conn util.Cmder) (*model.Skin, error) {
+	if username == "" {
+		return nil, &SkinNotFoundError{username}
+	}
+
+	redisKey := buildUsernameKey(username)
+	response := conn.Cmd("GET", redisKey)
+	if !response.IsType(redis.Str) {
+		return nil, &SkinNotFoundError{username}
+	}
+
+	encodedResult, err := response.Bytes()
+	if err != nil {
+		return nil, err
+	}
+
+	result, err := zlibDecode(encodedResult)
+	if err != nil {
+		return nil, err
+	}
+
+	var skin *model.Skin
+	err = json.Unmarshal(result, &skin)
+	if err != nil {
+		return nil, err
+	}
+
+	skin.OldUsername = skin.Username
+
+	return skin, nil
+}
+
+func findByUserId(id int, conn util.Cmder) (*model.Skin, error) {
+	response := conn.Cmd("HGET", accountIdToUsernameKey, id)
+	if !response.IsType(redis.Str) {
+		return nil, &SkinNotFoundError{"unknown"}
+	}
+
+	username, _ := response.Str()
+
+	return findByUsername(username, conn)
+}
+
+func removeByUserId(id int, conn util.Cmder) error {
+	record, err := findByUserId(id, conn)
+	if err != nil {
+		if _, ok := err.(*SkinNotFoundError); !ok {
+			return err
+		}
+	}
+
+	conn.Cmd("MULTI")
+
+	conn.Cmd("HDEL", accountIdToUsernameKey, id)
+	if record != nil {
+		conn.Cmd("DEL", buildUsernameKey(record.Username))
+	}
+
+	conn.Cmd("EXEC")
+
+	return nil
+}
+
+func removeByUsername(username string, conn util.Cmder) error {
+	record, err := findByUsername(username, conn)
+	if err != nil {
+		if _, ok := err.(*SkinNotFoundError); ok {
+			return nil
+		}
+
+		return err
+	}
+
+	conn.Cmd("MULTI")
+
+	conn.Cmd("DEL", buildUsernameKey(record.Username))
+	conn.Cmd("HDEL", accountIdToUsernameKey, record.UserId)
+
+	conn.Cmd("EXEC")
+
+	return nil
+}
+
+func save(skin *model.Skin, conn util.Cmder) error {
+	conn.Cmd("MULTI")
+
+	// If user has changed username, then we must delete his old username record
+	if skin.OldUsername != "" && skin.OldUsername != skin.Username {
+		conn.Cmd("DEL", buildUsernameKey(skin.OldUsername))
+	}
+
+	// If this is a new record or if the user has changed username, we set the value in the hash table
+	if skin.OldUsername != "" || skin.OldUsername != skin.Username {
+		conn.Cmd("HSET", accountIdToUsernameKey, skin.UserId, skin.Username)
+	}
+
+	str, _ := json.Marshal(skin)
+	conn.Cmd("SET", buildUsernameKey(skin.Username), zlibEncode(str))
+
+	conn.Cmd("EXEC")
+
+	skin.OldUsername = skin.Username
+
+	return nil
+}
+
+func findMojangUuidByUsername(username string, conn util.Cmder) (string, error) {
+	response := conn.Cmd("HGET", mojangUsernameToUuidKey, strings.ToLower(username))
+	if response.IsType(redis.Nil) {
+		return "", &queue.ValueNotFound{}
+	}
+
+	data, _ := response.Str()
+	parts := strings.Split(data, ":")
+	timestamp, _ := strconv.ParseInt(parts[1], 10, 64)
+	storedAt := time.Unix(timestamp, 0)
+	if storedAt.Add(time.Hour * 24 * 30).Before(time.Now()) {
+		return "", &queue.ValueNotFound{}
+	}
+
+	return parts[0], nil
+}
+
+func storeMojangUuid(username string, uuid string, conn util.Cmder) error {
+	value := uuid + ":" + strconv.FormatInt(time.Now().Unix(), 10)
+	res := conn.Cmd("HSET", mojangUsernameToUuidKey, strings.ToLower(username), value)
+	if res.IsType(redis.Err) {
+		return res.Err
+	}
+
+	return nil
+}
+
+func buildUsernameKey(username string) string {
+	return "username:" + strings.ToLower(username)
+}
+
+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
+}
--- a/docker-compose.base.yml
+++ b/docker-compose.base.yml
@@ -1,13 +0,0 @@
-version: '2'
-services:
-    redis:
-        image: redis:3.0-alpine
-        volumes:
-            - ./data/redis:/data
-
-    rabbitmq:
-        image: rabbitmq:3.6
-        environment:
-            RABBITMQ_DEFAULT_USER: "ely-skinsystem-app"
-            RABBITMQ_DEFAULT_PASS: "ely-skinsystem-app-password"
-            RABBITMQ_DEFAULT_VHOST: "/ely"
--- a/docker-compose.dev.yml
+++ b/docker-compose.dev.yml
@@ -1,23 +1,14 @@
+# This file can be used to start up necessary services.
+# Copy it into the docker-compose.yml:
+# > cp docker-compose.dev.yml docker-compose.yml
+# And then run it:
+# > docker-compose up -d
+
 version: '2'
 services:
-    app:
-        build: .
-        image: registry.ely.by/elyby/skinsystem:latest
-        ports:
-            - "80:80"
-        volumes:
-            - ./:/go/src/app
-        command: ["go", "run", "minecraft-skinsystem.go"]
-        links:
-            - redis
-            - rabbitmq
-
  redis:
-        extends:
-            file: docker-compose.base.yml
-            service: redis
-
-    rabbitmq:
-        extends:
-            file: docker-compose.base.yml
-            service: rabbitmq
+    image: redis:4.0-32bit
+    ports:
+      - "6379:6379"
+    volumes:
+      - ./data/redis:/data
--- a/docker-compose.prod.yml
+++ b/docker-compose.prod.yml
@@ -1,22 +1,27 @@
+# This file can be used to run application in the production environment.
+# Copy it into the docker-compose.yml:
+# > cp docker-compose.prod.yml docker-compose.yml
+# And then run it:
+# > docker-compose up -d
+# Service will be listened at the http://localhost
+
 version: '2'
 services:
  app:
-        image: registry.ely.by/elyby/skinsystem:latest
-        ports:
-            - "80:80"
+    image: elyby/chrly
+    hostname: chrly0
+    restart: always
    links:
      - redis
-            - rabbitmq
-        restart: always
+    volumes:
+      - ./data/capes:/data/capes
+    ports:
+      - "80:80"
+    environment:
+      CHRLY_SECRET: replace_this_value_in_production

  redis:
-        extends:
-            file: docker-compose.base.yml
-            service: redis
-        restart: always
-
-    rabbitmq:
-        extends:
-            file: docker-compose.base.yml
-            service: rabbitmq
+    image: redis:4.0-32bit # 32-bit version is recommended to spare some memory
    restart: always
+    volumes:
+      - ./data/redis:/data
--- a/docker-entrypoint.sh
+++ b/docker-entrypoint.sh
@@ -0,0 +1,12 @@
+#!/bin/sh
+set -e
+
+if [ ! -d /data/capes ]; then
+    mkdir -p /data/capes
+fi
+
+if [ "$1" = "serve" ] || [ "$1" = "token" ] || [ "$1" = "version" ]; then
+    set -- /usr/local/bin/chrly "$@"
+fi
+
+exec "$@"
--- a/http/api.go
+++ b/http/api.go
@@ -0,0 +1,259 @@
+package http
+
+import (
+	"encoding/json"
+	"errors"
+	"fmt"
+	"net/http"
+	"regexp"
+	"strconv"
+
+	"github.com/elyby/chrly/auth"
+	"github.com/elyby/chrly/db"
+	"github.com/elyby/chrly/interfaces"
+	"github.com/elyby/chrly/model"
+
+	"github.com/gorilla/mux"
+	"github.com/mono83/slf/wd"
+	"github.com/thedevsaddam/govalidator"
+)
+
+//noinspection GoSnakeCaseUsage
+const UUID_ANY = "^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$"
+
+var regexUuidAny = regexp.MustCompile(UUID_ANY)
+
+func init() {
+	govalidator.AddCustomRule("skinUploadingNotAvailable", func(field string, rule string, message string, value interface{}) error {
+		if message == "" {
+			message = "Skin uploading is temporary unavailable"
+		}
+
+		return errors.New(message)
+	})
+
+	// Add ability to validate any possible uuid form
+	govalidator.AddCustomRule("uuid_any", func(field string, rule string, message string, value interface{}) error {
+		str := value.(string)
+		if !regexUuidAny.MatchString(str) {
+			if message == "" {
+				message = fmt.Sprintf("The %s field must contain valid UUID", field)
+			}
+
+			return errors.New(message)
+		}
+
+		return nil
+	})
+}
+
+func (cfg *Config) PostSkin(resp http.ResponseWriter, req *http.Request) {
+	cfg.Logger.IncCounter("api.skins.post.request", 1)
+	validationErrors := validatePostSkinRequest(req)
+	if validationErrors != nil {
+		cfg.Logger.IncCounter("api.skins.post.validation_failed", 1)
+		apiBadRequest(resp, validationErrors)
+		return
+	}
+
+	identityId, _ := strconv.Atoi(req.Form.Get("identityId"))
+	username := req.Form.Get("username")
+
+	record, err := findIdentity(cfg.SkinsRepo, identityId, username)
+	if err != nil {
+		cfg.Logger.Error("Error on requesting a skin from the repository: :err", wd.ErrParam(err))
+		apiServerError(resp)
+		return
+	}
+
+	skinId, _ := strconv.Atoi(req.Form.Get("skinId"))
+	is18, _ := strconv.ParseBool(req.Form.Get("is1_8"))
+	isSlim, _ := strconv.ParseBool(req.Form.Get("isSlim"))
+
+	record.Uuid = req.Form.Get("uuid")
+	record.SkinId = skinId
+	record.Is1_8 = is18
+	record.IsSlim = isSlim
+	record.Url = req.Form.Get("url")
+	record.MojangTextures = req.Form.Get("mojangTextures")
+	record.MojangSignature = req.Form.Get("mojangSignature")
+
+	err = cfg.SkinsRepo.Save(record)
+	if err != nil {
+		cfg.Logger.Error("Unable to save record to the repository: :err", wd.ErrParam(err))
+		apiServerError(resp)
+		return
+	}
+
+	cfg.Logger.IncCounter("api.skins.post.success", 1)
+	resp.WriteHeader(http.StatusCreated)
+}
+
+func (cfg *Config) DeleteSkinByUserId(resp http.ResponseWriter, req *http.Request) {
+	cfg.Logger.IncCounter("api.skins.delete.request", 1)
+	id, _ := strconv.Atoi(mux.Vars(req)["id"])
+	skin, err := cfg.SkinsRepo.FindByUserId(id)
+	if err != nil {
+		cfg.Logger.IncCounter("api.skins.delete.not_found", 1)
+		apiNotFound(resp, "Cannot find record for requested user id")
+		return
+	}
+
+	cfg.deleteSkin(skin, resp)
+}
+
+func (cfg *Config) DeleteSkinByUsername(resp http.ResponseWriter, req *http.Request) {
+	cfg.Logger.IncCounter("api.skins.delete.request", 1)
+	username := mux.Vars(req)["username"]
+	skin, err := cfg.SkinsRepo.FindByUsername(username)
+	if err != nil {
+		cfg.Logger.IncCounter("api.skins.delete.not_found", 1)
+		apiNotFound(resp, "Cannot find record for requested username")
+		return
+	}
+
+	cfg.deleteSkin(skin, resp)
+}
+
+func (cfg *Config) AuthenticationMiddleware(handler http.Handler) http.Handler {
+	return http.HandlerFunc(func(resp http.ResponseWriter, req *http.Request) {
+		cfg.Logger.IncCounter("authentication.challenge", 1)
+		err := cfg.Auth.Check(req)
+		if err != nil {
+			if _, ok := err.(*auth.Unauthorized); ok {
+				cfg.Logger.IncCounter("authentication.failed", 1)
+				apiForbidden(resp, err.Error())
+			} else {
+				cfg.Logger.Error("Unknown error on validating api request: :err", wd.ErrParam(err))
+				apiServerError(resp)
+			}
+
+			return
+		}
+
+		cfg.Logger.IncCounter("authentication.success", 1)
+		handler.ServeHTTP(resp, req)
+	})
+}
+
+func (cfg *Config) deleteSkin(skin *model.Skin, resp http.ResponseWriter) {
+	err := cfg.SkinsRepo.RemoveByUserId(skin.UserId)
+	if err != nil {
+		cfg.Logger.Error("Cannot delete skin by error: :err", wd.ErrParam(err))
+		apiServerError(resp)
+		return
+	}
+
+	cfg.Logger.IncCounter("api.skins.delete.success", 1)
+	resp.WriteHeader(http.StatusNoContent)
+}
+
+func validatePostSkinRequest(request *http.Request) map[string][]string {
+	const maxMultipartMemory int64 = 32 << 20
+	const oneOfSkinOrUrlMessage = "One of url or skin should be provided, but not both"
+
+	_ = request.ParseMultipartForm(maxMultipartMemory)
+
+	validationRules := govalidator.MapData{
+		"identityId": {"required", "numeric", "min:1"},
+		"username":   {"required"},
+		"uuid":       {"required", "uuid_any"},
+		"skinId":     {"required", "numeric", "min:1"},
+		"url":        {"url"},
+		"file:skin":  {"ext:png", "size:24576", "mime:image/png"},
+		"is1_8":      {"bool"},
+		"isSlim":     {"bool"},
+	}
+
+	shouldAppendSkinRequiredError := false
+	url := request.Form.Get("url")
+	_, _, skinErr := request.FormFile("skin")
+	if (url != "" && skinErr == nil) || (url == "" && skinErr != nil) {
+		shouldAppendSkinRequiredError = true
+	} else if skinErr == nil {
+		validationRules["file:skin"] = append(validationRules["file:skin"], "skinUploadingNotAvailable")
+	} else if url != "" {
+		validationRules["is1_8"] = append(validationRules["is1_8"], "required")
+		validationRules["isSlim"] = append(validationRules["isSlim"], "required")
+	}
+
+	mojangTextures := request.Form.Get("mojangTextures")
+	if mojangTextures != "" {
+		validationRules["mojangSignature"] = []string{"required"}
+	}
+
+	validator := govalidator.New(govalidator.Options{
+		Request:         request,
+		Rules:           validationRules,
+		RequiredDefault: false,
+		FormSize:        maxMultipartMemory,
+	})
+	validationResults := validator.Validate()
+	if shouldAppendSkinRequiredError {
+		validationResults["url"] = append(validationResults["url"], oneOfSkinOrUrlMessage)
+		validationResults["skin"] = append(validationResults["skin"], oneOfSkinOrUrlMessage)
+	}
+
+	if len(validationResults) != 0 {
+		return validationResults
+	}
+
+	return nil
+}
+
+func findIdentity(repo interfaces.SkinsRepository, identityId int, username string) (*model.Skin, error) {
+	var record *model.Skin
+	record, err := repo.FindByUserId(identityId)
+	if err != nil {
+		if _, isSkinNotFound := err.(*db.SkinNotFoundError); !isSkinNotFound {
+			return nil, err
+		}
+
+		record, err = repo.FindByUsername(username)
+		if err == nil {
+			_ = repo.RemoveByUsername(username)
+			record.UserId = identityId
+		} else {
+			record = &model.Skin{
+				UserId:   identityId,
+				Username: username,
+			}
+		}
+	} else if record.Username != username {
+		_ = repo.RemoveByUserId(identityId)
+		record.Username = username
+	}
+
+	return record, nil
+}
+
+func apiBadRequest(resp http.ResponseWriter, errorsPerField map[string][]string) {
+	resp.WriteHeader(http.StatusBadRequest)
+	resp.Header().Set("Content-Type", "application/json")
+	result, _ := json.Marshal(map[string]interface{}{
+		"errors": errorsPerField,
+	})
+	_, _ = resp.Write(result)
+}
+
+func apiForbidden(resp http.ResponseWriter, reason string) {
+	resp.WriteHeader(http.StatusForbidden)
+	resp.Header().Set("Content-Type", "application/json")
+	result, _ := json.Marshal(map[string]interface{}{
+		"error": reason,
+	})
+	_, _ = resp.Write(result)
+}
+
+func apiNotFound(resp http.ResponseWriter, reason string) {
+	resp.WriteHeader(http.StatusNotFound)
+	resp.Header().Set("Content-Type", "application/json")
+	result, _ := json.Marshal([]interface{}{
+		reason,
+	})
+	_, _ = resp.Write(result)
+}
+
+func apiServerError(resp http.ResponseWriter) {
+	resp.WriteHeader(http.StatusInternalServerError)
+}
--- a/http/api_test.go
+++ b/http/api_test.go
@@ -0,0 +1,501 @@
+package http
+
+import (
+	"bytes"
+	"encoding/base64"
+	"io/ioutil"
+	"mime/multipart"
+	"net/http"
+	"net/http/httptest"
+	"net/url"
+	"testing"
+
+	"github.com/elyby/chrly/auth"
+	"github.com/elyby/chrly/db"
+
+	"github.com/golang/mock/gomock"
+	testify "github.com/stretchr/testify/assert"
+)
+
+func TestConfig_PostSkin(t *testing.T) {
+	t.Run("Upload new identity with textures info", func(t *testing.T) {
+		assert := testify.New(t)
+
+		ctrl := gomock.NewController(t)
+		defer ctrl.Finish()
+
+		config, mocks := setupMocks(ctrl)
+
+		resultModel := createSkinModel("mock_user", false)
+		resultModel.SkinId = 5
+		resultModel.Url = "http://example.com/skin.png"
+		resultModel.MojangTextures = ""
+		resultModel.MojangSignature = ""
+
+		form := url.Values{
+			"identityId": {"1"},
+			"username":   {"mock_user"},
+			"uuid":       {"0f657aa8-bfbe-415d-b700-5750090d3af3"},
+			"skinId":     {"5"},
+			"is1_8":      {"0"},
+			"isSlim":     {"0"},
+			"url":        {"http://example.com/skin.png"},
+		}
+
+		req := httptest.NewRequest("POST", "http://chrly/api/skins", bytes.NewBufferString(form.Encode()))
+		req.Header.Add("Content-Type", "application/x-www-form-urlencoded")
+		w := httptest.NewRecorder()
+
+		mocks.Auth.EXPECT().Check(gomock.Any()).Return(nil)
+		mocks.Skins.EXPECT().FindByUserId(1).Return(nil, &db.SkinNotFoundError{Who: "unknown"})
+		mocks.Skins.EXPECT().FindByUsername("mock_user").Return(nil, &db.SkinNotFoundError{Who: "mock_user"})
+		mocks.Skins.EXPECT().Save(resultModel).Return(nil)
+		mocks.Log.EXPECT().IncCounter("authentication.challenge", int64(1))
+		mocks.Log.EXPECT().IncCounter("authentication.success", int64(1))
+		mocks.Log.EXPECT().IncCounter("api.skins.post.request", int64(1))
+		mocks.Log.EXPECT().IncCounter("api.skins.post.success", int64(1))
+
+		config.CreateHandler().ServeHTTP(w, req)
+
+		resp := w.Result()
+		defer resp.Body.Close()
+		assert.Equal(201, resp.StatusCode)
+		response, _ := ioutil.ReadAll(resp.Body)
+		assert.Empty(response)
+	})
+
+	t.Run("Upload new identity with skin file", func(t *testing.T) {
+		assert := testify.New(t)
+
+		ctrl := gomock.NewController(t)
+		defer ctrl.Finish()
+
+		config, mocks := setupMocks(ctrl)
+
+		body := &bytes.Buffer{}
+		writer := multipart.NewWriter(body)
+
+		part, _ := writer.CreateFormFile("skin", "char.png")
+		_, _ = part.Write(loadSkinFile())
+
+		_ = writer.WriteField("identityId", "1")
+		_ = writer.WriteField("username", "mock_user")
+		_ = writer.WriteField("uuid", "0f657aa8-bfbe-415d-b700-5750090d3af3")
+		_ = writer.WriteField("skinId", "5")
+
+		err := writer.Close()
+		if err != nil {
+			panic(err)
+		}
+
+		req := httptest.NewRequest("POST", "http://chrly/api/skins", body)
+		req.Header.Add("Content-Type", writer.FormDataContentType())
+		w := httptest.NewRecorder()
+
+		mocks.Auth.EXPECT().Check(gomock.Any()).Return(nil)
+		mocks.Log.EXPECT().IncCounter("authentication.challenge", int64(1))
+		mocks.Log.EXPECT().IncCounter("authentication.success", int64(1))
+		mocks.Log.EXPECT().IncCounter("api.skins.post.request", int64(1))
+		mocks.Log.EXPECT().IncCounter("api.skins.post.validation_failed", int64(1))
+
+		config.CreateHandler().ServeHTTP(w, req)
+
+		resp := w.Result()
+		defer resp.Body.Close()
+		assert.Equal(400, resp.StatusCode)
+		response, _ := ioutil.ReadAll(resp.Body)
+		assert.JSONEq(`{
+			"errors": {
+				"skin": [
+					"Skin uploading is temporary unavailable"
+				]
+			}
+		}`, string(response))
+	})
+
+	t.Run("Keep the same identityId, uuid and username, but change textures information", func(t *testing.T) {
+		assert := testify.New(t)
+
+		ctrl := gomock.NewController(t)
+		defer ctrl.Finish()
+
+		config, mocks := setupMocks(ctrl)
+
+		resultModel := createSkinModel("mock_user", false)
+		resultModel.SkinId = 5
+		resultModel.Url = "http://textures-server.com/skin.png"
+		resultModel.MojangTextures = ""
+		resultModel.MojangSignature = ""
+
+		mocks.Auth.EXPECT().Check(gomock.Any()).Return(nil)
+		mocks.Skins.EXPECT().FindByUserId(1).Return(createSkinModel("mock_user", false), nil)
+		mocks.Skins.EXPECT().Save(resultModel).Return(nil)
+		mocks.Log.EXPECT().IncCounter("authentication.challenge", int64(1))
+		mocks.Log.EXPECT().IncCounter("authentication.success", int64(1))
+		mocks.Log.EXPECT().IncCounter("api.skins.post.request", int64(1))
+		mocks.Log.EXPECT().IncCounter("api.skins.post.success", int64(1))
+
+		form := url.Values{
+			"identityId": {"1"},
+			"username":   {"mock_user"},
+			"uuid":       {"0f657aa8-bfbe-415d-b700-5750090d3af3"},
+			"skinId":     {"5"},
+			"is1_8":      {"0"},
+			"isSlim":     {"0"},
+			"url":        {"http://textures-server.com/skin.png"},
+		}
+
+		req := httptest.NewRequest("POST", "http://chrly/api/skins", bytes.NewBufferString(form.Encode()))
+		req.Header.Add("Content-Type", "application/x-www-form-urlencoded")
+		w := httptest.NewRecorder()
+
+		config.CreateHandler().ServeHTTP(w, req)
+
+		resp := w.Result()
+		defer resp.Body.Close()
+		assert.Equal(201, resp.StatusCode)
+		response, _ := ioutil.ReadAll(resp.Body)
+		assert.Empty(response)
+	})
+
+	t.Run("Keep the same uuid and username, but change identityId", func(t *testing.T) {
+		assert := testify.New(t)
+
+		ctrl := gomock.NewController(t)
+		defer ctrl.Finish()
+
+		config, mocks := setupMocks(ctrl)
+
+		resultModel := createSkinModel("mock_user", false)
+		resultModel.UserId = 2
+		resultModel.SkinId = 5
+		resultModel.Url = "http://example.com/skin.png"
+		resultModel.MojangTextures = ""
+		resultModel.MojangSignature = ""
+
+		form := url.Values{
+			"identityId": {"2"},
+			"username":   {"mock_user"},
+			"uuid":       {"0f657aa8-bfbe-415d-b700-5750090d3af3"},
+			"skinId":     {"5"},
+			"is1_8":      {"0"},
+			"isSlim":     {"0"},
+			"url":        {"http://example.com/skin.png"},
+		}
+
+		req := httptest.NewRequest("POST", "http://chrly/api/skins", bytes.NewBufferString(form.Encode()))
+		req.Header.Add("Content-Type", "application/x-www-form-urlencoded")
+		w := httptest.NewRecorder()
+
+		mocks.Auth.EXPECT().Check(gomock.Any()).Return(nil)
+		mocks.Skins.EXPECT().FindByUserId(2).Return(nil, &db.SkinNotFoundError{Who: "unknown"})
+		mocks.Skins.EXPECT().FindByUsername("mock_user").Return(createSkinModel("mock_user", false), nil)
+		mocks.Skins.EXPECT().RemoveByUsername("mock_user").Return(nil)
+		mocks.Skins.EXPECT().Save(resultModel).Return(nil)
+		mocks.Log.EXPECT().IncCounter("authentication.challenge", int64(1))
+		mocks.Log.EXPECT().IncCounter("authentication.success", int64(1))
+		mocks.Log.EXPECT().IncCounter("api.skins.post.request", int64(1))
+		mocks.Log.EXPECT().IncCounter("api.skins.post.success", int64(1))
+
+		config.CreateHandler().ServeHTTP(w, req)
+
+		resp := w.Result()
+		defer resp.Body.Close()
+		assert.Equal(201, resp.StatusCode)
+		response, _ := ioutil.ReadAll(resp.Body)
+		assert.Empty(response)
+	})
+
+	t.Run("Keep the same identityId and uuid, but change username", func(t *testing.T) {
+		assert := testify.New(t)
+
+		ctrl := gomock.NewController(t)
+		defer ctrl.Finish()
+
+		config, mocks := setupMocks(ctrl)
+
+		resultModel := createSkinModel("changed_username", false)
+		resultModel.SkinId = 5
+		resultModel.Url = "http://example.com/skin.png"
+		resultModel.MojangTextures = ""
+		resultModel.MojangSignature = ""
+
+		form := url.Values{
+			"identityId": {"1"},
+			"username":   {"changed_username"},
+			"uuid":       {"0f657aa8-bfbe-415d-b700-5750090d3af3"},
+			"skinId":     {"5"},
+			"is1_8":      {"0"},
+			"isSlim":     {"0"},
+			"url":        {"http://example.com/skin.png"},
+		}
+
+		req := httptest.NewRequest("POST", "http://chrly/api/skins", bytes.NewBufferString(form.Encode()))
+		req.Header.Add("Content-Type", "application/x-www-form-urlencoded")
+		w := httptest.NewRecorder()
+
+		mocks.Auth.EXPECT().Check(gomock.Any()).Return(nil)
+		mocks.Skins.EXPECT().FindByUserId(1).Return(createSkinModel("mock_user", false), nil)
+		mocks.Skins.EXPECT().RemoveByUserId(1).Return(nil)
+		mocks.Skins.EXPECT().Save(resultModel).Return(nil)
+		mocks.Log.EXPECT().IncCounter("authentication.challenge", int64(1))
+		mocks.Log.EXPECT().IncCounter("authentication.success", int64(1))
+		mocks.Log.EXPECT().IncCounter("api.skins.post.request", int64(1))
+		mocks.Log.EXPECT().IncCounter("api.skins.post.success", int64(1))
+
+		config.CreateHandler().ServeHTTP(w, req)
+
+		resp := w.Result()
+		defer resp.Body.Close()
+		assert.Equal(201, resp.StatusCode)
+		response, _ := ioutil.ReadAll(resp.Body)
+		assert.Empty(response)
+	})
+
+	t.Run("Get errors about required fields", func(t *testing.T) {
+		assert := testify.New(t)
+
+		ctrl := gomock.NewController(t)
+		defer ctrl.Finish()
+
+		config, mocks := setupMocks(ctrl)
+
+		form := url.Values{
+			"mojangTextures": {"someBase64EncodedString"},
+		}
+
+		req := httptest.NewRequest("POST", "http://chrly/api/skins", bytes.NewBufferString(form.Encode()))
+		req.Header.Add("Content-Type", "application/x-www-form-urlencoded")
+		w := httptest.NewRecorder()
+
+		mocks.Auth.EXPECT().Check(gomock.Any()).Return(nil)
+		mocks.Log.EXPECT().IncCounter("authentication.challenge", int64(1))
+		mocks.Log.EXPECT().IncCounter("authentication.success", int64(1))
+		mocks.Log.EXPECT().IncCounter("api.skins.post.request", int64(1))
+		mocks.Log.EXPECT().IncCounter("api.skins.post.validation_failed", int64(1))
+
+		config.CreateHandler().ServeHTTP(w, req)
+
+		resp := w.Result()
+		defer resp.Body.Close()
+		assert.Equal(400, resp.StatusCode)
+		response, _ := ioutil.ReadAll(resp.Body)
+		assert.JSONEq(`{
+			"errors": {
+				"identityId": [
+					"The identityId field is required",
+					"The identityId field must be numeric",
+					"The identityId field must be minimum 1 char"
+				],
+				"skinId": [
+					"The skinId field is required",
+					"The skinId field must be numeric",
+					"The skinId field must be minimum 1 char"
+				],
+				"username": [
+					"The username field is required"
+				],
+				"uuid": [
+					"The uuid field is required",
+					"The uuid field must contain valid UUID"
+				],
+				"url": [
+					"One of url or skin should be provided, but not both"
+				],
+				"skin": [
+					"One of url or skin should be provided, but not both"
+				],
+				"mojangSignature": [
+					"The mojangSignature field is required"
+				]
+			}
+		}`, string(response))
+	})
+
+	t.Run("Perform request without authorization", func(t *testing.T) {
+		assert := testify.New(t)
+
+		ctrl := gomock.NewController(t)
+		defer ctrl.Finish()
+
+		config, mocks := setupMocks(ctrl)
+
+		req := httptest.NewRequest("POST", "http://chrly/api/skins", nil)
+		req.Header.Add("Authorization", "Bearer invalid.jwt.token")
+		w := httptest.NewRecorder()
+
+		mocks.Auth.EXPECT().Check(gomock.Any()).Return(&auth.Unauthorized{Reason: "Cannot parse passed JWT token"})
+		mocks.Log.EXPECT().IncCounter("authentication.challenge", int64(1))
+		mocks.Log.EXPECT().IncCounter("authentication.failed", int64(1))
+
+		config.CreateHandler().ServeHTTP(w, req)
+
+		resp := w.Result()
+		defer resp.Body.Close()
+		assert.Equal(403, resp.StatusCode)
+		response, _ := ioutil.ReadAll(resp.Body)
+		assert.JSONEq(`{
+			"error": "Cannot parse passed JWT token"
+		}`, string(response))
+	})
+}
+
+func TestConfig_DeleteSkinByUserId(t *testing.T) {
+	t.Run("Delete skin by its identity id", func(t *testing.T) {
+		assert := testify.New(t)
+
+		ctrl := gomock.NewController(t)
+		defer ctrl.Finish()
+
+		config, mocks := setupMocks(ctrl)
+
+		req := httptest.NewRequest("DELETE", "http://chrly/api/skins/id:1", nil)
+		w := httptest.NewRecorder()
+
+		mocks.Auth.EXPECT().Check(gomock.Any()).Return(nil)
+		mocks.Skins.EXPECT().FindByUserId(1).Return(createSkinModel("mock_user", false), nil)
+		mocks.Skins.EXPECT().RemoveByUserId(1).Return(nil)
+		mocks.Log.EXPECT().IncCounter("authentication.challenge", int64(1))
+		mocks.Log.EXPECT().IncCounter("authentication.success", int64(1))
+		mocks.Log.EXPECT().IncCounter("api.skins.delete.request", int64(1))
+		mocks.Log.EXPECT().IncCounter("api.skins.delete.success", int64(1))
+
+		config.CreateHandler().ServeHTTP(w, req)
+
+		resp := w.Result()
+		defer resp.Body.Close()
+		assert.Equal(204, resp.StatusCode)
+		response, _ := ioutil.ReadAll(resp.Body)
+		assert.Empty(response)
+	})
+
+	t.Run("Try to remove not exists identity id", func(t *testing.T) {
+		assert := testify.New(t)
+
+		ctrl := gomock.NewController(t)
+		defer ctrl.Finish()
+
+		config, mocks := setupMocks(ctrl)
+
+		req := httptest.NewRequest("DELETE", "http://chrly/api/skins/id:2", nil)
+		w := httptest.NewRecorder()
+
+		mocks.Auth.EXPECT().Check(gomock.Any()).Return(nil)
+		mocks.Skins.EXPECT().FindByUserId(2).Return(nil, &db.SkinNotFoundError{Who: "unknown"})
+		mocks.Log.EXPECT().IncCounter("authentication.challenge", int64(1))
+		mocks.Log.EXPECT().IncCounter("authentication.success", int64(1))
+		mocks.Log.EXPECT().IncCounter("api.skins.delete.request", int64(1))
+		mocks.Log.EXPECT().IncCounter("api.skins.delete.not_found", int64(1))
+
+		config.CreateHandler().ServeHTTP(w, req)
+
+		resp := w.Result()
+		defer resp.Body.Close()
+		assert.Equal(404, resp.StatusCode)
+		response, _ := ioutil.ReadAll(resp.Body)
+		assert.JSONEq(`[
+			"Cannot find record for requested user id"
+		]`, string(response))
+	})
+}
+
+func TestConfig_DeleteSkinByUsername(t *testing.T) {
+	t.Run("Delete skin by its identity username", func(t *testing.T) {
+		assert := testify.New(t)
+
+		ctrl := gomock.NewController(t)
+		defer ctrl.Finish()
+
+		config, mocks := setupMocks(ctrl)
+
+		req := httptest.NewRequest("DELETE", "http://chrly/api/skins/mock_user", nil)
+		w := httptest.NewRecorder()
+
+		mocks.Auth.EXPECT().Check(gomock.Any()).Return(nil)
+		mocks.Skins.EXPECT().FindByUsername("mock_user").Return(createSkinModel("mock_user", false), nil)
+		mocks.Skins.EXPECT().RemoveByUserId(1).Return(nil)
+		mocks.Log.EXPECT().IncCounter("authentication.challenge", int64(1))
+		mocks.Log.EXPECT().IncCounter("authentication.success", int64(1))
+		mocks.Log.EXPECT().IncCounter("api.skins.delete.request", int64(1))
+		mocks.Log.EXPECT().IncCounter("api.skins.delete.success", int64(1))
+
+		config.CreateHandler().ServeHTTP(w, req)
+
+		resp := w.Result()
+		defer resp.Body.Close()
+		assert.Equal(204, resp.StatusCode)
+		response, _ := ioutil.ReadAll(resp.Body)
+		assert.Empty(response)
+	})
+
+	t.Run("Try to remove not exists identity username", func(t *testing.T) {
+		assert := testify.New(t)
+
+		ctrl := gomock.NewController(t)
+		defer ctrl.Finish()
+
+		config, mocks := setupMocks(ctrl)
+
+		req := httptest.NewRequest("DELETE", "http://chrly/api/skins/mock_user_2", nil)
+		w := httptest.NewRecorder()
+
+		mocks.Auth.EXPECT().Check(gomock.Any()).Return(nil)
+		mocks.Skins.EXPECT().FindByUsername("mock_user_2").Return(nil, &db.SkinNotFoundError{Who: "mock_user_2"})
+		mocks.Log.EXPECT().IncCounter("authentication.challenge", int64(1))
+		mocks.Log.EXPECT().IncCounter("authentication.success", int64(1))
+		mocks.Log.EXPECT().IncCounter("api.skins.delete.request", int64(1))
+		mocks.Log.EXPECT().IncCounter("api.skins.delete.not_found", int64(1))
+
+		config.CreateHandler().ServeHTTP(w, req)
+
+		resp := w.Result()
+		defer resp.Body.Close()
+		assert.Equal(404, resp.StatusCode)
+		response, _ := ioutil.ReadAll(resp.Body)
+		assert.JSONEq(`[
+		"Cannot find record for requested username"
+	]`, string(response))
+	})
+}
+
+func TestConfig_Authenticate(t *testing.T) {
+	t.Run("Test behavior when signing key is not set", func(t *testing.T) {
+		assert := testify.New(t)
+
+		ctrl := gomock.NewController(t)
+		defer ctrl.Finish()
+
+		config, mocks := setupMocks(ctrl)
+
+		req := httptest.NewRequest("POST", "http://localhost", nil)
+		w := httptest.NewRecorder()
+
+		mocks.Auth.EXPECT().Check(gomock.Any()).Return(&auth.Unauthorized{Reason: "signing key not available"})
+		mocks.Log.EXPECT().IncCounter("authentication.challenge", int64(1))
+		mocks.Log.EXPECT().IncCounter("authentication.failed", int64(1))
+
+		res := config.AuthenticationMiddleware(http.HandlerFunc(func(resp http.ResponseWriter, req *http.Request) {}))
+		res.ServeHTTP(w, req)
+
+		resp := w.Result()
+		defer resp.Body.Close()
+		assert.Equal(403, resp.StatusCode)
+		response, _ := ioutil.ReadAll(resp.Body)
+		assert.JSONEq(`{
+			"error": "signing key not available"
+		}`, string(response))
+	})
+}
+
+// base64 https://github.com/mathiasbynens/small/blob/0ca3c51/png-transparent.png
+var OnePxPng = []byte("iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAACklEQVR4nGMAAQAABQABDQottAAAAABJRU5ErkJggg==")
+
+func loadSkinFile() []byte {
+	result := make([]byte, 92)
+	_, err := base64.StdEncoding.Decode(result, OnePxPng)
+	if err != nil {
+		panic(err)
+	}
+
+	return result
+}
--- a/http/cape.go
+++ b/http/cape.go
@@ -0,0 +1,51 @@
+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 {
+		request.Header.Set("Content-Type", "image/png")
+		_, _ = io.Copy(response, rec.File)
+		return
+	}
+
+	mojangTextures := <-cfg.MojangTexturesQueue.GetTexturesForUsername(username)
+	if mojangTextures == nil {
+		response.WriteHeader(http.StatusNotFound)
+		return
+	}
+
+	texturesProp := mojangTextures.DecodeTextures()
+	cape := texturesProp.Textures.Cape
+	if cape == nil {
+		response.WriteHeader(http.StatusNotFound)
+		return
+	}
+
+	http.Redirect(response, request, cape.Url, 301)
+}
+
+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)
+}
--- a/http/cape_test.go
+++ b/http/cape_test.go
@@ -0,0 +1,163 @@
+package http
+
+import (
+	"bytes"
+	"image"
+	"image/png"
+	"io/ioutil"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	"github.com/golang/mock/gomock"
+	testify "github.com/stretchr/testify/assert"
+
+	"github.com/elyby/chrly/db"
+	"github.com/elyby/chrly/model"
+)
+
+type capesTestCase struct {
+	Name                 string
+	RequestUrl           string
+	ExpectedLogKey       string
+	ExistsInLocalStorage bool
+	ExistsInMojang       bool
+	HasCapeInMojangResp  bool
+	AssertResponse       func(assert *testify.Assertions, resp *http.Response)
+}
+
+var capesTestCases = []*capesTestCase{
+	{
+		Name: "Obtain cape for known username",
+		ExistsInLocalStorage: true,
+		AssertResponse: func(assert *testify.Assertions, resp *http.Response) {
+			assert.Equal(200, resp.StatusCode)
+			responseData, _ := ioutil.ReadAll(resp.Body)
+			assert.Equal(createCape(), responseData)
+			assert.Equal("image/png", resp.Header.Get("Content-Type"))
+		},
+	},
+	{
+		Name: "Obtain cape for unknown username that exists in Mojang and has a cape",
+		ExistsInLocalStorage: false,
+		ExistsInMojang: true,
+		HasCapeInMojangResp: true,
+		AssertResponse: func(assert *testify.Assertions, resp *http.Response) {
+			assert.Equal(301, resp.StatusCode)
+			assert.Equal("http://mojang/cape.png", resp.Header.Get("Location"))
+		},
+	},
+	{
+		Name: "Obtain cape for unknown username that exists in Mojang, but don't has a cape",
+		ExistsInLocalStorage: false,
+		ExistsInMojang: true,
+		HasCapeInMojangResp: false,
+		AssertResponse: func(assert *testify.Assertions, resp *http.Response) {
+			assert.Equal(404, resp.StatusCode)
+		},
+	},
+	{
+		Name: "Obtain cape for unknown username that doesn't exists in Mojang",
+		ExistsInLocalStorage: false,
+		ExistsInMojang: false,
+		AssertResponse: func(assert *testify.Assertions, resp *http.Response) {
+			assert.Equal(404, resp.StatusCode)
+		},
+	},
+}
+
+func TestConfig_Cape(t *testing.T) {
+	performTest := func(t *testing.T, testCase *capesTestCase) {
+		assert := testify.New(t)
+
+		ctrl := gomock.NewController(t)
+		defer ctrl.Finish()
+
+		config, mocks := setupMocks(ctrl)
+
+		mocks.Log.EXPECT().IncCounter(testCase.ExpectedLogKey, int64(1))
+		if testCase.ExistsInLocalStorage {
+			mocks.Capes.EXPECT().FindByUsername("mock_username").Return(&model.Cape{
+				File: bytes.NewReader(createCape()),
+			}, nil)
+		} else {
+			mocks.Capes.EXPECT().FindByUsername("mock_username").Return(nil, &db.CapeNotFoundError{Who: "mock_username"})
+		}
+
+		if testCase.ExistsInMojang {
+			textures := createTexturesResponse(false, testCase.HasCapeInMojangResp)
+			mocks.Queue.On("GetTexturesForUsername", "mock_username").Return(textures)
+		} else {
+			mocks.Queue.On("GetTexturesForUsername", "mock_username").Return(nil)
+		}
+
+		req := httptest.NewRequest("GET", testCase.RequestUrl, nil)
+		w := httptest.NewRecorder()
+
+		config.CreateHandler().ServeHTTP(w, req)
+
+		resp := w.Result()
+		testCase.AssertResponse(assert, resp)
+	}
+
+	t.Run("Normal API", func(t *testing.T) {
+		for _, testCase := range capesTestCases {
+			testCase.RequestUrl = "http://chrly/cloaks/mock_username"
+			testCase.ExpectedLogKey = "capes.request"
+			t.Run(testCase.Name, func(t *testing.T) {
+				performTest(t, testCase)
+			})
+		}
+	})
+
+	t.Run("GET fallback API", func(t *testing.T) {
+		for _, testCase := range capesTestCases {
+			testCase.RequestUrl = "http://chrly/cloaks?name=mock_username"
+			testCase.ExpectedLogKey = "capes.get_request"
+			t.Run(testCase.Name, func(t *testing.T) {
+				performTest(t, testCase)
+			})
+		}
+
+		t.Run("Should trim trailing slash", func(t *testing.T) {
+			assert := testify.New(t)
+
+			req := httptest.NewRequest("GET", "http://chrly/cloaks/?name=notch", nil)
+			w := httptest.NewRecorder()
+
+			(&Config{}).CreateHandler().ServeHTTP(w, req)
+
+			resp := w.Result()
+			assert.Equal(301, resp.StatusCode)
+			assert.Equal("http://chrly/cloaks?name=notch", resp.Header.Get("Location"))
+		})
+
+		t.Run("Return error when name is not provided", func(t *testing.T) {
+			assert := testify.New(t)
+
+			ctrl := gomock.NewController(t)
+			defer ctrl.Finish()
+
+			config, mocks := setupMocks(ctrl)
+			mocks.Log.EXPECT().IncCounter("capes.get_request", int64(1))
+
+			req := httptest.NewRequest("GET", "http://chrly/cloaks", nil)
+			w := httptest.NewRecorder()
+
+			config.CreateHandler().ServeHTTP(w, req)
+
+			resp := w.Result()
+			assert.Equal(400, resp.StatusCode)
+		})
+	})
+}
+
+// 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
+}
--- a/http/http.go
+++ b/http/http.go
@@ -0,0 +1,88 @@
+package http
+
+import (
+	"fmt"
+	"net"
+	"net/http"
+	"os"
+	"os/signal"
+	"strings"
+	"syscall"
+	"time"
+
+	"github.com/gorilla/mux"
+	"github.com/mono83/slf/wd"
+
+	"github.com/elyby/chrly/interfaces"
+)
+
+type Config struct {
+	ListenSpec string
+
+	SkinsRepo           interfaces.SkinsRepository
+	CapesRepo           interfaces.CapesRepository
+	MojangTexturesQueue interfaces.MojangTexturesQueue
+	Logger              wd.Watchdog
+	Auth                interfaces.AuthChecker
+}
+
+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")
+	// Legacy
+	router.HandleFunc("/skins", cfg.SkinGET).Methods("GET")
+	router.HandleFunc("/cloaks", cfg.CapeGET).Methods("GET")
+	// API
+	apiRouter := router.PathPrefix("/api").Subrouter()
+	apiRouter.Use(cfg.AuthenticationMiddleware)
+	apiRouter.Handle("/skins", http.HandlerFunc(cfg.PostSkin)).Methods("POST")
+	apiRouter.Handle("/skins/id:{id:[0-9]+}", http.HandlerFunc(cfg.DeleteSkinByUserId)).Methods("DELETE")
+	apiRouter.Handle("/skins/{username}", http.HandlerFunc(cfg.DeleteSkinByUsername)).Methods("DELETE")
+	// 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 waitForSignal() os.Signal {
+	ch := make(chan os.Signal)
+	signal.Notify(ch, syscall.SIGINT, syscall.SIGTERM)
+
+	return <-ch
+}
--- a/http/http_test.go
+++ b/http/http_test.go
@@ -0,0 +1,89 @@
+package http
+
+import (
+	"testing"
+	"time"
+
+	"github.com/elyby/chrly/api/mojang"
+
+	"github.com/elyby/chrly/tests"
+	"github.com/golang/mock/gomock"
+	testify "github.com/stretchr/testify/assert"
+
+	"github.com/elyby/chrly/interfaces/mock_interfaces"
+	"github.com/elyby/chrly/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")
+}
+
+type mocks struct {
+	Skins *mock_interfaces.MockSkinsRepository
+	Capes *mock_interfaces.MockCapesRepository
+	Queue *tests.MojangTexturesQueueMock
+	Auth  *mock_interfaces.MockAuthChecker
+	Log   *mock_wd.MockWatchdog
+}
+
+func setupMocks(ctrl *gomock.Controller) (
+	*Config,
+	*mocks,
+) {
+	skinsRepo := mock_interfaces.NewMockSkinsRepository(ctrl)
+	capesRepo := mock_interfaces.NewMockCapesRepository(ctrl)
+	authChecker := mock_interfaces.NewMockAuthChecker(ctrl)
+	wd := mock_wd.NewMockWatchdog(ctrl)
+	texturesQueue := &tests.MojangTexturesQueueMock{}
+
+	return &Config{
+		SkinsRepo:           skinsRepo,
+		CapesRepo:           capesRepo,
+		Auth:                authChecker,
+		MojangTexturesQueue: texturesQueue,
+		Logger:              wd,
+	}, &mocks{
+		Skins: skinsRepo,
+		Capes: capesRepo,
+		Auth:  authChecker,
+		Queue: texturesQueue,
+		Log:   wd,
+	}
+}
+
+func createTexturesResponse(includeSkin bool, includeCape bool) *mojang.SignedTexturesResponse {
+	timeZone, _ := time.LoadLocation("Europe/Minsk")
+	textures := &mojang.TexturesProp{
+		Timestamp: time.Date(2019, 4, 27, 23, 56, 12, 0, timeZone).Unix(),
+		ProfileID: "00000000000000000000000000000000",
+		ProfileName: "mock_user",
+		Textures: &mojang.TexturesResponse{},
+	}
+
+	if includeSkin {
+		textures.Textures.Skin = &mojang.SkinTexturesResponse{
+			Url: "http://mojang/skin.png",
+		}
+	}
+
+	if includeCape {
+		textures.Textures.Cape = &mojang.CapeTexturesResponse{
+			Url: "http://mojang/cape.png",
+		}
+	}
+
+	response := &mojang.SignedTexturesResponse{
+		Id: "00000000000000000000000000000000",
+		Name: "mock_user",
+		Props: []*mojang.Property{
+			{
+				Name: "textures",
+				Value: mojang.EncodeTextures(textures),
+			},
+		},
+	}
+
+	return response
+}
--- a/http/not_found.go
+++ b/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)
+}
--- a/http/not_found_test.go
+++ b/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))
+}
--- a/http/signed_textures.go
+++ b/http/signed_textures.go
@@ -0,0 +1,49 @@
+package http
+
+import (
+	"encoding/json"
+	"net/http"
+	"strings"
+
+	"github.com/gorilla/mux"
+
+	"github.com/elyby/chrly/api/mojang"
+)
+
+func (cfg *Config) SignedTextures(response http.ResponseWriter, request *http.Request) {
+	cfg.Logger.IncCounter("signed_textures.request", 1)
+	username := parseUsername(mux.Vars(request)["username"])
+
+	var responseData *mojang.SignedTexturesResponse
+
+	rec, err := cfg.SkinsRepo.FindByUsername(username)
+	if err == nil && rec.SkinId != 0 && rec.MojangTextures != "" {
+		responseData = &mojang.SignedTexturesResponse{
+			Id:   strings.Replace(rec.Uuid, "-", "", -1),
+			Name: rec.Username,
+			Props: []*mojang.Property{
+				{
+					Name:      "textures",
+					Signature: rec.MojangSignature,
+					Value:     rec.MojangTextures,
+				},
+			},
+		}
+	} else if request.URL.Query().Get("proxy") != "" {
+		responseData = <-cfg.MojangTexturesQueue.GetTexturesForUsername(username)
+	}
+
+	if responseData == nil {
+		response.WriteHeader(http.StatusNoContent)
+		return
+	}
+
+	responseData.Props = append(responseData.Props, &mojang.Property{
+		Name:  "ely",
+		Value: "but why are you asking?",
+	})
+
+	responseJson, _ := json.Marshal(responseData)
+	response.Header().Set("Content-Type", "application/json")
+	response.Write(responseJson)
+}
--- a/http/signed_textures_test.go
+++ b/http/signed_textures_test.go
@@ -0,0 +1,141 @@
+package http
+
+import (
+	"io/ioutil"
+	"net/http/httptest"
+	"testing"
+
+	"github.com/golang/mock/gomock"
+	testify "github.com/stretchr/testify/assert"
+
+	"github.com/elyby/chrly/db"
+)
+
+func TestConfig_SignedTextures(t *testing.T) {
+	t.Run("Obtain signed textures for exists user", func(t *testing.T) {
+		assert := testify.New(t)
+
+		ctrl := gomock.NewController(t)
+		defer ctrl.Finish()
+
+		config, mocks := setupMocks(ctrl)
+
+		mocks.Log.EXPECT().IncCounter("signed_textures.request", int64(1))
+		mocks.Skins.EXPECT().FindByUsername("mock_user").Return(createSkinModel("mock_user", false), nil)
+
+		req := httptest.NewRequest("GET", "http://chrly/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))
+	})
+
+	t.Run("Obtain signed textures for not exists user", func(t *testing.T) {
+		assert := testify.New(t)
+
+		ctrl := gomock.NewController(t)
+		defer ctrl.Finish()
+
+		config, mocks := setupMocks(ctrl)
+
+		mocks.Log.EXPECT().IncCounter("signed_textures.request", int64(1))
+
+		mocks.Skins.EXPECT().FindByUsername("mock_user").Return(nil, &db.SkinNotFoundError{})
+
+		req := httptest.NewRequest("GET", "http://chrly/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))
+	})
+
+	t.Run("Obtain signed textures for exists user, but without signed textures", func(t *testing.T) {
+		assert := testify.New(t)
+
+		ctrl := gomock.NewController(t)
+		defer ctrl.Finish()
+
+		config, mocks := setupMocks(ctrl)
+
+		skinModel := createSkinModel("mock_user", false)
+		skinModel.MojangTextures = ""
+		skinModel.MojangSignature = ""
+
+		mocks.Log.EXPECT().IncCounter("signed_textures.request", int64(1))
+		mocks.Skins.EXPECT().FindByUsername("mock_user").Return(skinModel, nil)
+
+		req := httptest.NewRequest("GET", "http://chrly/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))
+	})
+
+	t.Run("Obtain signed textures for exists user, but without signed textures", func(t *testing.T) {
+		assert := testify.New(t)
+
+		ctrl := gomock.NewController(t)
+		defer ctrl.Finish()
+
+		config, mocks := setupMocks(ctrl)
+
+		skinModel := createSkinModel("mock_user", false)
+		skinModel.MojangTextures = ""
+		skinModel.MojangSignature = ""
+
+		mocks.Log.EXPECT().IncCounter("signed_textures.request", int64(1))
+		mocks.Skins.EXPECT().FindByUsername("mock_user").Return(skinModel, nil)
+		mocks.Queue.On("GetTexturesForUsername", "mock_user").Once().Return(createTexturesResponse(true, false))
+
+		req := httptest.NewRequest("GET", "http://chrly/textures/signed/mock_user?proxy=true", 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": "00000000000000000000000000000000",
+			"name": "mock_user",
+			"properties": [
+				{
+					"name": "textures",
+					"value": "eyJ0aW1lc3RhbXAiOjE1NTYzOTg1NzIsInByb2ZpbGVJZCI6IjAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwIiwicHJvZmlsZU5hbWUiOiJtb2NrX3VzZXIiLCJ0ZXh0dXJlcyI6eyJTS0lOIjp7InVybCI6Imh0dHA6Ly9tb2phbmcvc2tpbi5wbmcifX19"
+				},
+				{
+					"name": "ely",
+					"value": "but why are you asking?"
+				}
+			]
+		}`, string(response))
+	})
+}
--- a/http/skin.go
+++ b/http/skin.go
@@ -0,0 +1,49 @@
+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, rec.Url, 301)
+		return
+	}
+
+	mojangTextures := <-cfg.MojangTexturesQueue.GetTexturesForUsername(username)
+	if mojangTextures == nil {
+		response.WriteHeader(http.StatusNotFound)
+		return
+	}
+
+	texturesProp := mojangTextures.DecodeTextures()
+	skin := texturesProp.Textures.Skin
+	if skin == nil {
+		response.WriteHeader(http.StatusNotFound)
+		return
+	}
+
+	http.Redirect(response, request, skin.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)
+}
--- a/http/skin_test.go
+++ b/http/skin_test.go
@@ -0,0 +1,158 @@
+package http
+
+import (
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	"github.com/golang/mock/gomock"
+	testify "github.com/stretchr/testify/assert"
+
+	"github.com/elyby/chrly/db"
+	"github.com/elyby/chrly/model"
+)
+
+type skinsTestCase struct {
+	Name                 string
+	RequestUrl           string
+	ExpectedLogKey       string
+	ExistsInLocalStorage bool
+	ExistsInMojang       bool
+	HasSkinInMojangResp  bool
+	AssertResponse       func(assert *testify.Assertions, resp *http.Response)
+}
+
+var skinsTestCases = []*skinsTestCase{
+	{
+		Name:                 "Obtain skin for known username",
+		ExistsInLocalStorage: true,
+		AssertResponse: func(assert *testify.Assertions, resp *http.Response) {
+			assert.Equal(301, resp.StatusCode)
+			assert.Equal("http://chrly/skin.png", resp.Header.Get("Location"))
+		},
+	},
+	{
+		Name:                 "Obtain skin for unknown username that exists in Mojang and has a cape",
+		ExistsInLocalStorage: false,
+		ExistsInMojang:       true,
+		HasSkinInMojangResp:  true,
+		AssertResponse: func(assert *testify.Assertions, resp *http.Response) {
+			assert.Equal(301, resp.StatusCode)
+			assert.Equal("http://mojang/skin.png", resp.Header.Get("Location"))
+		},
+	},
+	{
+		Name:                 "Obtain skin for unknown username that exists in Mojang, but don't has a cape",
+		ExistsInLocalStorage: false,
+		ExistsInMojang:       true,
+		HasSkinInMojangResp:  false,
+		AssertResponse: func(assert *testify.Assertions, resp *http.Response) {
+			assert.Equal(404, resp.StatusCode)
+		},
+	},
+	{
+		Name:                 "Obtain skin for unknown username that doesn't exists in Mojang",
+		ExistsInLocalStorage: false,
+		ExistsInMojang:       false,
+		AssertResponse: func(assert *testify.Assertions, resp *http.Response) {
+			assert.Equal(404, resp.StatusCode)
+		},
+	},
+}
+
+func TestConfig_Skin(t *testing.T) {
+	performTest := func(t *testing.T, testCase *skinsTestCase) {
+		assert := testify.New(t)
+
+		ctrl := gomock.NewController(t)
+		defer ctrl.Finish()
+
+		config, mocks := setupMocks(ctrl)
+
+		mocks.Log.EXPECT().IncCounter(testCase.ExpectedLogKey, int64(1))
+		if testCase.ExistsInLocalStorage {
+			mocks.Skins.EXPECT().FindByUsername("mock_username").Return(createSkinModel("mock_username", false), nil)
+		} else {
+			mocks.Skins.EXPECT().FindByUsername("mock_username").Return(nil, &db.SkinNotFoundError{Who: "mock_username"})
+		}
+
+		if testCase.ExistsInMojang {
+			textures := createTexturesResponse(testCase.HasSkinInMojangResp, true)
+			mocks.Queue.On("GetTexturesForUsername", "mock_username").Return(textures)
+		} else {
+			mocks.Queue.On("GetTexturesForUsername", "mock_username").Return(nil)
+		}
+
+		req := httptest.NewRequest("GET", testCase.RequestUrl, nil)
+		w := httptest.NewRecorder()
+
+		config.CreateHandler().ServeHTTP(w, req)
+
+		resp := w.Result()
+		testCase.AssertResponse(assert, resp)
+	}
+
+	t.Run("Normal API", func(t *testing.T) {
+		for _, testCase := range skinsTestCases {
+			testCase.RequestUrl = "http://chrly/skins/mock_username"
+			testCase.ExpectedLogKey = "skins.request"
+			t.Run(testCase.Name, func(t *testing.T) {
+				performTest(t, testCase)
+			})
+		}
+	})
+
+	t.Run("GET fallback API", func(t *testing.T) {
+		for _, testCase := range skinsTestCases {
+			testCase.RequestUrl = "http://chrly/skins?name=mock_username"
+			testCase.ExpectedLogKey = "skins.get_request"
+			t.Run(testCase.Name, func(t *testing.T) {
+				performTest(t, testCase)
+			})
+		}
+
+		t.Run("Should trim trailing slash", func(t *testing.T) {
+			assert := testify.New(t)
+
+			req := httptest.NewRequest("GET", "http://chrly/skins/?name=notch", nil)
+			w := httptest.NewRecorder()
+
+			(&Config{}).CreateHandler().ServeHTTP(w, req)
+
+			resp := w.Result()
+			assert.Equal(301, resp.StatusCode)
+			assert.Equal("http://chrly/skins?name=notch", resp.Header.Get("Location"))
+		})
+
+		t.Run("Return error when name is not provided", func(t *testing.T) {
+			assert := testify.New(t)
+
+			ctrl := gomock.NewController(t)
+			defer ctrl.Finish()
+
+			config, mocks := setupMocks(ctrl)
+			mocks.Log.EXPECT().IncCounter("skins.get_request", int64(1))
+
+			req := httptest.NewRequest("GET", "http://chrly/skins", nil)
+			w := httptest.NewRecorder()
+
+			config.CreateHandler().ServeHTTP(w, req)
+
+			resp := w.Result()
+			assert.Equal(400, resp.StatusCode)
+		})
+	})
+}
+
+func createSkinModel(username string, isSlim bool) *model.Skin {
+	return &model.Skin{
+		UserId:          1,
+		Username:        username,
+		Uuid:            "0f657aa8-bfbe-415d-b700-5750090d3af3", // Use non nil UUID to pass validation in api tests
+		SkinId:          1,
+		Url:             "http://chrly/skin.png",
+		MojangTextures:  "mocked textures base64",
+		MojangSignature: "mocked signature",
+		IsSlim:          isSlim,
+	}
+}
--- a/http/textures.go
+++ b/http/textures.go
@@ -0,0 +1,61 @@
+package http
+
+import (
+	"encoding/json"
+	"net/http"
+
+	"github.com/gorilla/mux"
+
+	"github.com/elyby/chrly/api/mojang"
+)
+
+func (cfg *Config) Textures(response http.ResponseWriter, request *http.Request) {
+	cfg.Logger.IncCounter("textures.request", 1)
+	username := parseUsername(mux.Vars(request)["username"])
+
+	var textures *mojang.TexturesResponse
+	skin, skinErr := cfg.SkinsRepo.FindByUsername(username)
+	_, capeErr := cfg.CapesRepo.FindByUsername(username)
+	if (skinErr == nil && skin.SkinId != 0) || capeErr == nil {
+		textures = &mojang.TexturesResponse{}
+
+		if skinErr == nil && skin.SkinId != 0 {
+			skinTextures := &mojang.SkinTexturesResponse{
+				Url: skin.Url,
+			}
+
+			if skin.IsSlim {
+				skinTextures.Metadata = &mojang.SkinTexturesMetadata{
+					Model: "slim",
+				}
+			}
+
+			textures.Skin = skinTextures
+		}
+
+		if capeErr == nil {
+			textures.Cape = &mojang.CapeTexturesResponse{
+				Url: request.URL.Scheme + "://" + request.Host + "/cloaks/" + username,
+			}
+		}
+	} else {
+		mojangTextures := <-cfg.MojangTexturesQueue.GetTexturesForUsername(username)
+		if mojangTextures == nil {
+			response.WriteHeader(http.StatusNoContent)
+			return
+		}
+
+		texturesProp := mojangTextures.DecodeTextures()
+		if texturesProp == nil {
+			response.WriteHeader(http.StatusInternalServerError)
+			cfg.Logger.Error("Unable to find textures property")
+			return
+		}
+
+		textures = texturesProp.Textures
+	}
+
+	responseData, _ := json.Marshal(textures)
+	response.Header().Set("Content-Type", "application/json")
+	response.Write(responseData)
+}
--- a/http/textures_test.go
+++ b/http/textures_test.go
@@ -0,0 +1,194 @@
+package http
+
+import (
+	"bytes"
+	"io/ioutil"
+	"net/http/httptest"
+	"testing"
+
+	"github.com/golang/mock/gomock"
+	testify "github.com/stretchr/testify/assert"
+
+	"github.com/elyby/chrly/db"
+	"github.com/elyby/chrly/model"
+)
+
+func TestConfig_Textures(t *testing.T) {
+	t.Run("Obtain textures for exists user with only default skin", func(t *testing.T) {
+		assert := testify.New(t)
+
+		ctrl := gomock.NewController(t)
+		defer ctrl.Finish()
+
+		config, mocks := setupMocks(ctrl)
+
+		mocks.Log.EXPECT().IncCounter("textures.request", int64(1))
+
+		mocks.Skins.EXPECT().FindByUsername("mock_user").Return(createSkinModel("mock_user", false), nil)
+		mocks.Capes.EXPECT().FindByUsername("mock_user").Return(nil, &db.CapeNotFoundError{Who: "mock_user"})
+
+		req := httptest.NewRequest("GET", "http://chrly/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://chrly/skin.png"
+			}
+		}`, string(response))
+	})
+
+	t.Run("Obtain textures for exists user with only slim skin", func(t *testing.T) {
+		assert := testify.New(t)
+
+		ctrl := gomock.NewController(t)
+		defer ctrl.Finish()
+
+		config, mocks := setupMocks(ctrl)
+
+		mocks.Log.EXPECT().IncCounter("textures.request", int64(1))
+
+		mocks.Skins.EXPECT().FindByUsername("mock_user").Return(createSkinModel("mock_user", true), nil)
+		mocks.Capes.EXPECT().FindByUsername("mock_user").Return(nil, &db.CapeNotFoundError{Who: "mock_user"})
+
+		req := httptest.NewRequest("GET", "http://chrly/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://chrly/skin.png",
+				"metadata": {
+					"model": "slim"
+				}
+			}
+		}`, string(response))
+	})
+
+	t.Run("Obtain textures for exists user with only cape", func(t *testing.T) {
+		assert := testify.New(t)
+
+		ctrl := gomock.NewController(t)
+		defer ctrl.Finish()
+
+		config, mocks := setupMocks(ctrl)
+
+		mocks.Log.EXPECT().IncCounter("textures.request", int64(1))
+
+		mocks.Skins.EXPECT().FindByUsername("mock_user").Return(nil, &db.SkinNotFoundError{Who: "mock_user"})
+		mocks.Capes.EXPECT().FindByUsername("mock_user").Return(&model.Cape{File: bytes.NewReader(createCape())}, nil)
+
+		req := httptest.NewRequest("GET", "http://chrly/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(`{
+			"CAPE": {
+				"url": "http://chrly/cloaks/mock_user"
+			}
+		}`, string(response))
+	})
+
+	t.Run("Obtain textures for exists user with skin and cape", func(t *testing.T) {
+		assert := testify.New(t)
+
+		ctrl := gomock.NewController(t)
+		defer ctrl.Finish()
+
+		config, mocks := setupMocks(ctrl)
+
+		mocks.Log.EXPECT().IncCounter("textures.request", int64(1))
+
+		mocks.Skins.EXPECT().FindByUsername("mock_user").Return(createSkinModel("mock_user", false), nil)
+		mocks.Capes.EXPECT().FindByUsername("mock_user").Return(&model.Cape{File: bytes.NewReader(createCape())}, nil)
+
+		req := httptest.NewRequest("GET", "http://chrly/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://chrly/skin.png"
+			},
+			"CAPE": {
+				"url": "http://chrly/cloaks/mock_user"
+			}
+		}`, string(response))
+	})
+
+	t.Run("Obtain textures for not exists user that exists in Mojang", func(t *testing.T) {
+		assert := testify.New(t)
+
+		ctrl := gomock.NewController(t)
+		defer ctrl.Finish()
+
+		config, mocks := setupMocks(ctrl)
+
+		mocks.Log.EXPECT().IncCounter("textures.request", int64(1))
+
+		mocks.Skins.EXPECT().FindByUsername("mock_username").Return(nil, &db.SkinNotFoundError{})
+		mocks.Capes.EXPECT().FindByUsername("mock_username").Return(nil, &db.CapeNotFoundError{})
+		mocks.Queue.On("GetTexturesForUsername", "mock_username").Once().Return(createTexturesResponse(true, true))
+
+		req := httptest.NewRequest("GET", "http://chrly/textures/mock_username", 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://mojang/skin.png"
+			},
+			"CAPE": {
+				"url": "http://mojang/cape.png"
+			}
+		}`, string(response))
+	})
+
+	t.Run("Obtain textures for not exists user that not exists in Mojang too", func(t *testing.T) {
+		assert := testify.New(t)
+
+		ctrl := gomock.NewController(t)
+		defer ctrl.Finish()
+
+		config, mocks := setupMocks(ctrl)
+
+		mocks.Log.EXPECT().IncCounter("textures.request", int64(1))
+
+		mocks.Skins.EXPECT().FindByUsername("mock_username").Return(nil, &db.SkinNotFoundError{})
+		mocks.Capes.EXPECT().FindByUsername("mock_username").Return(nil, &db.CapeNotFoundError{})
+		mocks.Queue.On("GetTexturesForUsername", "mock_username").Once().Return(nil)
+
+		req := httptest.NewRequest("GET", "http://chrly/textures/mock_username", nil)
+		w := httptest.NewRecorder()
+
+		config.CreateHandler().ServeHTTP(w, req)
+
+		resp := w.Result()
+		assert.Equal(204, resp.StatusCode)
+	})
+}
--- a/interfaces/auth.go
+++ b/interfaces/auth.go
@@ -0,0 +1,7 @@
+package interfaces
+
+import "net/http"
+
+type AuthChecker interface {
+	Check(req *http.Request) error
+}
--- a/interfaces/mock_interfaces/mock_auth.go
+++ b/interfaces/mock_interfaces/mock_auth.go
@@ -0,0 +1,45 @@
+// Code generated by MockGen. DO NOT EDIT.
+// Source: interfaces/auth.go
+
+package mock_interfaces
+
+import (
+	gomock "github.com/golang/mock/gomock"
+	http "net/http"
+	reflect "reflect"
+)
+
+// MockAuthChecker is a mock of AuthChecker interface
+type MockAuthChecker struct {
+	ctrl     *gomock.Controller
+	recorder *MockAuthCheckerMockRecorder
+}
+
+// MockAuthCheckerMockRecorder is the mock recorder for MockAuthChecker
+type MockAuthCheckerMockRecorder struct {
+	mock *MockAuthChecker
+}
+
+// NewMockAuthChecker creates a new mock instance
+func NewMockAuthChecker(ctrl *gomock.Controller) *MockAuthChecker {
+	mock := &MockAuthChecker{ctrl: ctrl}
+	mock.recorder = &MockAuthCheckerMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use
+func (_m *MockAuthChecker) EXPECT() *MockAuthCheckerMockRecorder {
+	return _m.recorder
+}
+
+// Check mocks base method
+func (_m *MockAuthChecker) Check(req *http.Request) error {
+	ret := _m.ctrl.Call(_m, "Check", req)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// Check indicates an expected call of Check
+func (_mr *MockAuthCheckerMockRecorder) Check(arg0 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCallWithMethodType(_mr.mock, "Check", reflect.TypeOf((*MockAuthChecker)(nil).Check), arg0)
+}
--- a/interfaces/mock_interfaces/mock_interfaces.go
+++ b/interfaces/mock_interfaces/mock_interfaces.go
@@ -0,0 +1,131 @@
+// Code generated by MockGen. DO NOT EDIT.
+// Source: interfaces/repositories.go
+
+package mock_interfaces
+
+import (
+	model "github.com/elyby/chrly/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)
+}
+
+// RemoveByUserId mocks base method
+func (_m *MockSkinsRepository) RemoveByUserId(id int) error {
+	ret := _m.ctrl.Call(_m, "RemoveByUserId", id)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// RemoveByUserId indicates an expected call of RemoveByUserId
+func (_mr *MockSkinsRepositoryMockRecorder) RemoveByUserId(arg0 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCallWithMethodType(_mr.mock, "RemoveByUserId", reflect.TypeOf((*MockSkinsRepository)(nil).RemoveByUserId), arg0)
+}
+
+// RemoveByUsername mocks base method
+func (_m *MockSkinsRepository) RemoveByUsername(username string) error {
+	ret := _m.ctrl.Call(_m, "RemoveByUsername", username)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// RemoveByUsername indicates an expected call of RemoveByUsername
+func (_mr *MockSkinsRepositoryMockRecorder) RemoveByUsername(arg0 interface{}) *gomock.Call {
+	return _mr.mock.ctrl.RecordCallWithMethodType(_mr.mock, "RemoveByUsername", reflect.TypeOf((*MockSkinsRepository)(nil).RemoveByUsername), 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)
+}
--- a/interfaces/mock_wd/mock_wd.go
+++ b/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...)
+}
--- a/interfaces/repositories.go
+++ b/interfaces/repositories.go
@@ -0,0 +1,22 @@
+package interfaces
+
+import (
+	"github.com/elyby/chrly/api/mojang"
+	"github.com/elyby/chrly/model"
+)
+
+type SkinsRepository interface {
+	FindByUsername(username string) (*model.Skin, error)
+	FindByUserId(id int) (*model.Skin, error)
+	Save(skin *model.Skin) error
+	RemoveByUserId(id int) error
+	RemoveByUsername(username string) error
+}
+
+type CapesRepository interface {
+	FindByUsername(username string) (*model.Cape, error)
+}
+
+type MojangTexturesQueue interface {
+	GetTexturesForUsername(username string) chan *mojang.SignedTexturesResponse
+}
--- a/lib/data/CapeItem.go
+++ b/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)
-}
--- a/lib/data/SkinItem.go
+++ b/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)
-}
--- a/lib/data/TexturesResponse.go
+++ b/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"`
-}
--- a/lib/routes/Cape.go
+++ b/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)
-}
--- a/lib/routes/Face.go
+++ b/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 "/minecfaft/skin_buffer/faces/" + hash + ".png"
-}
--- a/lib/routes/MinecraftPHP.go
+++ b/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)
-	}
-	}
-}
--- a/lib/routes/NotFound.go
+++ b/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)
-}
--- a/lib/routes/SetSkin.go
+++ b/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"))
-}
--- a/lib/routes/Skin.go
+++ b/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)
-}
--- a/lib/routes/Textures.go
+++ b/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)
-}
--- a/lib/services/services.go
+++ b/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
--- a/lib/tools/tools.go
+++ b/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()
-}
-
--- a/lib/tools/tools_test.go
+++ b/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:")
-	}
-}
--- a/lib/worker/handlers.go
+++ b/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
-}
--- a/lib/worker/models.go
+++ b/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"`
-}
--- a/lib/worker/worker.go
+++ b/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)
-	}
-}
--- a/main.go
+++ b/main.go
@@ -0,0 +1,12 @@
+package main
+
+import (
+	"runtime"
+
+	"github.com/elyby/chrly/cmd"
+)
+
+func main() {
+	runtime.GOMAXPROCS(runtime.NumCPU())
+	cmd.Execute()
+}
--- a/minecraft-skinsystem.go
+++ b/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))
-}
--- a/model/cape.go
+++ b/model/cape.go
@@ -0,0 +1,9 @@
+package model
+
+import (
+	"io"
+)
+
+type Cape struct {
+	File io.Reader
+}
--- a/model/skin.go
+++ b/model/skin.go
@@ -0,0 +1,14 @@
+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"`
+	MojangTextures  string `json:"mojangTextures"`
+	MojangSignature string `json:"mojangSignature"`
+	OldUsername     string
+}
--- a/script/coverage
+++ b/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
--- a/script/mocks
+++ b/script/mocks
@@ -0,0 +1,4 @@
+#!/bin/sh
+
+mockgen -source=interfaces/repositories.go -destination=interfaces/mock_interfaces/mock_interfaces.go
+mockgen -source=interfaces/auth.go -destination=interfaces/mock_interfaces/mock_auth.go
--- a/script/test
+++ b/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
--- a/tests/mojang_textures_queue_mock.go
+++ b/tests/mojang_textures_queue_mock.go
@@ -0,0 +1,33 @@
+package tests
+
+import (
+	"github.com/elyby/chrly/api/mojang"
+
+	"github.com/stretchr/testify/mock"
+)
+
+type MojangTexturesQueueMock struct {
+	mock.Mock
+}
+
+func (m *MojangTexturesQueueMock) GetTexturesForUsername(username string) chan *mojang.SignedTexturesResponse {
+	args := m.Called(username)
+	result := make(chan *mojang.SignedTexturesResponse)
+	arg := args.Get(0)
+	switch arg.(type) {
+	case *mojang.SignedTexturesResponse:
+		go func() {
+			result <- arg.(*mojang.SignedTexturesResponse)
+		}()
+	case chan *mojang.SignedTexturesResponse:
+		return arg.(chan *mojang.SignedTexturesResponse)
+	case nil:
+		go func() {
+			result <- nil
+		}()
+	default:
+		panic("unsupported return value")
+	}
+
+	return result
+}
--- a/tests/wd_mock.go
+++ b/tests/wd_mock.go
@@ -0,0 +1,61 @@
+package tests
+
+import (
+	"time"
+
+	"github.com/mono83/slf"
+	"github.com/mono83/slf/wd"
+	"github.com/stretchr/testify/mock"
+)
+
+type WdMock struct {
+	mock.Mock
+}
+
+func (m *WdMock) Trace(message string, p ...slf.Param) {
+	m.Called(message)
+}
+
+func (m *WdMock) Debug(message string, p ...slf.Param) {
+	m.Called(message)
+}
+
+func (m *WdMock) Info(message string, p ...slf.Param) {
+	m.Called(message)
+}
+
+func (m *WdMock) Warning(message string, p ...slf.Param) {
+	m.Called(message)
+}
+
+func (m *WdMock) Error(message string, p ...slf.Param) {
+	m.Called(message)
+}
+
+func (m *WdMock) Alert(message string, p ...slf.Param) {
+	m.Called(message)
+}
+
+func (m *WdMock) Emergency(message string, p ...slf.Param) {
+	m.Called(message)
+}
+
+func (m *WdMock) IncCounter(name string, value int64, p ...slf.Param) {
+	m.Called(name, value)
+}
+
+func (m *WdMock) UpdateGauge(name string, value int64, p ...slf.Param) {
+	m.Called(name, value)
+}
+
+func (m *WdMock) RecordTimer(name string, d time.Duration, p ...slf.Param) {
+	m.Called(name, d)
+}
+
+func (m *WdMock) Timer(name string, p ...slf.Param) slf.Timer {
+	return slf.NewTimer(name, p, m)
+}
+
+func (m *WdMock) WithParams(p ...slf.Param) wd.Watchdog {
+	panic("this method shouldn't be used")
+}
Author	SHA1	Message	Date
ErickSkrauch	ab847589ba	Merge branch 'master' into ely	2019-11-08 02:13:05 +03:00
ErickSkrauch	6fd88e077e	Prepare 4.3.0 release	2019-11-08 02:12:31 +03:00
ErickSkrauch	ae185e1daa	Bump Go version to 1.13	2019-11-08 02:08:10 +03:00
ErickSkrauch	7353047467	Increase queue loop delay from 1 to 2.5 seconds. Add configuration param to adjust its value	2019-11-08 01:54:16 +03:00
ErickSkrauch	b2a1fd450b	Handle 403 Forbidden error from Mojang's API	2019-11-08 01:32:26 +03:00
ErickSkrauch	e573e6146d	Merge branch 'master' into ely	2019-10-03 01:40:30 +03:00
ErickSkrauch	334e60ff2f	Prepare 4.2.3 release	2019-10-03 01:26:34 +03:00
ErickSkrauch	6d6d0e4b79	Decrease queue batch size. Log all 400 response from the Mojang's API. Resolves #10 .	2019-10-03 01:24:25 +03:00
ErickSkrauch	2775b14e78	Merge branch 'master' into ely	2019-06-19 01:08:32 +03:00
ErickSkrauch	0cfed45b64	Prepare 4.2.2 release	2019-06-19 01:02:41 +03:00
ErickSkrauch	f872fe4698	Fix race condition, introduced in the previous commit	2019-06-19 00:56:09 +03:00
ErickSkrauch	5b4761e4e5	Fixes #9 . Start GC loop for in-memory textures cache.	2019-06-18 23:34:16 +03:00
ErickSkrauch	c25a2f2360	Merge branch 'master' into ely	2019-05-06 17:27:28 +03:00
ErickSkrauch	e81ca1520d	Add codecov shield [skip ci]	2019-05-06 17:26:55 +03:00
ErickSkrauch	d36fc77df0	Prepare 4.2.1 release	2019-05-06 17:20:52 +03:00
ErickSkrauch	ab78af33a5	Remove validation rules for a hash field	2019-05-06 17:17:44 +03:00
ErickSkrauch	1f057a27aa	Adjust Mojang's queue behavior	2019-05-06 17:12:37 +03:00
ErickSkrauch	9dde5715f5	Adjust Mojang's queue behavior	2019-05-05 23:06:29 +03:00
ErickSkrauch	edc368aa81	Merge branch 'master' into ely	2019-05-02 21:56:04 +03:00
ErickSkrauch	f3a8af6866	Upgrade Alpine version to 3.9, add ca-certificates	2019-05-02 21:55:21 +03:00
ErickSkrauch	4097e61a02	Merge branch 'master' into ely	2019-05-02 21:08:21 +03:00
ErickSkrauch	e6bac323c5	Update changelog	2019-05-02 21:07:40 +03:00
ErickSkrauch	26a8628070	Remove faces endpoint	2019-05-02 20:55:50 +03:00
ErickSkrauch	ae0ff91a64	Fix test for signed textures	2019-05-02 20:54:18 +03:00
ErickSkrauch	ab6410ff4a	Merge branch 'master' into ely	2019-05-02 20:53:45 +03:00
ErickSkrauch	6515e3e5bd	Resolves #5 . Return Redis connection to the pool after commands are executed	2019-05-01 02:16:20 +03:00
ErickSkrauch	ed0b9bb040	Resolves #6 . Remove hash field from the project structures	2019-05-01 02:16:11 +03:00
ErickSkrauch	a81c6fc9f8	Resolves #4 . Fix Gopkg.toml structure, update all outdated dependencies, use middlewares introduced in gorilla/mux 1.6.1, replace gopkg.in/h2non/gock.v1 with it's GitHub link github.com/h2non/gock	2019-05-01 02:15:57 +03:00
ErickSkrauch	8aeb1929b5	Merge pull request #3 from elyby/1_mojang_skins_proxy Restore Mojang skins proxy implementation	2019-05-01 00:56:11 +03:00
ErickSkrauch	b97647318f	Enable codecov	2019-04-30 14:31:04 +03:00
KolFoxy	8d619d52cd	#1 : Fixed misspells in README and CHANGELOG Co-Authored-By: erickskrauch <erickskrauch@ely.by>	2019-04-30 11:03:58 +03:00
ErickSkrauch	a5daae3cb8	#1 : Add CHANGELOG.md, update README.md	2019-04-30 01:55:59 +03:00
ErickSkrauch	94b930f388	#1 : Add test case for panic when trying to store response without textures	2019-04-30 00:45:29 +03:00
ErickSkrauch	f213ed45c7	#1 : Log unexpected errors from Mojang API	2019-04-30 00:36:51 +03:00
ErickSkrauch	6daec4dc4b	#1 : Fix GolangCI issues	2019-04-28 20:30:55 +03:00
ErickSkrauch	90ce22f687	#1 : Attempt to fix travis tests run	2019-04-28 20:24:08 +03:00
ErickSkrauch	9250d53fb3	#1 : Remove comments about compatibility check with exists Authlibs	2019-04-28 20:21:46 +03:00
ErickSkrauch	2c7a1625f3	#1 : Tests for http layer are restored	2019-04-28 00:43:22 +03:00
ErickSkrauch	f7cdab243f	#1 : Integrate queue to the application	2019-04-27 01:46:15 +03:00
ErickSkrauch	f3690686ec	#1 : Implement UuidsStorage in Redis	2019-04-25 02:23:10 +03:00
ErickSkrauch	533afcc689	#1 : Add logging mechanic and remove awaiting of finishing of all textures requests in usernames queue	2019-04-25 00:45:04 +03:00
ErickSkrauch	50a19202a5	#1 : Fix build	2019-04-21 20:35:35 +03:00
ErickSkrauch	d7f03ce182	#1 : Implemented in-memory storage for textures	2019-04-21 20:28:58 +03:00
ErickSkrauch	ad300e8c1c	#1 : Implemented helper to decode/encode base64 textures value	2019-04-21 20:27:54 +03:00
ErickSkrauch	7d1506d0d9	#1 : Fix Mojang's API HTTPClient default configuration, make mojang.ResponseError interface not applicable to any type, add handling of some possible network errors	2019-04-21 03:04:03 +03:00
ErickSkrauch	a8bbacf8b1	#1 : Handle Mojang's server errors too	2019-04-20 23:04:29 +03:00
ErickSkrauch	c2921400b0	#1 : Add case when Mojang's API returns empty response	2019-04-20 22:39:17 +03:00
ErickSkrauch	e7c0fac346	#1 : Split textures processing to 2 separate steps	2019-04-20 22:22:02 +03:00
ErickSkrauch	bd099cfb2a	#1 : User golang 1.12 for travis build. Improve random usernames generator	2019-04-20 20:04:57 +03:00
ErickSkrauch	96af45b2a1	#1 : Disallow to query invalid Mojang usernames	2019-04-20 19:51:55 +03:00
ErickSkrauch	b1e18d0d01	#1 : Add storage integration	2019-04-20 19:35:37 +03:00
ErickSkrauch	abea94a41f	#1 : Add broadcaster structure to broadcast results of the same usernames	2019-04-20 03:23:49 +03:00
ErickSkrauch	8244351bb5	#1 : Fix race conditions errors and rewrite tests	2019-04-19 01:41:52 +03:00
ErickSkrauch	e14619e079	#1 : add initial tests for queue, upgrade github.com/stretchr/testify	2019-04-18 02:56:20 +03:00
ErickSkrauch	fd4e5eb9ca	#1 : Pull queue into struct, add storage interface	2019-04-15 02:52:00 +03:00
ErickSkrauch	879a33344b	#1 : Renaming	2019-04-15 01:32:22 +03:00
ErickSkrauch	d2d6d07fa6	#1 : Rough implementation of textures queue	2019-04-15 00:52:10 +03:00
ErickSkrauch	44f3ee7413	#1 : Improve uuidToTextures method, organize tests	2019-04-15 00:31:09 +03:00
ErickSkrauch	7db4d27fba	#1 : Implemented necessary Mojang APIs	2019-04-14 17:36:46 +03:00
ErickSkrauch	4386054ca1	Latest dep structure changes [skip ci]	2019-04-14 17:34:10 +03:00
ErickSkrauch	c7ac890812	Merge branch 'master' into ely	2018-03-19 02:19:14 +03:00
ErickSkrauch	b73582bbf4	Do not limit hash format only to md5	2018-03-19 02:16:07 +03:00
ErickSkrauch	34598e39bc	Allow any uuid version	2018-03-19 01:16:37 +03:00
ErickSkrauch	9fc6ca54d9	Fix latest tag condition	2018-02-17 02:21:03 +03:00
ErickSkrauch	aed957a896	Fix latest tag condition	2018-02-17 02:15:20 +03:00
ErickSkrauch	7734f2cbd5	Merge branch 'master' into ely	2018-02-17 01:52:47 +03:00
ErickSkrauch	2cd97dda8b	Compile without CGO usage	2018-02-17 01:25:24 +03:00
ErickSkrauch	ded50df8b8	Build chrly statically to work with Alpine image	2018-02-17 01:14:43 +03:00
ErickSkrauch	55b8c12955	Restore Ely documentation link on the 404 page	2018-02-16 21:01:01 +03:00
ErickSkrauch	10ff6f34fb	Restore Ely signed textures ely property	2018-02-16 21:01:01 +03:00
ErickSkrauch	31cd75ffa7	Restore Ely faces API	2018-02-16 21:01:01 +03:00
ErickSkrauch	d7bc77e5a7	Adjust Travis setup	2018-02-16 20:58:29 +03:00
ErickSkrauch	befa163f0e	Merge branch 'develop'	2018-02-16 20:44:12 +03:00
ErickSkrauch	cb7adab3df	Merge branch '4.1' into develop	2018-02-16 18:31:56 +03:00
ErickSkrauch	87a302c7da	Hello, Travis?	2018-02-16 00:46:20 +03:00
ErickSkrauch	ce4dce49a2	Completely rename project to the Chrly and make it ready to be opensourced	2018-02-16 00:13:57 +03:00
ErickSkrauch	11647f2eae	Remove gitlab-ci	2018-02-16 00:02:05 +03:00
ErickSkrauch	acd0237fac	Update Dockerfile, add docker-compose for prod and dev environment, cleanup some old things	2018-02-16 00:01:46 +03:00
ErickSkrauch	55f52d0ad4	Add project README	2018-02-15 23:57:57 +03:00
ErickSkrauch	778bc615aa	The configuration file was deleted in favor of using environment variables. Token generation functionality remove. Secret token now provided via CHRLY_SECRET env variable.	2018-02-15 23:57:23 +03:00
ErickSkrauch	235f65f11c	Add LICENSE	2018-02-15 01:03:40 +03:00
ErickSkrauch	8dd6a581a9	Fix commands descriptions	2018-02-14 23:49:22 +03:00
ErickSkrauch	055f3ce6c0	Rename ely field into chrly	2018-02-11 17:03:13 +03:00
ErickSkrauch	a9f5632743	Remove Ely.by documentation link from not found response	2018-02-11 16:57:20 +03:00
ErickSkrauch	ce99ac8cf8	Removed Ely-specific faces API	2018-02-01 23:16:52 +03:00
ErickSkrauch	6192a58f63	Removed buildUrl() helper for automatically adding ely.by domain to skin. Now it's universtal	2018-02-01 22:58:34 +03:00
ErickSkrauch	caebac1753	Added version print by --version flag	2018-01-24 23:36:42 +03:00
ErickSkrauch	dcaa4c037d	Removed mentions of the AMQP worker and Accounts Ely.by internal API inside configs	2018-01-24 00:26:50 +03:00
ErickSkrauch	9e4f805ed3	Removed sentry logger implementation (we are already use accepter PR with this implementation)	2018-01-24 00:19:26 +03:00
ErickSkrauch	ad7faf6e81	Added statsd metrics logging for newly created API	2018-01-24 00:14:31 +03:00
ErickSkrauch	855302ec60	Removed amqp worker command implementation Removed Accounts Ely.by api implementation	2018-01-23 23:49:50 +03:00
ErickSkrauch	f5f8fbc65e	Added test for the case, when signing key is not available	2018-01-23 23:20:28 +03:00
ErickSkrauch	968c83db99	Implemented skin deleting	2018-01-23 22:58:42 +03:00
ErickSkrauch	1e2f30c6c7	Forgot to commit auth checker interface mock	2018-01-23 18:53:14 +03:00
ErickSkrauch	f120064fe3	Implemented API endpoint to update skin information Added tests to jwt package Reworked redis backend implementation Skin repository now have methods to remove skins by user id or username	2018-01-23 18:43:37 +03:00
ErickSkrauch	aaff88d32f	Reworked http tests mocking	2018-01-23 00:16:42 +03:00
ErickSkrauch	b8c3cc6cf8	Added sh script to rebuild mocks for interfaces	2018-01-20 21:23:05 +03:00
ErickSkrauch	ca4479252f	Implemented jwt generation	2018-01-15 23:52:22 +03:00
ErickSkrauch	d2485df64d	Use accepted PR of github.com/mono83/slf with support of Sentry logger	2018-01-05 00:10:38 +03:00
ErickSkrauch	6a489287ba	Removed OldSkinId field	2018-01-04 23:47:05 +03:00
ErickSkrauch	6e7a61f5f2	Merge branch 'develop'	2017-09-29 14:01:27 +03:00
ErickSkrauch	20b8e8da86	Возвращаем ошибку, если не удалось раскодировать JSON с информацией о скине из Redis	2017-09-29 13:59:29 +03:00
ErickSkrauch	63df092973	Merge branch 'develop'	2017-09-11 17:00:22 +03:00
ErickSkrauch	378643623b	Исправлена ошибка, которая возвращается, если в бд не найдено записи о скине	2017-09-11 16:49:08 +03:00
ErickSkrauch	e33b86b809	Merge branch 'develop'	2017-09-11 14:25:15 +03:00
ErickSkrauch	80fa307915	Обновлён .gitlab-ci: переименованы ENV перменные в соответствии с 9 версией GitLab Исправлен вызов компилятора для "зашивания" версии при сборке	2017-09-11 14:17:28 +03:00
ErickSkrauch	2e9520db89	Добавлена команда version для отображения версии	2017-09-11 14:16:25 +03:00
ErickSkrauch	74564b4747	Fixes SKINSYSTEM-3	2017-09-11 13:54:11 +03:00
ErickSkrauch	18909776a8	Merge branch 'develop'	2017-09-05 01:05:17 +03:00
ErickSkrauch	d1b1f22a93	Merge branch 'v4'	2017-09-05 01:04:41 +03:00
ErickSkrauch	cb928a3918	Исправлен volume для worker в docker-compose под production [skip ci]	2017-09-05 00:57:40 +03:00
ErickSkrauch	d9aeaba627	Компилируем на golang:1.9-alpine image	2017-09-04 23:56:10 +03:00
ErickSkrauch	645f6ac694	Для сборки проекта теперь используется Go 1.9	2017-09-04 20:25:32 +03:00
ErickSkrauch	eab7c6ecaa	Все Docker штуки опущены в директорию docker. Production Docker контейнер теперь использует alpine linux вместо пустого scratch В production Docker контейнер добавлен docker-entrypoint.sh, который автоматически создаёт конфиг по умолчанию.	2017-09-04 20:24:55 +03:00
ErickSkrauch	ac714de8df	Логгер в консоль теперь не добавляет метку в конец строки, а также выводит время в более коротком формате	2017-09-03 22:54:46 +03:00
ErickSkrauch	8007b082d6	Реализовано автоматическое восстановление соединения с AMQP	2017-09-03 22:45:38 +03:00
ErickSkrauch	9cb6502f9c	Модели amqp событий перенесены непосредственно в компонент amqp worker	2017-09-03 21:41:40 +03:00
ErickSkrauch	76a3f3ad26	rabbitmq images заменены на alpine версии	2017-09-03 21:28:17 +03:00
ErickSkrauch	bdd7c5e15e	Обновлены docker-compose файлы Добавлен config.dist.yml Обновлено README проекта (наконец-то нормально описание!) Файл конфигурации теперь автоматически ищется в директории проекта.	2017-09-03 00:09:11 +03:00
ErickSkrauch	340b24d862	Добавлена генерация версии при сборке проекта	2017-09-02 21:37:16 +03:00
ErickSkrauch	cf99a0eab2	Добавлена интеграция с Sentry	2017-08-27 18:10:03 +03:00
ErickSkrauch	fb4ae46e29	На этап сборки docker контейнера возвращено использование репозитория	2017-08-24 15:10:30 +03:00
ErickSkrauch	971155485b	Игнорируем возможную неудачу команды docker rmi на этапе cleanup	2017-08-24 15:04:52 +03:00
ErickSkrauch	9ee3e93042	Обновлёна логика построения production image, используем только scratch, без alpine linux	2017-08-24 14:57:03 +03:00
ErickSkrauch	6128c56a0c	Добавлен вызов runtime.GOMAXPROCS() Обновлены зависимости	2017-08-23 00:01:58 +03:00
ErickSkrauch	a2e3d28580	Добавлены скрипты для тестирования и подсчёта общего coverage	2017-08-21 18:45:27 +03:00
ErickSkrauch	fecfa9c4e8	Оттестирован функционал пакета worker	2017-08-21 15:37:15 +03:00
ErickSkrauch	04714543b8	Реорганизация пакета daemon в http. Упразднён пакет utils. Удалён обработчик minecraft.php (legacy с самого-самого начала Ely.by) Добавлены тесты для всех api-запросов.	2017-08-20 01:22:42 +03:00
ErickSkrauch	ec461efe34	Добавлена логика автоматического рефреша API токена при его истечении	2017-08-18 17:48:29 +03:00
ErickSkrauch	eec6b384b7	Тестирование включено в CI	2017-08-18 02:03:18 +03:00
ErickSkrauch	4734bfd93c	Восстановлена логика для доступна к internal API Accounts Ely.by	2017-08-18 01:08:08 +03:00
ErickSkrauch	b1dbee2310	repositories package переименован в interfaces	2017-08-18 00:50:23 +03:00
ErickSkrauch	78917a70d3	Частично восстановлена логика AMQP воркера	2017-08-17 02:47:35 +03:00
ErickSkrauch	4bf146dd43	Восстановлен логгинг метрик в statsd, если таковой указан в конфигурации	2017-08-16 15:23:03 +03:00
ErickSkrauch	06b8e88346	Реализовано автоматическое восстановление соединения с redis	2017-08-15 01:03:02 +03:00
ErickSkrauch	4945b3f984	Исправлен Dockerfile	2017-08-15 00:44:27 +03:00
ErickSkrauch	359aef4b40	Миграция с glide на dep для управления зависимостями	2017-08-15 00:43:56 +03:00
ErickSkrauch	b159cd327c	Подчищены команды в cmd	2017-08-15 00:43:31 +03:00
ErickSkrauch	b99697d26e	Попытка сделать фабрики репозиториев для абстрактных хранилищ данных. Добавлено чтение конфигурации из файла.	2017-08-14 21:06:22 +03:00
ErickSkrauch	d51c358ef6	Имплементации репозиториев теперь хранятся в том же пакете, что и базовое описание фабрики репозитория	2017-08-10 03:14:28 +03:00
ErickSkrauch	d9629b5e83	Возвращаем ошибки по ссылке в реализациях репозиториев	2017-08-10 03:00:02 +03:00
ErickSkrauch	428bedf301	Entities в model, repositories в repositories	2017-08-09 19:19:46 +03:00
ErickSkrauch	11a7570f51	Учитываем пустой input для методов FindByUsername	2017-08-09 19:11:53 +03:00
ErickSkrauch	676ba03c37	Применены рекомендации от index0h	2017-07-02 03:35:38 +03:00
ErickSkrauch	07903cf9c8	Переработка структуры проекта	2017-06-30 18:40:25 +03:00
ErickSkrauch	e090d04dc7	Go обновлён до 1.9 Перешли на использование менеджера зависимостей glide	2017-06-28 13:32:20 +03:00
ErickSkrauch	a993c1d157	Реализовано сжатие значений в redis	2017-06-19 02:20:38 +03:00
ErickSkrauch	a661f9aac3	Merge branch 'develop'	2017-06-17 01:30:58 +03:00
ErickSkrauch	9ffdf99b77	Образ redis заменён на 3.2-32bit для экономии памяти	2017-06-17 01:17:02 +03:00
ErickSkrauch	ad35872fc1	Добавлено логирование запроса получения токена авторизации	2017-06-17 01:16:34 +03:00
ErickSkrauch	a8d8fffaa5	Исправлен адрес для API запросов	2017-06-17 01:16:08 +03:00
ErickSkrauch	0d41f0c347	Merge branch 'develop'	2017-04-13 14:20:36 +03:00
ErickSkrauch	b22f0551fa	Не добавляем домен к ссылке на скин, если скин уже имеет домен	2017-04-13 14:20:04 +03:00
ErickSkrauch	1a906cfc09	Merge branch 'develop'	2017-04-10 20:50:25 +03:00
ErickSkrauch	f610667aa5	Revert statsd config	2017-04-10 20:47:45 +03:00
ErickSkrauch	8b51c1bd0c	Merge branch 'develop'	2017-04-10 20:38:35 +03:00
ErickSkrauch	cbe940f8ec	Конфиг Accounts API вынесен в параметры окружения	2017-04-10 20:28:47 +03:00
ErickSkrauch	8693673a71	Добавлена поддержка восстановления информации об аккаунте, если по какой-то причине её не удалось найти в хранилище	2017-04-10 14:53:26 +03:00
ErickSkrauch	73205648d2	Merge branch 'develop'	2017-04-04 18:54:22 +03:00
ErickSkrauch	3d73cc9402	Добавлено Ely property	2017-04-01 12:46:25 +03:00
ErickSkrauch	39f5ec5bee	Учитываем ситуацию, когда скин есть, а просчитанной текстуры - нет	2017-04-01 12:22:48 +03:00
ErickSkrauch	e652691b29	Добавлена поддержка отображения подписанных текстур	2017-04-01 12:18:57 +03:00
ErickSkrauch	d3b4bee3b0	Обновлён docker-composer.base.yml	2017-03-25 16:48:47 +03:00
ErickSkrauch	ae50e90ea7	Merge branch 'statsd' into develop	2017-03-25 16:38:09 +03:00
ErickSkrauch	c74151c558	Переименованы некоторые параметры для statsd	2017-03-25 16:36:37 +03:00
ErickSkrauch	445bd18fbc	Merge branch 'develop' into statsd	2017-03-25 15:56:07 +03:00
ErickSkrauch	6a881a62e3	Доработана конфигурация взаимодействия со statsd	2017-03-25 15:55:57 +03:00
ErickSkrauch	201a257d69	Исправлены вызовы IncCounter для обработчиков задач из amqp	2017-03-25 15:54:17 +03:00
ErickSkrauch	5d46094643	Удалён обработчик для запроса setSkin	2016-12-03 02:08:00 +03:00
ErickSkrauch	1694403c79	Добавлен gitlab-ci	2016-12-03 02:05:23 +03:00
ErickSkrauch	66c61dc3cd	Добавлено логгирование метрик для системы скинов	2016-12-03 01:57:55 +03:00
ErickSkrauch	a0d940f8cd	Попытка внедрить statsd	2016-11-15 14:15:16 +03:00
ErickSkrauch	58a1c6ec33	Merge branch 'develop'	2016-11-15 13:42:30 +03:00
ErickSkrauch	34179ae1fe	Исправлена опечатка в ссылке на лицо	2016-11-15 13:41:52 +03:00