Add signature to the custom profile property when ?unsigned=false

Introducing profiles endpoint was a mistake, but we had to deal with that mistake until I'll remove it. The Accounts service needs textures with a signature. But it is possible that a user has a fresh account and Chrly has not yet received the profile information. In this case we have no way to get textures for the player. Adding the onUnknownProfileRespondWithUuid parameter solves this problem. This is a bad solution and nobody should use it except Ely.by infrastructure. In v5 version the texture signature on Chrly will be removed.

.dockerignore

@@ -0,0 +1,2 @@
+data
+vendor

.github/workflows/build.yml

@@ -0,0 +1,53 @@
+name: Build
+
+on:
+  push:
+    branches:
+      - '**'
+    tags:
+      - '*.*.*'
+  pull_request:
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    services:
+      redis:
+        image: redis:7-alpine
+        options: >-
+          --health-cmd "redis-cli ping"
+          --health-interval 10s
+          --health-timeout 5s
+          --health-retries 5
+        ports:
+          - 6379:6379
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Setup Go
+        uses: actions/setup-go@v4
+        with:
+          cache-dependency-path: go.sum
+          go-version-file: go.mod
+
+      - name: Install dependencies
+        run: go get .
+
+      - name: Go Format
+        run: gofmt -s -w . && git diff --exit-code
+
+      - name: Go Vet
+        run: go vet ./...
+
+      - name: Go Test
+        run: go test -v -race --tags redis -coverprofile=coverage.txt -covermode=atomic ./...
+
+      - name: Upload coverage to Codecov
+        uses: codecov/codecov-action@v4-beta
+        env:
+          CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
+
+      - name: Build
+        run: go build ./...

.github/workflows/release.yml

@@ -0,0 +1,66 @@
+name: Release
+
+on:
+  workflow_run:
+    workflows:
+      - Build
+    types:
+      - completed
+    branches:
+      - master
+
+jobs:
+  dockerhub:
+    if: ${{ github.event.workflow_run.conclusion == 'success' }}
+
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - id: meta
+        name: Docker meta
+        uses: docker/metadata-action@v5
+        with:
+          images: ${{ github.repository }}
+          tags: |
+            type=semver,pattern={{version}}
+            type=semver,pattern={{major}}.{{minor}}
+            type=semver,pattern={{major}}
+            type=edge,branch=${{ github.event.repository.default_branch }}
+
+      - id: version
+        name: Set up build version
+        run: |
+          if [[ $GITHUB_REF_TYPE == "tag" ]]; then
+            VERSION=${GITHUB_REF#refs/tags/}
+          else
+            BRANCH_NAME=${GITHUB_REF#refs/heads/}
+            SHORT_SHA=$(git rev-parse --short $GITHUB_SHA)
+            VERSION="${BRANCH_NAME}-${SHORT_SHA}"
+          fi
+          echo "### Version: $VERSION" >> $GITHUB_STEP_SUMMARY
+          echo "version=$VERSION" >> "$GITHUB_OUTPUT"
+
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v3
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+
+      - name: Log in to the Container registry
+        uses: docker/login-action@v3
+        with:
+          username: ${{ secrets.DOCKERHUB_USERNAME }}
+          password: ${{ secrets.DOCKERHUB_TOKEN }}
+
+      - name: Build and Push
+        uses: docker/build-push-action@v5
+        with:
+          push: true
+          tags: ${{ steps.meta.outputs.tags }}
+          labels: ${{ steps.meta.outputs.labels }}
+          platforms: linux/amd64,linux/arm64
+          build-args: |
+            VERSION=${{ steps.version.outputs.version }}
+            COMMIT=${{ github.sha }}

.gitignore

@@ -1,2 +1,5 @@
-/.idea
-/awstat
+.idea
+docker-compose.yml
+docker-compose.override.yml
+vendor
+.cover

.htaccess

@@ -1,5 +0,0 @@
-<IfModule mod_rewrite.c>
-	RewriteEngine on
-	RewriteRule  ^$ public/    [L]
-	RewriteRule  (.*) public/$1 [L]
-</IfModule>

CHANGELOG.md

@@ -0,0 +1,196 @@
+# 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
+### Added
+- Allow to remove a skin without removing all user information
+- New StatsD metrics:
+  - Counters:
+    - `ely.skinsystem.{hostname}.app.profiles.request`
+
+### Fixed
+- Adjusted Mojang usernames filter to be stickier according to their docs
+- `/profile/{username}` endpoint now returns the correct signature for the custom property as well.
+
+### Changed
+- Bumped Go version to 1.21.
+
+### Removed
+- Removed mentioning and processing of skin uploading as a file, as this functionality was never implemented and was not planned to be implemented
+- StatsD metrics:
+ - Gauges:
+   - `ely.skinsystem.{hostname}.app.redis.pool.available`
+
+## [4.6.0] - 2021-03-04
+### Added
+- `/profile/{username}` endpoint, which returns a profile and its textures, equivalent of the Mojang's
+  [UUID -> Profile + Skin/Cape endpoint](https://wiki.vg/Mojang_API#UUID_-.3E_Profile_.2B_Skin.2FCape).
+- `/signature-verification-key.der` and `/signature-verification-key.pem` endpoints, which returns the public key in
+  `DER` or `PEM` formats for signature verification.
+
+### Fixed
+- [#28](https://github.com/elyby/chrly/issues/28): Added handling of corrupted data from the Mojang's username to UUID
+  cache.
+- [#29](https://github.com/elyby/chrly/issues/29): If a previously cached UUID no longer exists,
+  it will be invalidated and re-requested.
+- Use correct status code for error about empty response from Mojang's API.
+
+### Changed
+- **BREAKING**: `/cloaks/{username}` and `/textures/{username}` endpoints will no longer return a cape if there are no
+  textures for the requested username.
+- All endpoints are now returns `500` status code when an error occurred during request processing.
+- Increased the response timeout for Mojang's API from 3 to 10 seconds.
+
+## [4.5.0] - 2020-05-01
+### Added
+- [#24](https://github.com/elyby/chrly/issues/24): Implemented a new strategy for the queue in the batch provider of
+  Mojang UUIDs: `full-bus`.
+- New configuration param `QUEUE_STRATEGY` with the default value `periodic`.
+- New configuration params: `MOJANG_API_BASE_URL` and `MOJANG_SESSION_SERVER_BASE_URL`, that allow you to spoof
+  Mojang API base addresses.
+- New health checker, that ensures that response for textures provider from Mojang's API is valid.
+- `dev` Docker images now have the `--cpuprofile` flag, which allows you to run the program with CPU profiling.
+- New StatsD metrics:
+  - Gauges:
+    - `ely.skinsystem.{hostname}.app.redis.pool.available`
+
+### Fixed
+- Handle the case when there is no textures property in Mojang's response.
+- Handle `SIGTERM` as a valid stop signal for a graceful shutdown since it's the default stop code for the Docker.
+- Default connections pool size for Redis.
+
+### Changed
+- `ely.skinsystem.{hostname}.app.mojang_textures.usernames.round_time` timer will not be recorded if the iteration was
+  empty.
+
+## [4.4.1] - 2020-04-24
+### Added
+- [#20](https://github.com/elyby/chrly/issues/20): Print hostname in the `version` command output.
+- [#21](https://github.com/elyby/chrly/issues/21): Print Chrly's version during server startup.
+
+### Fixed
+- [#22](https://github.com/elyby/chrly/issues/22): Correct version passing during building of the Docker image.
+
+## [4.4.0] - 2020-04-22
+### Added
+- Mojang textures queue now can be completely disabled via `MOJANG_TEXTURES_ENABLED` param.
+- Remote mode for Mojang's textures queue with a new configuration params: `MOJANG_TEXTURES_UUIDS_PROVIDER_DRIVER` and
+  `MOJANG_TEXTURES_UUIDS_PROVIDER_URL`.
+
+  For example, to send requests directly to [Mojang's APIs](https://wiki.vg/Mojang_API#Username_-.3E_UUID_at_time),
+  set the next configuration:
+  - `MOJANG_TEXTURES_UUIDS_PROVIDER_DRIVER=remote`
+  - `MOJANG_TEXTURES_UUIDS_PROVIDER_URL=https://api.mojang.com/users/profiles/minecraft/`
+- Implemented worker mode. The app starts with the only one API endpoint: `/api/worker/mojang-uuid/{username}`,
+  which is compatible with [Mojang's endpoint](https://wiki.vg/Mojang_API#Username_-.3E_UUID_at_time) to exchange
+  username to its UUID. It can be used with some load balancing software to increase throughput of Mojang's textures
+  proxy by splitting the load across multiple servers with its own IPs.
+- Textures extra param is now can be configured via `TEXTURES_EXTRA_PARAM_NAME` and `TEXTURES_EXTRA_PARAM_VALUE`.
+- New StatsD metrics:
+  - Counters:
+    - `ely.skinsystem.{hostname}.app.mojang_textures.usernames.textures_hit`
+    - `ely.skinsystem.{hostname}.app.mojang_textures.usernames.textures_miss`
+- All incoming requests are now logging to the console in
+  [Apache Common Log Format](http://httpd.apache.org/docs/2.2/logs.html#common).
+- Added `/healthcheck` endpoint.
+- Graceful server shutdown.
+- Panics in http are now logged in Sentry.
+
+### Fixed
+- `ely.skinsystem.{hostname}.app.mojang_textures.usernames.iteration_size` and
+  `ely.skinsystem.{hostname}.app.mojang_textures.usernames.queue_size` are now updates even if the queue is empty.
+- Don't return an empty object if Mojang's textures don't contain any skin or cape.
+- Provides a correct URL scheme for the cape link.
+
+### Changed
+- **BREAKING**: `QUEUE_LOOP_DELAY` param is now sets as a Go duration, not milliseconds.
+  For example, default value is now `2s500ms`.
+- **BREAKING**: Event `ely.skinsystem.{hostname}.app.mojang_textures.already_in_queue` has been renamed into
+  `ely.skinsystem.{hostname}.app.mojang_textures.already_scheduled`.
+- Bumped Go version to 1.14.
+
+### Removed
+- **BREAKING**: `ely.skinsystem.{hostname}.app.mojang_textures.invalid_username` counter has been removed.
+
+## [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.6.0...HEAD
+[4.6.0]: https://github.com/elyby/chrly/compare/4.5.0...4.6.0
+[4.5.0]: https://github.com/elyby/chrly/compare/4.4.1...4.5.0
+[4.4.1]: https://github.com/elyby/chrly/compare/4.4.0...4.4.1
+[4.4.0]: https://github.com/elyby/chrly/compare/4.3.0...4.4.0
+[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

Dockerfile

@@ -0,0 +1,29 @@
+# syntax=docker/dockerfile:1
+
+FROM golang:1.21-alpine AS builder
+
+ARG VERSION=unversioned
+ARG COMMIT=unspecified
+
+COPY . /build
+WORKDIR /build
+RUN go mod download
+
+RUN CGO_ENABLED=0 \
+    go build \
+    -trimpath \
+    -ldflags "-w -s -X github.com/elyby/chrly/version.version=$VERSION -X github.com/elyby/chrly/version.commit=$COMMIT" \
+    -o chrly \
+    main.go
+
+FROM alpine:3.19
+
+EXPOSE 80
+ENV STORAGE_REDIS_HOST=redis
+ENV STORAGE_FILESYSTEM_HOST=/data
+
+COPY docker-entrypoint.sh /
+COPY --from=builder /build/chrly /usr/local/bin/chrly
+
+ENTRYPOINT ["/docker-entrypoint.sh"]
+CMD ["serve"]

LICENSE

@@ -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 2023 Ely.by (https://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.

README.md

@@ -0,0 +1,501 @@
+# Chrly
+
+[![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)
+
+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` and `CHRLY_SIGNING_KEY`
+environment variables 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
+      CHRLY_SIGNING_KEY: base64:LS0tLS1CRUdJTiBSU0EgUFJJVkFURSBLRVktLS0tLQpNSUlCT3dJQkFBSkJBTmJVcFZDWmtNS3BmdllaMDhXM2x1bWRBYVl4TEJubVVEbHpIQlFIM0RwWWVmNVdDTzMyClREVTZmZUlKNThBMGxBeXdndFo0d3dpMmRHSE96LzFoQXZjQ0F3RUFBUUpBSXRheFNIVGU2UEtieUVVLzlweGoKT05kaFlSWXdWTExvNTZnbk1ZaGt5b0VxYWFNc2ZvdjhoaG9lcGtZWkJNdlpGQjJiRE9zUTJTYUorRTJlaUJPNApBUUloQVBzc1MwK0JSOXcwYk9kbWpHcW1kRTlOck41VUpRY09XMTNzMjkrNlF6VUJBaUVBMnZXT2VwQTVBcGl1CnBFQTNwd29HZGtWQ3JOU25uS2pEUXpEWEJucGQzL2NDSUVGTmQ5c1k0cVVHNEZXZFhONlJubVhMN1NqMHVaZkgKRE13enU4ckVNNXNCQWlFQWh2ZG9ETnFMbWJNZHEzYytGc1BTT2VMMWQyMVpwL0pLOGtiUHRGbUhOZjhDSVFEVgo2RlNaRHd2V2Z1eGFNN0JzeWNRT05rakRCVFBOdStscWN0SkJHbkJ2M0E9PQotLS0tLUVORCBSU0EgUFJJVkFURSBLRVktLS0tLQo=
+
+  redis:
+    image: redis:4.0-32bit
+    restart: always
+    volumes:
+      - ./data/redis:/data
+```
+
+**Tip**: to generate a value for the `CHRLY_SIGNING_KEY` use the command below and then join it with a `base64:` prefix.
+```sh
+openssl genrsa 4096 | base64 -w0
+```
+
+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 `up`
+it again:
+
+```sh
+docker-compose up -d app
+```
+
+**Variables to adjust:**
+
+<table>
+<thead>
+    <tr>
+        <th>ENV</th>
+        <th>Description</th>
+        <th>Example</th>
+    </tr>
+</thead>
+<tbody>
+    <tr>
+        <td>STORAGE_REDIS_HOST</td>
+        <td>
+            By default, Chrly tries to connect to the <code>redis</code> host
+            (by service name in docker-compose configuration).
+        </td>
+        <td><code>localhost</code></td>
+    </tr>
+    <tr>
+        <td>STORAGE_REDIS_PORT</td>
+        <td>
+            Specifies the Redis connection port.
+        </td>
+        <td><code>6379</code></td>
+    </tr>
+    <tr>
+        <td>STORAGE_REDIS_POOL</td>
+        <td>By default, Chrly creates pool with 10 connection, but you may want to increase it</td>
+        <td><code>20</code></td>
+    </tr>
+    <tr>
+        <td>STATSD_ADDR</td>
+        <td>StatsD can be used to collect metrics</td>
+        <td><code>localhost:8125</code></td>
+    </tr>
+    <tr>
+        <td>SENTRY_DSN</td>
+        <td>Sentry can be used to collect app errors</td>
+        <td><code>https://public:private@your.sentry.io/1</code></td>
+    </tr>
+    <tr>
+        <td>QUEUE_STRATEGY</td>
+        <td>
+            Sets the strategy for the queue in the batch provider of Mojang UUIDs. Allowed values are <code>periodic</code>
+            and <code>full-bus</code> (see <a href="https://github.com/elyby/chrly/issues/24">#24</a>).
+        </td>
+        <td><code>periodic</code></td>
+    </tr>
+    <tr>
+        <td>QUEUE_LOOP_DELAY</td>
+        <td>
+            Parameter is sets the delay before each iteration of the Mojang's textures queue
+            (<a href="https://golang.org/pkg/time/#ParseDuration">Go's duration</a>)
+        </td>
+        <td><code>3s200ms</code></td>
+    </tr>
+    <tr>
+        <td>QUEUE_BATCH_SIZE</td>
+        <td>
+            Sets the count of usernames, which will be sent to the
+            <a href="https://wiki.vg/Mojang_API#Playernames_-.3E_UUIDs">Mojang's API to exchange them to their UUIDs</a>.
+            The current limit is <code>10</code>, but it may change in the future, so you may want to adjust it.
+        </td>
+        <td><code>10</code></td>
+    </tr>
+    <tr>
+        <td>MOJANG_TEXTURES_ENABLED</td>
+        <td>
+            Allows to completely disable Mojang textures provider for unknown usernames. Enabled by default.
+        </td>
+        <td><code>true</code></td>
+    </tr>
+    <tr>
+        <td id="remote-mojang-uuids-provider">MOJANG_TEXTURES_UUIDS_PROVIDER_DRIVER</td>
+        <td>
+            Specifies the preferred provider of the Mojang's UUIDs. Takes <code>remote</code> value.
+            In any other case, the local queue will be used.
+        </td>
+        <td><code>remote</code></td>
+    </tr>
+    <tr>
+        <td>MOJANG_TEXTURES_UUIDS_PROVIDER_URL</td>
+        <td>
+            When the UUIDs driver set to <code>remote</code>, sets the remote URL.
+            The trailing slash won't cause any problems.
+        </td>
+        <td><code>http://remote-provider.com/api/worker/mojang-uuid</code></td>
+    </tr>
+    <tr>
+        <td>MOJANG_API_BASE_URL</td>
+        <td>
+            Allows you to spoof the Mojang's API server address.
+        </td>
+        <td><code>https://api.mojang.com</code></td>
+    </tr>
+    <tr>
+        <td>MOJANG_SESSION_SERVER_BASE_URL</td>
+        <td>
+            Allows you to spoof the Mojang's Session server address.
+        </td>
+        <td><code>https://sessionserver.mojang.com</code></td>
+    </tr>
+    <tr>
+        <td>TEXTURES_EXTRA_PARAM_NAME</td>
+        <td>
+            Sets the name of the extra property in the
+            <a href="#get-texturessignedusername">signed textures</a> response.
+        </td>
+        <td><code>your-name</code></td>
+    </tr>
+    <tr>
+        <td>TEXTURES_EXTRA_PARAM_VALUE</td>
+        <td>
+            Sets the value of the extra property in the
+            <a href="#get-texturessignedusername">signed textures</a> response.
+        </td>
+        <td><code>your awesome joke!</code></td>
+    </tr>
+</tbody>
+</table>
+
+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. The `.png` postfix can be omitted.
+
+#### `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 /profile/{username}`
+
+This endpoint behaves exactly like the
+[Mojang's UUID -> Profile + Skin/Cape endpoint](https://wiki.vg/Mojang_API#UUID_-.3E_Profile_.2B_Skin.2FCape), but using
+a username instead of the UUID. Just like in the Mojang's API, you can append `?unsigned=false` part to URL to sign
+the `textures` property. If the textures for the requested username aren't found, it'll request them through the
+Mojang's API, but the Mojang's signature will be discarded and the textures will be re-signed using the signature key
+for your Chrly instance.
+
+Response example:
+
+```json
+{
+    "id": "0f657aa8bfbe415db7005750090d3af3",
+    "name": "username",
+    "properties": [
+        {
+            "name": "textures",
+            "signature": "textures signature value",
+            "value": "base64 encoded value"
+        },
+        {
+            "name": "chrly",
+            "signature": "custom property signature value",
+            "value": "how do you tame a horse in Minecraft?"
+        }
+    ]
+}
+```
+
+The base64 `value` string for the `textures` property decoded:
+
+```json
+{
+    "timestamp": 1614387238630,
+    "profileId": "0f657aa8bfbe415db7005750090d3af3",
+    "profileName": "username",
+    "textures": {
+        "SKIN": {
+            "url": "http://example.com/skin.png"
+        },
+        "CAPE": {
+            "url": "http://example.com/cape.png"
+        }
+    }
+}
+```
+
+If username can't be found locally and can't be obtained from the Mojang's API, empty response with `204` status code
+will be sent.
+
+Note that this endpoint will try to use the UUID for the stored profile in the database. This is an edge case, related
+to the situation where the user is available in the database but has no textures, which caused them to be retrieved
+from the Mojang's API.
+
+#### `GET /signature-verification-key.der`
+
+This endpoint returns a public key that can be used to verify textures signatures. The key is provided in `DER` format,
+so it can be used directly in the Authlib, without modifying the signature checking algorithm.
+
+#### `GET /signature-verification-key.pem`
+
+The same endpoint as the previous one, except that it returns the key in `PEM` format.
+
+#### `GET /textures/signed/{username}`
+
+Actually, this is the [Ely.by](https://ely.by)'s feature called
+[Server Skins System](https://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`
+
+Endpoint allows you to create or update skin record for a username.
+
+The request body must be encoded as `application/x-www-form-urlencoded`.
+
+**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.                                                        |
+
+**Important**: all parameters are always read at least as their default values. So, if you only want to update the username and not pass the skin data it will reset all skin information. If you want to keep the data, you should always pass the full set of parameters.
+
+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"
+}
+```
+
+### Worker mode
+
+The worker mode can be used in cooperation with the [remote server mode](#remote-mojang-uuids-provider)
+to exchange Mojang usernames to UUIDs. This mode by itself doesn't solve the problem of
+[extremely strict limits](https://github.com/elyby/chrly/issues/10) on the number of requests to the Mojang's API.
+But with a proxying load balancer (e.g. HAProxy, Nginx, etc.) it's easy to build a cluster of workers,
+which will multiply the bandwidth of the exchanging usernames to its UUIDs.
+
+The instructions for setting up a proxy load balancer are outside the context of this documentation,
+but you get the idea ;)
+
+#### `GET /api/worker/mojang-uuid/{username}`
+
+Performs [batch usernames exchange to UUIDs](https://github.com/elyby/chrly/issues/1) and returns the result in the
+[same format as it returns from the Mojang's API](https://wiki.vg/Mojang_API#Username_-.3E_UUID_at_time):
+
+```json
+{
+    "id": "3e3ee6c35afa48abb61e8cd8c42fc0d9",
+    "name": "ErickSkrauch"
+}
+```
+
+> **Note**: the results aren't cached.
+
+### Health check
+
+#### `GET /healthcheck`
+
+This endpoint can be used to programmatically check the status of the server.
+If all internal checks are successful, the server will return `200` status code with the following body:
+
+```json
+{
+    "status": "OK"
+}
+```
+
+If any of the checks fails, the server will return `503` status code with the following body:
+
+```json
+{
+    "status": "Service Unavailable",
+    "errors": {
+        "mojang-batch-uuids-provider-queue-length": "the maximum number of tasks in the queue has been exceeded"
+    }
+}
+```
+
+## Development
+
+First of all you should install the [latest stable version of Go](https://golang.org/doc/install) and set `GOPATH`
+environment variable.
+
+Then you must fork this repository. Now follow these steps:
+
+```sh
+# Get the source code
+git clone https://github.com/elyby/chrly.git
+# Switch to the project folder
+cd chrly
+# Install dependencies
+go mod download
+# 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`.
+
+After all of that `go run main.go serve` should successfully start the application.
+To run tests execute `go test ./...`.
+
+[ico-lang]: https://img.shields.io/github/go-mod/go-version/elyby/chrly?style=flat-square
+[ico-build]: https://img.shields.io/github/actions/workflow/status/elyby/chrly/build.yml?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://github.com/elyby/chrly/actions
+[link-coverage]: https://codecov.io/gh/elyby/chrly

api/mojang/mojang.go

@@ -0,0 +1,225 @@
+package mojang
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"io/ioutil"
+	"net/http"
+	"strings"
+	"sync"
+	"time"
+)
+
+var HttpClient = &http.Client{
+	Timeout: 10 * time.Second,
+	Transport: &http.Transport{
+		MaxIdleConnsPerHost: 1024,
+	},
+}
+
+type SignedTexturesResponse struct {
+	Id    string      `json:"id"`
+	Name  string      `json:"name"`
+	Props []*Property `json:"properties"`
+
+	once            sync.Once
+	decodedTextures *TexturesProp
+	decodedErr      error
+}
+
+func (t *SignedTexturesResponse) DecodeTextures() (*TexturesProp, error) {
+	t.once.Do(func() {
+		var texturesProp string
+		for _, prop := range t.Props {
+			if prop.Name == "textures" {
+				texturesProp = prop.Value
+				break
+			}
+		}
+
+		if texturesProp == "" {
+			return
+		}
+
+		decodedTextures, err := DecodeTextures(texturesProp)
+		if err != nil {
+			t.decodedErr = err
+		} else {
+			t.decodedTextures = decodedTextures
+		}
+	})
+
+	return t.decodedTextures, t.decodedErr
+}
+
+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"`
+}
+
+var ApiMojangDotComAddr = "https://api.mojang.com"
+var SessionServerMojangComAddr = "https://sessionserver.mojang.com"
+
+// 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, err := http.NewRequest("POST", ApiMojangDotComAddr+"/profiles/minecraft", bytes.NewBuffer(requestBody))
+	if err != nil {
+		return nil, err
+	}
+
+	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) {
+	normalizedUuid := strings.ReplaceAll(uuid, "-", "")
+	url := SessionServerMojangComAddr + "/session/minecraft/profile/" + normalizedUuid
+	if signed {
+		url += "?unsigned=false"
+	}
+
+	request, err := http.NewRequest("GET", url, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	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 "204: 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 fmt.Sprintf("400 %s: %s", e.ErrorType, 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 "403: Forbidden"
+}
+
+// When you exceed the set limit of requests, this error will be returned
+type TooManyRequestsError struct {
+	ResponseError
+}
+
+func (*TooManyRequestsError) Error() string {
+	return "429: 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 fmt.Sprintf("%d: %s", e.Status, "Server error")
+}
+
+func (*ServerError) IsMojangError() bool {
+	return true
+}

api/mojang/mojang_test.go

@@ -0,0 +1,313 @@
+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, err := obj.DecodeTextures()
+		testify.Nil(t, err)
+		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, err := obj.DecodeTextures()
+		testify.Nil(t, err)
+		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, "400 IllegalArgumentException: 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, "403: 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, "429: 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, "500: 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 with dashed uuid", 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("4566e69f-c907-48ee-8d71-d7ba5aa00d20", 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, "204: 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, "429: 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, "500: Server error")
+		assert.Equal(500, err.(*ServerError).Status)
+		assert.Implements((*ResponseError)(nil), err)
+	})
+}

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)
+}

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)
+		})
+	}
+}

app.php

@@ -1,98 +0,0 @@
-<?php
-
-define('ENCODING', 'UTF-8');
-
-$app->get('/skins/{nickname}', function ($nickname) use ($app) {
-    // $systemVersion = $app->request->get('version', 'int');
-    // $minecraftVersion = $app->request->get('minecraft_version', 'string');
-
-    // На всякий случай проверка на наличие .png для файла
-    if (strrpos($nickname, '.png') != -1) {
-        $nickname = explode('.', $nickname)[0];
-    }
-
-    // TODO: восстановить функцию деградации скинов
-
-    $skin = Skins::findByNickname($nickname);
-    if (!$skin || $skin->skinId == 0) {
-        return $app->response->redirect('http://skins.minecraft.net/MinecraftSkins/' . $nickname . '.png', true);
-    }
-
-    return $app->response->redirect($skin->url);
-})->setName('skinSystem');
-
-$app->get('/cloaks/{nickname}', function ($nickname) use ($app) {
-    // На всякий случай проверка на наличие .png для файла
-    if (strrpos($nickname, '.png') != -1) {
-        $nickname = explode('.', $nickname)[0];
-    }
-
-    return $app->response->redirect('http://skins.minecraft.net/MinecraftCloaks/'.$nickname.'.png');
-});
-
-$app->get('/textures/{nickname}', function($nickname) use ($app) {
-    $skin = Skins::findByNickname($nickname);
-    if ($skin && $skin->skinId != 0) {
-        $url = $skin->url;
-        $hash = $skin->hash;
-    } else {
-        $url = 'http://skins.minecraft.net/MinecraftSkins/'.$nickname.'.png';
-        $hash = md5('non-ely-' . mktime(date('H'), 0, 0) . '-' . $nickname);
-    }
-
-    // TODO: в authserver.ely.by есть готовый класс для работы с форматом текстур. Так что если мы его вынесем в
-    // common library, то нужно будет заменить его здесь
-
-    $textures = [
-        'SKIN' => [
-            'url' => $url,
-            'hash' => $hash,
-        ],
-    ];
-
-    $capePath = __DIR__ . '/cloaks/' . $nickname . '.png';
-    if (file_exists($capePath)) {
-        $textures['CAPE'] = [
-            'url' => '/cloaks/' . mb_convert_case($nickname, MB_CASE_LOWER) . '.png',
-            'hash' => md5_file($capePath),
-        ];
-    }
-
-    if ($skin && $skin->isSlim) {
-        $textures['SKIN']['metadata']['model'] = 'slim';
-    }
-
-    return $app->response->setContentType('application/json')->setJsonContent($textures);
-});
-
-$app->post('/system/setSkin', function() use ($app) {
-    $headers = getallheaders();
-    if (!array_key_exists('X-Ely-key', $headers) || $headers['X-Ely-key'] != '43fd2ce61b3f5704dfd729c1f2d6ffdb') {
-        return $app->response->setStatusCode(403, 'Forbidden')->setContent('Хорошая попытка, мерзкий хакер.');
-    }
-
-    $request = $app->request;
-    $nickname = mb_convert_case($request->getPost('nickname', 'string'), MB_CASE_LOWER, ENCODING);
-
-    $skin = Skins::findByNickname($nickname);
-    if (!$skin) {
-        $skin = new Skins();
-        $skin->nickname = $nickname;
-    }
-
-    $skin->userId =  (int) $request->getPost('userId', 'int');
-    $skin->skinId = (int) $request->getPost('skinId', 'int');
-    $skin->hash = $request->getPost('hash', 'string');
-    $skin->is1_8 = (bool) $request->getPost('is1_8', 'int');
-    $skin->isSlim = (bool) $request->getPost('isSlim', 'int');
-    $skin->url = $request->getPost('url', 'string');
-
-    return $app->response->setContent($skin->save() ? 'OK' : 'ERROR');
-});
-
-$app->notFound(function () use ($app) {
-    $app->response
-        ->setStatusCode(404, 'Not Found')
-        ->setContent('Not Found<br /> <a href="http://ely.by">Система скинов Ely.by</a>.')
-        ->send();
-});

cmd/root.go

@@ -0,0 +1,67 @@
+package cmd
+
+import (
+	"fmt"
+	"log"
+	"os"
+	"strings"
+
+	. "github.com/defval/di"
+	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
+
+	"github.com/elyby/chrly/di"
+	"github.com/elyby/chrly/http"
+	"github.com/elyby/chrly/version"
+)
+
+var RootCmd = &cobra.Command{
+	Use:     "chrly",
+	Short:   "Implementation of Minecraft skins system server",
+	Version: version.Version(),
+}
+
+// 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 shouldGetContainer() *Container {
+	container, err := di.New()
+	if err != nil {
+		panic(err)
+	}
+
+	return container
+}
+
+func startServer(modules []string) {
+	container := shouldGetContainer()
+
+	var config *viper.Viper
+	err := container.Resolve(&config)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	config.Set("modules", modules)
+
+	err = container.Invoke(http.StartServer)
+	if err != nil {
+		log.Fatal(err)
+	}
+}
+
+func init() {
+	cobra.OnInitialize(initConfig)
+}
+
+func initConfig() {
+	viper.AutomaticEnv()
+	replacer := strings.NewReplacer(".", "_")
+	viper.SetEnvKeyReplacer(replacer)
+}

cmd/root_profiling.go

@@ -0,0 +1,56 @@
+//go:build profiling
+// +build profiling
+
+package cmd
+
+import (
+	"log"
+	"os"
+	"runtime/pprof"
+
+	"github.com/spf13/cobra"
+)
+
+func init() {
+	var profilePath string
+	RootCmd.PersistentFlags().StringVar(&profilePath, "cpuprofile", "", "enables pprof profiling and sets its output path")
+
+	pprofEnabled := false
+	originalPersistentPreRunE := RootCmd.PersistentPreRunE
+	RootCmd.PersistentPreRunE = func(cmd *cobra.Command, args []string) error {
+		if profilePath == "" {
+			return nil
+		}
+
+		f, err := os.Create(profilePath)
+		if err != nil {
+			return err
+		}
+
+		log.Println("enabling profiling")
+		err = pprof.StartCPUProfile(f)
+		if err != nil {
+			return err
+		}
+
+		pprofEnabled = true
+
+		if originalPersistentPreRunE != nil {
+			return originalPersistentPreRunE(cmd, args)
+		}
+
+		return nil
+	}
+
+	originalPersistentPostRun := RootCmd.PersistentPreRun
+	RootCmd.PersistentPostRun = func(cmd *cobra.Command, args []string) {
+		if pprofEnabled {
+			log.Println("shutting down profiling")
+			pprof.StopCPUProfile()
+		}
+
+		if originalPersistentPostRun != nil {
+			originalPersistentPostRun(cmd, args)
+		}
+	}
+}

cmd/serve.go

@@ -0,0 +1,17 @@
+package cmd
+
+import (
+	"github.com/spf13/cobra"
+)
+
+var serveCmd = &cobra.Command{
+	Use:   "serve",
+	Short: "Starts HTTP handler for the skins system",
+	Run: func(cmd *cobra.Command, args []string) {
+		startServer([]string{"skinsystem", "api"})
+	},
+}
+
+func init() {
+	RootCmd.AddCommand(serveCmd)
+}

cmd/token.go

@@ -0,0 +1,34 @@
+package cmd
+
+import (
+	"fmt"
+	"log"
+
+	"github.com/elyby/chrly/http"
+
+	"github.com/spf13/cobra"
+)
+
+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) {
+		container := shouldGetContainer()
+		var auth *http.JwtAuth
+		err := container.Resolve(&auth)
+		if err != nil {
+			log.Fatal(err)
+		}
+
+		token, err := auth.NewToken(http.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)
+}

cmd/version.go

@@ -0,0 +1,32 @@
+package cmd
+
+import (
+	"fmt"
+	"os"
+	"runtime"
+
+	"github.com/spf13/cobra"
+
+	"github.com/elyby/chrly/version"
+)
+
+var versionCmd = &cobra.Command{
+	Use:   "version",
+	Short: "Show the Chrly version information",
+	Run: func(cmd *cobra.Command, args []string) {
+		hostname, err := os.Hostname()
+		if err != nil {
+			hostname = "<unknown>"
+		}
+
+		fmt.Printf("Version:    %s\n", version.Version())
+		fmt.Printf("Commit:     %s\n", version.Commit())
+		fmt.Printf("Go version: %s\n", runtime.Version())
+		fmt.Printf("OS/Arch:    %s/%s\n", runtime.GOOS, runtime.GOARCH)
+		fmt.Printf("Hostname:   %s\n", hostname)
+	},
+}
+
+func init() {
+	RootCmd.AddCommand(versionCmd)
+}

cmd/worker.go

@@ -0,0 +1,17 @@
+package cmd
+
+import (
+	"github.com/spf13/cobra"
+)
+
+var workerCmd = &cobra.Command{
+	Use:   "worker",
+	Short: "Starts HTTP handler for the Mojang usernames to UUIDs worker",
+	Run: func(cmd *cobra.Command, args []string) {
+		startServer([]string{"worker"})
+	},
+}
+
+func init() {
+	RootCmd.AddCommand(workerCmd)
+}

config/config.php

@@ -1,15 +0,0 @@
-<?php
-
-return new \Phalcon\Config([
-    'mongo' => [
-        'host'     => 'localhost',
-        'port'     => 27017,
-        'username' => '',
-        'password' => '',
-        'dbname'   => 'ely_skins',
-    ],
-    'application' => [
-        'modelsDir' => __DIR__ . '/../models/',
-        'baseUri'   => '/',
-    ]
-]);

config/loader.php

@@ -1,12 +0,0 @@
-<?php
-/**
- * @var \Phalcon\Config $config
- */
-
-$loader = new \Phalcon\Loader();
-
-$loader->registerDirs(array(
-    $config->application->modelsDir
-));
-
-$loader->register();

config/services.php

@@ -1,46 +0,0 @@
-<?php
-/**
- * @var \Phalcon\Config $config
- */
-
-use Phalcon\Mvc\Collection\Manager;
-use Phalcon\Mvc\View;
-use Phalcon\Mvc\Url as UrlResolver;
-use Phalcon\DI\FactoryDefault;
-
-$di = new FactoryDefault();
-
-$di->set('view', function () {
-    $view = new View();
-    $view->disable();
-
-    return $view;
-});
-
-/**
- * The URL component is used to generate all kind of urls in the application
- */
-$di->set('url', function () use ($config) {
-    $url = new UrlResolver();
-    $url->setBaseUri($config->application->baseUri);
-
-    return $url;
-});
-
-$di->set('mongo', function() use ($config) {
-    /** @var StdClass $mongoConfig */
-    $mongoConfig = $config->mongo;
-    $connectionString = 'mongodb://';
-    if ($mongoConfig->username && $mongoConfig->password) {
-        $connectionString .= "{$mongoConfig->username}:{$mongoConfig->password}@";
-    }
-
-    $connectionString .= $mongoConfig->host . ':' . $mongoConfig->port;
-    $mongo = new MongoClient($connectionString);
-
-    return $mongo->selectDb($mongoConfig->dbname);
-});
-
-$di->setShared('collectionManager', function() {
-    return new Manager();
-});

data/redis/.gitignore

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

db/fs/fs.go

@@ -0,0 +1,33 @@
+package fs
+
+import (
+	"os"
+	"path"
+	"strings"
+
+	"github.com/elyby/chrly/model"
+)
+
+func New(basePath string) (*Filesystem, error) {
+	return &Filesystem{path: basePath}, nil
+}
+
+type Filesystem struct {
+	path string
+}
+
+func (f *Filesystem) FindCapeByUsername(username string) (*model.Cape, error) {
+	capePath := path.Join(f.path, strings.ToLower(username)+".png")
+	file, err := os.Open(capePath)
+	if err != nil {
+		if os.IsNotExist(err) {
+			return nil, nil
+		}
+
+		return nil, err
+	}
+
+	return &model.Cape{
+		File: file,
+	}, nil
+}

db/fs/fs_integration_test.go

@@ -0,0 +1,56 @@
+package fs
+
+import (
+	"fmt"
+	"io/ioutil"
+	"os"
+	"path"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestNew(t *testing.T) {
+	fs, err := New("base/path")
+	require.Nil(t, err)
+	require.Equal(t, "base/path", fs.path)
+}
+
+func TestFilesystem(t *testing.T) {
+	t.Run("FindCapeByUsername", func(t *testing.T) {
+		dir, err := ioutil.TempDir("", "capes")
+		if err != nil {
+			panic(fmt.Errorf("cannot crete temp directory for tests: %w", err))
+		}
+		defer os.RemoveAll(dir)
+
+		t.Run("exists cape", func(t *testing.T) {
+			file, err := os.Create(path.Join(dir, "username.png"))
+			if err != nil {
+				panic(fmt.Errorf("cannot create temp skin for tests: %w", err))
+			}
+			defer os.Remove(file.Name())
+
+			fs, _ := New(dir)
+			cape, err := fs.FindCapeByUsername("username")
+			require.Nil(t, err)
+			require.NotNil(t, cape)
+			capeFile, _ := cape.File.(*os.File)
+			require.Equal(t, file.Name(), capeFile.Name())
+		})
+
+		t.Run("not exists cape", func(t *testing.T) {
+			fs, _ := New(dir)
+			cape, err := fs.FindCapeByUsername("username")
+			require.Nil(t, err)
+			require.Nil(t, cape)
+		})
+
+		t.Run("empty username", func(t *testing.T) {
+			fs, _ := New(dir)
+			cape, err := fs.FindCapeByUsername("")
+			require.Nil(t, err)
+			require.Nil(t, cape)
+		})
+	})
+}

db/redis/redis.go

@@ -0,0 +1,315 @@
+package redis
+
+import (
+	"bytes"
+	"compress/zlib"
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/mediocregopher/radix/v4"
+
+	"github.com/elyby/chrly/model"
+)
+
+var now = time.Now
+
+func New(ctx context.Context, addr string, poolSize int) (*Redis, error) {
+	client, err := (radix.PoolConfig{Size: poolSize}).New(ctx, "tcp", addr)
+	if err != nil {
+		return nil, err
+	}
+
+	return &Redis{
+		client:  client,
+		context: ctx,
+	}, nil
+}
+
+const accountIdToUsernameKey = "hash:username-to-account-id" // TODO: this should be actually "hash:user-id-to-username"
+const mojangUsernameToUuidKey = "hash:mojang-username-to-uuid"
+
+type Redis struct {
+	client  radix.Client
+	context context.Context
+}
+
+func (db *Redis) FindSkinByUsername(username string) (*model.Skin, error) {
+	var skin *model.Skin
+	err := db.client.Do(db.context, radix.WithConn("", func(ctx context.Context, conn radix.Conn) error {
+		var err error
+		skin, err = findByUsername(ctx, conn, username)
+
+		return err
+	}))
+
+	return skin, err
+}
+
+func findByUsername(ctx context.Context, conn radix.Conn, username string) (*model.Skin, error) {
+	redisKey := buildUsernameKey(username)
+	var encodedResult []byte
+	err := conn.Do(ctx, radix.Cmd(&encodedResult, "GET", redisKey))
+	if err != nil {
+		return nil, err
+	}
+
+	if len(encodedResult) == 0 {
+		return nil, nil
+	}
+
+	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
+	}
+
+	// Some old data causing issues in the production.
+	// TODO: remove after investigation will be finished
+	if skin.Uuid == "" {
+		return nil, nil
+	}
+
+	skin.OldUsername = skin.Username
+
+	return skin, nil
+}
+
+func (db *Redis) FindSkinByUserId(id int) (*model.Skin, error) {
+	var skin *model.Skin
+	err := db.client.Do(db.context, radix.WithConn("", func(ctx context.Context, conn radix.Conn) error {
+		var err error
+		skin, err = findByUserId(ctx, conn, id)
+
+		return err
+	}))
+
+	return skin, err
+}
+
+func findByUserId(ctx context.Context, conn radix.Conn, id int) (*model.Skin, error) {
+	var username string
+	err := conn.Do(ctx, radix.FlatCmd(&username, "HGET", accountIdToUsernameKey, id))
+	if err != nil {
+		return nil, err
+	}
+
+	if username == "" {
+		return nil, nil
+	}
+
+	return findByUsername(ctx, conn, username)
+}
+
+func (db *Redis) SaveSkin(skin *model.Skin) error {
+	return db.client.Do(db.context, radix.WithConn("", func(ctx context.Context, conn radix.Conn) error {
+		return save(ctx, conn, skin)
+	}))
+}
+
+func save(ctx context.Context, conn radix.Conn, skin *model.Skin) error {
+	err := conn.Do(ctx, radix.Cmd(nil, "MULTI"))
+	if err != nil {
+		return err
+	}
+
+	// If user has changed username, then we must delete his old username record
+	if skin.OldUsername != "" && skin.OldUsername != skin.Username {
+		err = conn.Do(ctx, radix.Cmd(nil, "DEL", buildUsernameKey(skin.OldUsername)))
+		if err != nil {
+			return err
+		}
+	}
+
+	// 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 {
+		err = conn.Do(ctx, radix.FlatCmd(nil, "HSET", accountIdToUsernameKey, skin.UserId, skin.Username))
+	}
+
+	str, _ := json.Marshal(skin)
+	err = conn.Do(ctx, radix.FlatCmd(nil, "SET", buildUsernameKey(skin.Username), zlibEncode(str)))
+	if err != nil {
+		return err
+	}
+
+	err = conn.Do(ctx, radix.Cmd(nil, "EXEC"))
+	if err != nil {
+		return err
+	}
+
+	skin.OldUsername = skin.Username
+
+	return nil
+}
+
+func (db *Redis) RemoveSkinByUserId(id int) error {
+	return db.client.Do(db.context, radix.WithConn("", func(ctx context.Context, conn radix.Conn) error {
+		return removeByUserId(ctx, conn, id)
+	}))
+}
+
+func removeByUserId(ctx context.Context, conn radix.Conn, id int) error {
+	record, err := findByUserId(ctx, conn, id)
+	if err != nil {
+		return err
+	}
+
+	err = conn.Do(ctx, radix.Cmd(nil, "MULTI"))
+	if err != nil {
+		return err
+	}
+
+	err = conn.Do(ctx, radix.FlatCmd(nil, "HDEL", accountIdToUsernameKey, id))
+	if err != nil {
+		return err
+	}
+
+	if record != nil {
+		err = conn.Do(ctx, radix.Cmd(nil, "DEL", buildUsernameKey(record.Username)))
+		if err != nil {
+			return err
+		}
+	}
+
+	return conn.Do(ctx, radix.Cmd(nil, "EXEC"))
+}
+
+func (db *Redis) RemoveSkinByUsername(username string) error {
+	return db.client.Do(db.context, radix.WithConn("", func(ctx context.Context, conn radix.Conn) error {
+		return removeByUsername(ctx, conn, username)
+	}))
+}
+
+func removeByUsername(ctx context.Context, conn radix.Conn, username string) error {
+	record, err := findByUsername(ctx, conn, username)
+	if err != nil {
+		return err
+	}
+
+	if record == nil {
+		return nil
+	}
+
+	err = conn.Do(ctx, radix.Cmd(nil, "MULTI"))
+	if err != nil {
+		return err
+	}
+
+	err = conn.Do(ctx, radix.Cmd(nil, "DEL", buildUsernameKey(record.Username)))
+	if err != nil {
+		return err
+	}
+
+	err = conn.Do(ctx, radix.FlatCmd(nil, "HDEL", accountIdToUsernameKey, record.UserId))
+	if err != nil {
+		return err
+	}
+
+	return conn.Do(ctx, radix.Cmd(nil, "EXEC"))
+}
+
+func (db *Redis) GetUuid(username string) (string, bool, error) {
+	var uuid string
+	var found bool
+	err := db.client.Do(db.context, radix.WithConn("", func(ctx context.Context, conn radix.Conn) error {
+		var err error
+		uuid, found, err = findMojangUuidByUsername(ctx, conn, username)
+
+		return err
+	}))
+
+	return uuid, found, err
+}
+
+func findMojangUuidByUsername(ctx context.Context, conn radix.Conn, username string) (string, bool, error) {
+	key := strings.ToLower(username)
+	var result string
+	err := conn.Do(ctx, radix.Cmd(&result, "HGET", mojangUsernameToUuidKey, key))
+	if err != nil {
+		return "", false, err
+	}
+
+	if result == "" {
+		return "", false, nil
+	}
+
+	parts := strings.Split(result, ":")
+	// https://github.com/elyby/chrly/issues/28
+	if len(parts) < 2 {
+		err = conn.Do(ctx, radix.Cmd(nil, "HDEL", mojangUsernameToUuidKey, key))
+		if err != nil {
+			return "", false, err
+		}
+
+		return "", false, fmt.Errorf("got unexpected response from the mojangUsernameToUuid hash: \"%s\"", result)
+	}
+
+	timestamp, _ := strconv.ParseInt(parts[1], 10, 64)
+	storedAt := time.Unix(timestamp, 0)
+	if storedAt.Add(time.Hour * 24 * 30).Before(now()) {
+		err = conn.Do(ctx, radix.Cmd(nil, "HDEL", mojangUsernameToUuidKey, key))
+		if err != nil {
+			return "", false, err
+		}
+
+		return "", false, nil
+	}
+
+	return parts[0], true, nil
+}
+
+func (db *Redis) StoreUuid(username string, uuid string) error {
+	return db.client.Do(db.context, radix.WithConn("", func(ctx context.Context, conn radix.Conn) error {
+		return storeMojangUuid(ctx, conn, username, uuid)
+	}))
+}
+
+func storeMojangUuid(ctx context.Context, conn radix.Conn, username string, uuid string) error {
+	value := uuid + ":" + strconv.FormatInt(now().Unix(), 10)
+	err := conn.Do(ctx, radix.Cmd(nil, "HSET", mojangUsernameToUuidKey, strings.ToLower(username), value))
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (db *Redis) Ping() error {
+	return db.client.Do(db.context, radix.Cmd(nil, "PING"))
+}
+
+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, err := zlib.NewReader(buff)
+	if err != nil {
+		return nil, err
+	}
+
+	resultBuffer := new(bytes.Buffer)
+	_, _ = io.Copy(resultBuffer, reader)
+	_ = reader.Close()
+
+	return resultBuffer.Bytes(), nil
+}

db/redis/redis_integration_test.go

@@ -0,0 +1,425 @@
+//go:build redis
+
+package redis
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"strconv"
+	"testing"
+	"time"
+
+	"github.com/mediocregopher/radix/v4"
+	assert "github.com/stretchr/testify/require"
+	"github.com/stretchr/testify/suite"
+
+	"github.com/elyby/chrly/model"
+)
+
+var redisAddr string
+
+func init() {
+	host := "localhost"
+	port := 6379
+	if os.Getenv("STORAGE_REDIS_HOST") != "" {
+		host = os.Getenv("STORAGE_REDIS_HOST")
+	}
+
+	if os.Getenv("STORAGE_REDIS_PORT") != "" {
+		port, _ = strconv.Atoi(os.Getenv("STORAGE_REDIS_PORT"))
+	}
+
+	redisAddr = fmt.Sprintf("%s:%d", host, port)
+}
+
+func TestNew(t *testing.T) {
+	t.Run("should connect", func(t *testing.T) {
+		conn, err := New(context.Background(), redisAddr, 12)
+		assert.Nil(t, err)
+		assert.NotNil(t, conn)
+	})
+
+	t.Run("should return error", func(t *testing.T) {
+		conn, err := New(context.Background(), "localhost:12345", 12) // Use localhost to avoid DNS resolution
+		assert.Error(t, err)
+		assert.Nil(t, conn)
+	})
+}
+
+type redisTestSuite struct {
+	suite.Suite
+
+	Redis *Redis
+
+	cmd func(cmd string, args ...interface{}) string
+}
+
+func (suite *redisTestSuite) SetupSuite() {
+	ctx := context.Background()
+	conn, err := New(ctx, redisAddr, 10)
+	if err != nil {
+		panic(fmt.Errorf("cannot establish connection to redis: %w", err))
+	}
+
+	suite.Redis = conn
+	suite.cmd = func(cmd string, args ...interface{}) string {
+		var result string
+		err := suite.Redis.client.Do(ctx, radix.FlatCmd(&result, cmd, args...))
+		if err != nil {
+			panic(err)
+		}
+
+		return result
+	}
+}
+
+func (suite *redisTestSuite) SetupTest() {
+	// Cleanup database before each test
+	suite.cmd("FLUSHALL")
+}
+
+func (suite *redisTestSuite) TearDownTest() {
+	// Restore time.Now func
+	now = time.Now
+}
+
+func (suite *redisTestSuite) RunSubTest(name string, subTest func()) {
+	suite.SetupTest()
+	suite.Run(name, subTest)
+}
+
+func TestRedis(t *testing.T) {
+	suite.Run(t, new(redisTestSuite))
+}
+
+/**
+ * JSON with zlib encoding
+ * {
+ *     userId: 1,
+ *     uuid: "fd5da1e4d66d4d17aadee2446093896d",
+ *     username: "Mock",
+ *     skinId: 1,
+ *     url: "http://localhost/skin.png",
+ *     is1_8: true,
+ *     isSlim: false,
+ *     mojangTextures: "mock-mojang-textures",
+ *     mojangSignature: "mock-mojang-signature"
+ * }
+ */
+var skinRecord = string([]byte{
+	0x78, 0x9c, 0x5c, 0xce, 0x4b, 0x4a, 0x4, 0x41, 0xc, 0xc6, 0xf1, 0xbb, 0x7c, 0xeb, 0x1a, 0xdb, 0xd6, 0xb2,
+	0x9c, 0xc9, 0xd, 0x5c, 0x88, 0x8b, 0xd1, 0xb5, 0x84, 0x4e, 0xa6, 0xa7, 0xec, 0x7a, 0xc, 0xf5, 0x0, 0x41,
+	0xbc, 0xbb, 0xb4, 0xd2, 0xa, 0x2e, 0xf3, 0xe3, 0x9f, 0x90, 0xf, 0xf4, 0xaa, 0xe5, 0x41, 0x40, 0xa3, 0x41,
+	0xef, 0x5e, 0x40, 0x38, 0xc9, 0x9d, 0xf0, 0xa8, 0x56, 0x9c, 0x13, 0x2b, 0xe3, 0x3d, 0xb3, 0xa8, 0xde, 0x58,
+	0xeb, 0xae, 0xf, 0xb7, 0xfb, 0x83, 0x13, 0x98, 0xef, 0xa5, 0xc4, 0x51, 0x41, 0x78, 0xcc, 0xd3, 0x2, 0x83,
+	0xba, 0xf8, 0xb4, 0x9d, 0x29, 0x1, 0x84, 0x73, 0x6b, 0x17, 0x1a, 0x86, 0x90, 0x27, 0xe, 0xe7, 0x5c, 0xdb,
+	0xb0, 0x16, 0x57, 0x97, 0x34, 0xc3, 0xc0, 0xd7, 0xf1, 0x75, 0xf, 0x6a, 0xa5, 0xeb, 0x3a, 0x1c, 0x83, 0x8f,
+	0xa0, 0x13, 0x87, 0xaa, 0x6, 0x31, 0xbf, 0x71, 0x9a, 0x9f, 0xf5, 0xbd, 0xf5, 0xa2, 0x15, 0x84, 0x98, 0xa7,
+	0x65, 0xf7, 0xa3, 0xbb, 0xb6, 0xf1, 0xd6, 0x1d, 0xfd, 0x9c, 0x78, 0xa5, 0x7f, 0x61, 0xfd, 0x75, 0x83, 0xa7,
+	0x20, 0x2f, 0x7f, 0xff, 0xe2, 0xf3, 0x2b, 0x0, 0x0, 0xff, 0xff, 0x6f, 0xdd, 0x51, 0x71,
+})
+
+func (suite *redisTestSuite) TestFindSkinByUsername() {
+	suite.RunSubTest("exists record", func() {
+		suite.cmd("SET", "username:mock", skinRecord)
+
+		skin, err := suite.Redis.FindSkinByUsername("Mock")
+		suite.Require().Nil(err)
+		suite.Require().NotNil(skin)
+		suite.Require().Equal(1, skin.UserId)
+		suite.Require().Equal("fd5da1e4d66d4d17aadee2446093896d", skin.Uuid)
+		suite.Require().Equal("Mock", skin.Username)
+		suite.Require().Equal(1, skin.SkinId)
+		suite.Require().Equal("http://localhost/skin.png", skin.Url)
+		suite.Require().True(skin.Is1_8)
+		suite.Require().False(skin.IsSlim)
+		suite.Require().Equal("mock-mojang-textures", skin.MojangTextures)
+		suite.Require().Equal("mock-mojang-signature", skin.MojangSignature)
+		suite.Require().Equal(skin.Username, skin.OldUsername)
+	})
+
+	suite.RunSubTest("not exists record", func() {
+		skin, err := suite.Redis.FindSkinByUsername("Mock")
+		suite.Require().Nil(err)
+		suite.Require().Nil(skin)
+	})
+
+	suite.RunSubTest("invalid zlib encoding", func() {
+		suite.cmd("SET", "username:mock", "this is really not zlib")
+		skin, err := suite.Redis.FindSkinByUsername("Mock")
+		suite.Require().Nil(skin)
+		suite.Require().EqualError(err, "zlib: invalid header")
+	})
+
+	suite.RunSubTest("invalid json encoding", func() {
+		suite.cmd("SET", "username:mock", []byte{
+			0x78, 0x9c, 0xca, 0x48, 0xcd, 0xc9, 0xc9, 0x57, 0x28, 0xcf, 0x2f, 0xca, 0x49, 0x1, 0x4, 0x0, 0x0, 0xff,
+			0xff, 0x1a, 0xb, 0x4, 0x5d,
+		})
+		skin, err := suite.Redis.FindSkinByUsername("Mock")
+		suite.Require().Nil(skin)
+		suite.Require().EqualError(err, "invalid character 'h' looking for beginning of value")
+	})
+}
+
+func (suite *redisTestSuite) TestFindSkinByUserId() {
+	suite.RunSubTest("exists record", func() {
+		suite.cmd("SET", "username:mock", skinRecord)
+		suite.cmd("HSET", "hash:username-to-account-id", 1, "Mock")
+
+		skin, err := suite.Redis.FindSkinByUserId(1)
+		suite.Require().Nil(err)
+		suite.Require().NotNil(skin)
+		suite.Require().Equal(1, skin.UserId)
+	})
+
+	suite.RunSubTest("not exists record", func() {
+		skin, err := suite.Redis.FindSkinByUserId(1)
+		suite.Require().Nil(err)
+		suite.Require().Nil(skin)
+	})
+
+	suite.RunSubTest("exists hash record, but no skin record", func() {
+		suite.cmd("HSET", "hash:username-to-account-id", 1, "Mock")
+		skin, err := suite.Redis.FindSkinByUserId(1)
+		suite.Require().Nil(err)
+		suite.Require().Nil(skin)
+	})
+}
+
+func (suite *redisTestSuite) TestSaveSkin() {
+	suite.RunSubTest("save new entity", func() {
+		err := suite.Redis.SaveSkin(&model.Skin{
+			UserId:          1,
+			Uuid:            "fd5da1e4d66d4d17aadee2446093896d",
+			Username:        "Mock",
+			SkinId:          1,
+			Url:             "http://localhost/skin.png",
+			Is1_8:           true,
+			IsSlim:          false,
+			MojangTextures:  "mock-mojang-textures",
+			MojangSignature: "mock-mojang-signature",
+		})
+		suite.Require().Nil(err)
+
+		usernameResp := suite.cmd("GET", "username:mock")
+		suite.Require().NotEmpty(usernameResp)
+		suite.Require().Equal(skinRecord, usernameResp)
+
+		idResp := suite.cmd("HGET", "hash:username-to-account-id", 1)
+		suite.Require().Equal("Mock", idResp)
+	})
+
+	suite.RunSubTest("save exists record with changed username", func() {
+		suite.cmd("SET", "username:mock", skinRecord)
+		suite.cmd("HSET", "hash:username-to-account-id", 1, "Mock")
+
+		err := suite.Redis.SaveSkin(&model.Skin{
+			UserId:          1,
+			Uuid:            "fd5da1e4d66d4d17aadee2446093896d",
+			Username:        "NewMock",
+			SkinId:          1,
+			Url:             "http://localhost/skin.png",
+			Is1_8:           true,
+			IsSlim:          false,
+			MojangTextures:  "mock-mojang-textures",
+			MojangSignature: "mock-mojang-signature",
+			OldUsername:     "Mock",
+		})
+		suite.Require().Nil(err)
+
+		usernameResp := suite.cmd("GET", "username:newmock")
+		suite.Require().NotEmpty(usernameResp)
+		suite.Require().Equal(string([]byte{
+			0x78, 0x9c, 0x5c, 0x8e, 0xcb, 0x4e, 0xc3, 0x40, 0xc, 0x45, 0xff, 0xe5, 0xae, 0xa7, 0x84, 0x40, 0x18, 0x5a,
+			0xff, 0x1, 0xb, 0x60, 0x51, 0x58, 0x23, 0x2b, 0x76, 0xd3, 0x21, 0xf3, 0xa8, 0xe6, 0x21, 0x90, 0x10, 0xff,
+			0x8e, 0x52, 0x14, 0x90, 0xba, 0xf4, 0xd1, 0xf1, 0xd5, 0xf9, 0x42, 0x2b, 0x9a, 0x1f, 0x4, 0xd4, 0x1b, 0xb4,
+			0xe6, 0x4, 0x84, 0x83, 0xdc, 0x9, 0xf7, 0x3a, 0x88, 0xb5, 0x32, 0x48, 0x7f, 0xcf, 0x2c, 0xaa, 0x37, 0xc3,
+			0x60, 0xaf, 0x77, 0xb7, 0xdb, 0x9d, 0x15, 0x98, 0xf3, 0x53, 0xe4, 0xa0, 0x20, 0x3c, 0xe9, 0xc7, 0x63, 0x1a,
+			0x67, 0x18, 0x94, 0xd9, 0xc5, 0x75, 0x29, 0x7b, 0x10, 0x8e, 0xb5, 0x9e, 0xa8, 0xeb, 0x7c, 0x1a, 0xd9, 0x1f,
+			0x53, 0xa9, 0xdd, 0x62, 0x5c, 0x9d, 0xe2, 0x4, 0x3, 0x57, 0xfa, 0xb7, 0x2d, 0xa8, 0xe6, 0xa6, 0xcb, 0xb1,
+			0xf7, 0x2e, 0x80, 0xe, 0xec, 0x8b, 0x1a, 0x84, 0xf4, 0xce, 0x71, 0x7a, 0xd1, 0xcf, 0xda, 0xb2, 0x16, 0x10,
+			0x42, 0x1a, 0xe7, 0xcd, 0x2f, 0xdd, 0xd4, 0x15, 0xaf, 0xde, 0xde, 0x4d, 0x91, 0x17, 0x74, 0x21, 0x96, 0x3f,
+			0x6e, 0xf0, 0xec, 0xe5, 0xf5, 0x3f, 0xf9, 0xdc, 0xfb, 0xfd, 0x13, 0x0, 0x0, 0xff, 0xff, 0xca, 0xc3, 0x54,
+			0x25,
+		}), usernameResp)
+
+		oldUsernameResp := suite.cmd("GET", "username:mock")
+		suite.Require().Empty(oldUsernameResp)
+
+		idResp := suite.cmd("HGET", "hash:username-to-account-id", 1)
+		suite.Require().NotEmpty(usernameResp)
+		suite.Require().Equal("NewMock", idResp)
+	})
+}
+
+func (suite *redisTestSuite) TestRemoveSkinByUserId() {
+	suite.RunSubTest("exists record", func() {
+		suite.cmd("SET", "username:mock", skinRecord)
+		suite.cmd("HSET", "hash:username-to-account-id", 1, "Mock")
+
+		err := suite.Redis.RemoveSkinByUserId(1)
+		suite.Require().Nil(err)
+
+		usernameResp := suite.cmd("GET", "username:mock")
+		suite.Require().Empty(usernameResp)
+
+		idResp := suite.cmd("HGET", "hash:username-to-account-id", 1)
+		suite.Require().Empty(idResp)
+	})
+
+	suite.RunSubTest("exists only id", func() {
+		suite.cmd("HSET", "hash:username-to-account-id", 1, "Mock")
+
+		err := suite.Redis.RemoveSkinByUserId(1)
+		suite.Require().Nil(err)
+
+		idResp := suite.cmd("HGET", "hash:username-to-account-id", 1)
+		suite.Require().Empty(idResp)
+	})
+
+	suite.RunSubTest("error when querying skin record", func() {
+		suite.cmd("SET", "username:mock", "invalid zlib")
+		suite.cmd("HSET", "hash:username-to-account-id", 1, "Mock")
+
+		err := suite.Redis.RemoveSkinByUserId(1)
+		suite.Require().EqualError(err, "zlib: invalid header")
+	})
+}
+
+func (suite *redisTestSuite) TestRemoveSkinByUsername() {
+	suite.RunSubTest("exists record", func() {
+		suite.cmd("SET", "username:mock", skinRecord)
+		suite.cmd("HSET", "hash:username-to-account-id", 1, "Mock")
+
+		err := suite.Redis.RemoveSkinByUsername("Mock")
+		suite.Require().Nil(err)
+
+		usernameResp := suite.cmd("GET", "username:mock")
+		suite.Require().Empty(usernameResp)
+
+		idResp := suite.cmd("HGET", "hash:username-to-account-id", 1)
+		suite.Require().Empty(idResp)
+	})
+
+	suite.RunSubTest("exists only username", func() {
+		suite.cmd("SET", "username:mock", skinRecord)
+
+		err := suite.Redis.RemoveSkinByUsername("Mock")
+		suite.Require().Nil(err)
+
+		usernameResp := suite.cmd("GET", "username:mock")
+		suite.Require().Empty(usernameResp)
+	})
+
+	suite.RunSubTest("no records", func() {
+		err := suite.Redis.RemoveSkinByUsername("Mock")
+		suite.Require().Nil(err)
+	})
+
+	suite.RunSubTest("error when querying skin record", func() {
+		suite.cmd("SET", "username:mock", "invalid zlib")
+
+		err := suite.Redis.RemoveSkinByUsername("Mock")
+		suite.Require().EqualError(err, "zlib: invalid header")
+	})
+}
+
+func (suite *redisTestSuite) TestGetUuid() {
+	suite.RunSubTest("exists record", func() {
+		suite.cmd("HSET",
+			"hash:mojang-username-to-uuid",
+			"mock",
+			fmt.Sprintf("%s:%d", "d3ca513eb3e14946b58047f2bd3530fd", time.Now().Unix()),
+		)
+
+		uuid, found, err := suite.Redis.GetUuid("Mock")
+		suite.Require().Nil(err)
+		suite.Require().True(found)
+		suite.Require().Equal("d3ca513eb3e14946b58047f2bd3530fd", uuid)
+	})
+
+	suite.RunSubTest("exists record with empty uuid value", func() {
+		suite.cmd("HSET",
+			"hash:mojang-username-to-uuid",
+			"mock",
+			fmt.Sprintf(":%d", time.Now().Unix()),
+		)
+
+		uuid, found, err := suite.Redis.GetUuid("Mock")
+		suite.Require().Nil(err)
+		suite.Require().True(found)
+		suite.Require().Empty("", uuid)
+	})
+
+	suite.RunSubTest("not exists record", func() {
+		uuid, found, err := suite.Redis.GetUuid("Mock")
+		suite.Require().Nil(err)
+		suite.Require().False(found)
+		suite.Require().Empty(uuid)
+	})
+
+	suite.RunSubTest("exists, but expired record", func() {
+		suite.cmd("HSET",
+			"hash:mojang-username-to-uuid",
+			"mock",
+			fmt.Sprintf("%s:%d", "d3ca513eb3e14946b58047f2bd3530fd", time.Now().Add(-1*time.Hour*24*31).Unix()),
+		)
+
+		uuid, found, err := suite.Redis.GetUuid("Mock")
+		suite.Require().Empty(uuid)
+		suite.Require().False(found)
+		suite.Require().Nil(err)
+
+		resp := suite.cmd("HGET", "hash:mojang-username-to-uuid", "mock")
+		suite.Require().Empty(resp, "should cleanup expired records")
+	})
+
+	suite.RunSubTest("exists, but corrupted record", func() {
+		suite.cmd("HSET",
+			"hash:mojang-username-to-uuid",
+			"mock",
+			"corrupted value",
+		)
+
+		uuid, found, err := suite.Redis.GetUuid("Mock")
+		suite.Require().Empty(uuid)
+		suite.Require().False(found)
+		suite.Require().Error(err, "Got unexpected response from the mojangUsernameToUuid hash: \"corrupted value\"")
+
+		resp := suite.cmd("HGET", "hash:mojang-username-to-uuid", "mock")
+		suite.Require().Empty(resp, "should cleanup expired records")
+	})
+}
+
+func (suite *redisTestSuite) TestStoreUuid() {
+	suite.RunSubTest("store uuid", func() {
+		now = func() time.Time {
+			return time.Date(2020, 04, 21, 02, 10, 16, 0, time.UTC)
+		}
+
+		err := suite.Redis.StoreUuid("Mock", "d3ca513eb3e14946b58047f2bd3530fd")
+		suite.Require().Nil(err)
+
+		resp := suite.cmd("HGET", "hash:mojang-username-to-uuid", "mock")
+		suite.Require().Equal(resp, "d3ca513eb3e14946b58047f2bd3530fd:1587435016")
+	})
+
+	suite.RunSubTest("store empty uuid", func() {
+		now = func() time.Time {
+			return time.Date(2020, 04, 21, 02, 10, 16, 0, time.UTC)
+		}
+
+		err := suite.Redis.StoreUuid("Mock", "")
+		suite.Require().Nil(err)
+
+		resp := suite.cmd("HGET", "hash:mojang-username-to-uuid", "mock")
+		suite.Require().Equal(resp, ":1587435016")
+	})
+}
+
+func (suite *redisTestSuite) TestPing() {
+	err := suite.Redis.Ping()
+	suite.Require().Nil(err)
+}

di/config.go

@@ -0,0 +1,14 @@
+package di
+
+import (
+	"github.com/defval/di"
+	"github.com/spf13/viper"
+)
+
+var config = di.Options(
+	di.Provide(newConfig),
+)
+
+func newConfig() *viper.Viper {
+	return viper.GetViper()
+}

di/db.go

@@ -0,0 +1,72 @@
+package di
+
+import (
+	"context"
+	"fmt"
+	"path"
+
+	"github.com/defval/di"
+	"github.com/spf13/viper"
+
+	"github.com/elyby/chrly/db/fs"
+	"github.com/elyby/chrly/db/redis"
+	es "github.com/elyby/chrly/eventsubscribers"
+	"github.com/elyby/chrly/http"
+	"github.com/elyby/chrly/mojangtextures"
+)
+
+// v4 had the idea that it would be possible to separate backends for storing skins and capes.
+// But in v5 the storage will be unified, so this is just temporary constructors before large reworking.
+//
+// Since there are no options for selecting target backends,
+// all constants in this case point to static specific implementations.
+var db = di.Options(
+	di.Provide(newRedis,
+		di.As(new(http.SkinsRepository)),
+		di.As(new(mojangtextures.UUIDsStorage)),
+	),
+	di.Provide(newFSFactory,
+		di.As(new(http.CapesRepository)),
+	),
+	di.Provide(newMojangSignedTexturesStorage),
+)
+
+func newRedis(container *di.Container, config *viper.Viper) (*redis.Redis, error) {
+	config.SetDefault("storage.redis.host", "localhost")
+	config.SetDefault("storage.redis.port", 6379)
+	config.SetDefault("storage.redis.poolSize", 10)
+
+	conn, err := redis.New(
+		context.Background(),
+		fmt.Sprintf("%s:%d", config.GetString("storage.redis.host"), config.GetInt("storage.redis.port")),
+		config.GetInt("storage.redis.poolSize"),
+	)
+	if err != nil {
+		return nil, err
+	}
+
+	if err := container.Provide(func() *namedHealthChecker {
+		return &namedHealthChecker{
+			Name:    "redis",
+			Checker: es.DatabaseChecker(conn),
+		}
+	}); err != nil {
+		return nil, err
+	}
+
+	return conn, nil
+}
+
+func newFSFactory(config *viper.Viper) (*fs.Filesystem, error) {
+	config.SetDefault("storage.filesystem.basePath", "data")
+	config.SetDefault("storage.filesystem.capesDirName", "capes")
+
+	return fs.New(path.Join(
+		config.GetString("storage.filesystem.basePath"),
+		config.GetString("storage.filesystem.capesDirName"),
+	))
+}
+
+func newMojangSignedTexturesStorage() mojangtextures.TexturesStorage {
+	return mojangtextures.NewInMemoryTexturesStorage()
+}

di/di.go

@@ -0,0 +1,21 @@
+package di
+
+import "github.com/defval/di"
+
+func New() (*di.Container, error) {
+	container, err := di.New(
+		config,
+		dispatcher,
+		logger,
+		db,
+		mojangTextures,
+		handlers,
+		server,
+		signer,
+	)
+	if err != nil {
+		return nil, err
+	}
+
+	return container, nil
+}

di/dispatcher.go

@@ -0,0 +1,36 @@
+package di
+
+import (
+	"github.com/defval/di"
+	"github.com/mono83/slf"
+
+	d "github.com/elyby/chrly/dispatcher"
+	"github.com/elyby/chrly/eventsubscribers"
+	"github.com/elyby/chrly/http"
+	"github.com/elyby/chrly/mojangtextures"
+)
+
+var dispatcher = di.Options(
+	di.Provide(newDispatcher,
+		di.As(new(d.Emitter)),
+		di.As(new(d.Subscriber)),
+		di.As(new(http.Emitter)),
+		di.As(new(mojangtextures.Emitter)),
+		di.As(new(eventsubscribers.Subscriber)),
+	),
+	di.Invoke(enableEventsHandlers),
+)
+
+func newDispatcher() d.Dispatcher {
+	return d.New()
+}
+
+func enableEventsHandlers(
+	dispatcher d.Subscriber,
+	logger slf.Logger,
+	statsReporter slf.StatsReporter,
+) {
+	// TODO: use idea from https://github.com/defval/di/issues/10#issuecomment-615869852
+	(&eventsubscribers.Logger{Logger: logger}).ConfigureWithDispatcher(dispatcher)
+	(&eventsubscribers.StatsReporter{StatsReporter: statsReporter}).ConfigureWithDispatcher(dispatcher)
+}

di/handlers.go

@@ -0,0 +1,163 @@
+package di
+
+import (
+	"errors"
+	"net/http"
+	"strings"
+
+	"github.com/defval/di"
+	"github.com/etherlabsio/healthcheck/v2"
+	"github.com/gorilla/mux"
+	"github.com/spf13/viper"
+
+	. "github.com/elyby/chrly/http"
+	"github.com/elyby/chrly/mojangtextures"
+)
+
+var handlers = di.Options(
+	di.Provide(newHandlerFactory, di.As(new(http.Handler))),
+	di.Provide(newSkinsystemHandler, di.WithName("skinsystem")),
+	di.Provide(newApiHandler, di.WithName("api")),
+	di.Provide(newUUIDsWorkerHandler, di.WithName("worker")),
+)
+
+func newHandlerFactory(
+	container *di.Container,
+	config *viper.Viper,
+	emitter Emitter,
+) (*mux.Router, error) {
+	enabledModules := config.GetStringSlice("modules")
+
+	// gorilla.mux has no native way to combine multiple routers.
+	// The hack used later in the code works for prefixes in addresses, but leads to misbehavior
+	// if you set an empty prefix. Since the main application should be mounted at the root prefix,
+	// we use it as the base router
+	var router *mux.Router
+	if hasValue(enabledModules, "skinsystem") {
+		if err := container.Resolve(&router, di.Name("skinsystem")); err != nil {
+			return nil, err
+		}
+	} else {
+		router = mux.NewRouter()
+	}
+
+	router.StrictSlash(true)
+	requestEventsMiddleware := CreateRequestEventsMiddleware(emitter, "skinsystem")
+	router.Use(requestEventsMiddleware)
+	// NotFoundHandler doesn't call for registered middlewares, so we must wrap it manually.
+	// See https://github.com/gorilla/mux/issues/416#issuecomment-600079279
+	router.NotFoundHandler = requestEventsMiddleware(http.HandlerFunc(NotFoundHandler))
+
+	// Enable the worker module before api to allow gorilla.mux to correctly find the target router
+	// as it uses the first matching and /api overrides the more accurate /api/worker
+	if hasValue(enabledModules, "worker") {
+		var workerRouter *mux.Router
+		if err := container.Resolve(&workerRouter, di.Name("worker")); err != nil {
+			return nil, err
+		}
+
+		mount(router, "/api/worker", workerRouter)
+	}
+
+	if hasValue(enabledModules, "api") {
+		var apiRouter *mux.Router
+		if err := container.Resolve(&apiRouter, di.Name("api")); err != nil {
+			return nil, err
+		}
+
+		var authenticator Authenticator
+		if err := container.Resolve(&authenticator); err != nil {
+			return nil, err
+		}
+
+		apiRouter.Use(CreateAuthenticationMiddleware(authenticator))
+
+		mount(router, "/api", apiRouter)
+	}
+
+	err := container.Invoke(enableReporters)
+	if err != nil && !errors.Is(err, di.ErrTypeNotExists) {
+		return nil, err
+	}
+
+	// Resolve health checkers last, because all the services required by the application
+	// must first be initialized and each of them can publish its own checkers
+	var healthCheckers []*namedHealthChecker
+	if has, _ := container.Has(&healthCheckers); has {
+		if err := container.Resolve(&healthCheckers); err != nil {
+			return nil, err
+		}
+
+		checkersOptions := make([]healthcheck.Option, len(healthCheckers))
+		for i, checker := range healthCheckers {
+			checkersOptions[i] = healthcheck.WithChecker(checker.Name, checker.Checker)
+		}
+
+		router.Handle("/healthcheck", healthcheck.Handler(checkersOptions...)).Methods("GET")
+	}
+
+	return router, nil
+}
+
+func newSkinsystemHandler(
+	config *viper.Viper,
+	emitter Emitter,
+	skinsRepository SkinsRepository,
+	capesRepository CapesRepository,
+	mojangTexturesProvider MojangTexturesProvider,
+	texturesSigner TexturesSigner,
+) (*mux.Router, error) {
+	config.SetDefault("textures.extra_param_name", "chrly")
+	config.SetDefault("textures.extra_param_value", "how do you tame a horse in Minecraft?")
+
+	app, err := NewSkinsystem(
+		emitter,
+		skinsRepository,
+		capesRepository,
+		mojangTexturesProvider,
+		texturesSigner,
+		config.GetString("textures.extra_param_name"),
+		config.GetString("textures.extra_param_value"),
+	)
+	if err != nil {
+		return nil, err
+	}
+
+	return app.Handler(), nil
+}
+
+func newApiHandler(skinsRepository SkinsRepository) *mux.Router {
+	return (&Api{
+		SkinsRepo: skinsRepository,
+	}).Handler()
+}
+
+func newUUIDsWorkerHandler(mojangUUIDsProvider *mojangtextures.BatchUuidsProvider) *mux.Router {
+	return (&UUIDsWorker{
+		MojangUuidsProvider: mojangUUIDsProvider,
+	}).Handler()
+}
+
+func hasValue(slice []string, needle string) bool {
+	for _, value := range slice {
+		if value == needle {
+			return true
+		}
+	}
+
+	return false
+}
+
+func mount(router *mux.Router, path string, handler http.Handler) {
+	router.PathPrefix(path).Handler(
+		http.StripPrefix(
+			strings.TrimSuffix(path, "/"),
+			handler,
+		),
+	)
+}
+
+type namedHealthChecker struct {
+	Name    string
+	Checker healthcheck.Checker
+}

di/logger.go

@@ -0,0 +1,104 @@
+package di
+
+import (
+	"os"
+
+	"github.com/defval/di"
+	"github.com/getsentry/raven-go"
+	"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/viper"
+
+	"github.com/elyby/chrly/eventsubscribers"
+	"github.com/elyby/chrly/version"
+)
+
+var logger = di.Options(
+	di.Provide(newLogger),
+	di.Provide(newSentry),
+	di.Provide(newStatsReporter),
+)
+
+type loggerParams struct {
+	di.Inject
+
+	SentryRaven *raven.Client `di:"" optional:"true"`
+}
+
+func newLogger(params loggerParams) slf.Logger {
+	dispatcher := &slf.Dispatcher{}
+	dispatcher.AddReceiver(writer.New(writer.Options{
+		Marker:     false,
+		TimeFormat: "15:04:05.000",
+	}))
+
+	if params.SentryRaven != nil {
+		sentryReceiver, _ := sentry.NewReceiverWithCustomRaven(
+			params.SentryRaven,
+			&sentry.Config{
+				MinLevel: "warn",
+			},
+		)
+		dispatcher.AddReceiver(sentryReceiver)
+	}
+
+	logger := wd.Custom("", "", dispatcher)
+	logger.WithParams(rays.Host)
+
+	return logger
+}
+
+func newSentry(config *viper.Viper) (*raven.Client, error) {
+	sentryAddr := config.GetString("sentry.dsn")
+	if sentryAddr == "" {
+		return nil, nil
+	}
+
+	ravenClient, err := raven.New(sentryAddr)
+	if err != nil {
+		return nil, err
+	}
+
+	ravenClient.SetEnvironment("production")
+	ravenClient.SetDefaultLoggerName("sentry-watchdog-receiver")
+	ravenClient.SetRelease(version.Version())
+
+	raven.DefaultClient = ravenClient
+
+	return ravenClient, nil
+}
+
+func newStatsReporter(config *viper.Viper) (slf.StatsReporter, error) {
+	dispatcher := &slf.Dispatcher{}
+
+	statsdAddr := config.GetString("statsd.addr")
+	if statsdAddr != "" {
+		hostname, err := os.Hostname()
+		if err != nil {
+			return nil, err
+		}
+
+		statsdReceiver, err := statsd.NewReceiver(statsd.Config{
+			Address:    statsdAddr,
+			Prefix:     "ely.skinsystem." + hostname + ".app.",
+			FlushEvery: 1,
+		})
+		if err != nil {
+			return nil, err
+		}
+
+		dispatcher.AddReceiver(statsdReceiver)
+	}
+
+	return wd.Custom("", "", dispatcher), nil
+}
+
+func enableReporters(reporter slf.StatsReporter, factories []eventsubscribers.Reporter) {
+	for _, factory := range factories {
+		factory.Enable(reporter)
+	}
+}

di/mojang_textures.go

@@ -0,0 +1,235 @@
+package di
+
+import (
+	"context"
+	"fmt"
+	"net/url"
+	"time"
+
+	"github.com/defval/di"
+	"github.com/spf13/viper"
+
+	"github.com/elyby/chrly/api/mojang"
+	es "github.com/elyby/chrly/eventsubscribers"
+	"github.com/elyby/chrly/http"
+	"github.com/elyby/chrly/mojangtextures"
+)
+
+var mojangTextures = di.Options(
+	di.Invoke(interceptMojangApiUrls),
+	di.Provide(newMojangTexturesProviderFactory),
+	di.Provide(newMojangTexturesProvider),
+	di.Provide(newMojangTexturesUuidsProviderFactory),
+	di.Provide(newMojangTexturesBatchUUIDsProvider),
+	di.Provide(newMojangTexturesBatchUUIDsProviderStrategyFactory),
+	di.Provide(newMojangTexturesBatchUUIDsProviderDelayedStrategy),
+	di.Provide(newMojangTexturesBatchUUIDsProviderFullBusStrategy),
+	di.Provide(newMojangTexturesRemoteUUIDsProvider),
+	di.Provide(newMojangSignedTexturesProvider),
+	di.Provide(newMojangTexturesStorageFactory),
+)
+
+func interceptMojangApiUrls(config *viper.Viper) error {
+	apiUrl := config.GetString("mojang.api_base_url")
+	if apiUrl != "" {
+		u, err := url.ParseRequestURI(apiUrl)
+		if err != nil {
+			return err
+		}
+
+		mojang.ApiMojangDotComAddr = u.String()
+	}
+
+	sessionServerUrl := config.GetString("mojang.session_server_base_url")
+	if sessionServerUrl != "" {
+		u, err := url.ParseRequestURI(apiUrl)
+		if err != nil {
+			return err
+		}
+
+		mojang.SessionServerMojangComAddr = u.String()
+	}
+
+	return nil
+}
+
+func newMojangTexturesProviderFactory(
+	container *di.Container,
+	config *viper.Viper,
+) (http.MojangTexturesProvider, error) {
+	config.SetDefault("mojang_textures.enabled", true)
+	if !config.GetBool("mojang_textures.enabled") {
+		return &mojangtextures.NilProvider{}, nil
+	}
+
+	var provider *mojangtextures.Provider
+	err := container.Resolve(&provider)
+	if err != nil {
+		return nil, err
+	}
+
+	return provider, nil
+}
+
+func newMojangTexturesProvider(
+	emitter mojangtextures.Emitter,
+	uuidsProvider mojangtextures.UUIDsProvider,
+	texturesProvider mojangtextures.TexturesProvider,
+	storage mojangtextures.Storage,
+) *mojangtextures.Provider {
+	return &mojangtextures.Provider{
+		Emitter:          emitter,
+		UUIDsProvider:    uuidsProvider,
+		TexturesProvider: texturesProvider,
+		Storage:          storage,
+	}
+}
+
+func newMojangTexturesUuidsProviderFactory(
+	config *viper.Viper,
+	container *di.Container,
+) (mojangtextures.UUIDsProvider, error) {
+	preferredUuidsProvider := config.GetString("mojang_textures.uuids_provider.driver")
+	if preferredUuidsProvider == "remote" {
+		var provider *mojangtextures.RemoteApiUuidsProvider
+		err := container.Resolve(&provider)
+
+		return provider, err
+	}
+
+	var provider *mojangtextures.BatchUuidsProvider
+	err := container.Resolve(&provider)
+
+	return provider, err
+}
+
+func newMojangTexturesBatchUUIDsProvider(
+	container *di.Container,
+	strategy mojangtextures.BatchUuidsProviderStrategy,
+	emitter mojangtextures.Emitter,
+) (*mojangtextures.BatchUuidsProvider, error) {
+	if err := container.Provide(func(emitter es.Subscriber, config *viper.Viper) *namedHealthChecker {
+		config.SetDefault("healthcheck.mojang_batch_uuids_provider_cool_down_duration", time.Minute)
+
+		return &namedHealthChecker{
+			Name: "mojang-batch-uuids-provider-response",
+			Checker: es.MojangBatchUuidsProviderResponseChecker(
+				emitter,
+				config.GetDuration("healthcheck.mojang_batch_uuids_provider_cool_down_duration"),
+			),
+		}
+	}); err != nil {
+		return nil, err
+	}
+
+	if err := container.Provide(func(emitter es.Subscriber, config *viper.Viper) *namedHealthChecker {
+		config.SetDefault("healthcheck.mojang_batch_uuids_provider_queue_length_limit", 50)
+
+		return &namedHealthChecker{
+			Name: "mojang-batch-uuids-provider-queue-length",
+			Checker: es.MojangBatchUuidsProviderQueueLengthChecker(
+				emitter,
+				config.GetInt("healthcheck.mojang_batch_uuids_provider_queue_length_limit"),
+			),
+		}
+	}); err != nil {
+		return nil, err
+	}
+
+	return mojangtextures.NewBatchUuidsProvider(context.Background(), strategy, emitter), nil
+}
+
+func newMojangTexturesBatchUUIDsProviderStrategyFactory(
+	container *di.Container,
+	config *viper.Viper,
+) (mojangtextures.BatchUuidsProviderStrategy, error) {
+	config.SetDefault("queue.strategy", "periodic")
+
+	strategyName := config.GetString("queue.strategy")
+	switch strategyName {
+	case "periodic":
+		var strategy *mojangtextures.PeriodicStrategy
+		err := container.Resolve(&strategy)
+		if err != nil {
+			return nil, err
+		}
+
+		return strategy, nil
+	case "full-bus":
+		var strategy *mojangtextures.FullBusStrategy
+		err := container.Resolve(&strategy)
+		if err != nil {
+			return nil, err
+		}
+
+		return strategy, nil
+	default:
+		return nil, fmt.Errorf("unknown queue strategy \"%s\"", strategyName)
+	}
+}
+
+func newMojangTexturesBatchUUIDsProviderDelayedStrategy(config *viper.Viper) *mojangtextures.PeriodicStrategy {
+	config.SetDefault("queue.loop_delay", 2*time.Second+500*time.Millisecond)
+	config.SetDefault("queue.batch_size", 10)
+
+	return mojangtextures.NewPeriodicStrategy(
+		config.GetDuration("queue.loop_delay"),
+		config.GetInt("queue.batch_size"),
+	)
+}
+
+func newMojangTexturesBatchUUIDsProviderFullBusStrategy(config *viper.Viper) *mojangtextures.FullBusStrategy {
+	config.SetDefault("queue.loop_delay", 2*time.Second+500*time.Millisecond)
+	config.SetDefault("queue.batch_size", 10)
+
+	return mojangtextures.NewFullBusStrategy(
+		config.GetDuration("queue.loop_delay"),
+		config.GetInt("queue.batch_size"),
+	)
+}
+
+func newMojangTexturesRemoteUUIDsProvider(
+	container *di.Container,
+	config *viper.Viper,
+	emitter mojangtextures.Emitter,
+) (*mojangtextures.RemoteApiUuidsProvider, error) {
+	remoteUrl, err := url.Parse(config.GetString("mojang_textures.uuids_provider.url"))
+	if err != nil {
+		return nil, fmt.Errorf("unable to parse remote url: %w", err)
+	}
+
+	if err := container.Provide(func(emitter es.Subscriber, config *viper.Viper) *namedHealthChecker {
+		config.SetDefault("healthcheck.mojang_api_textures_provider_cool_down_duration", time.Minute+10*time.Second)
+
+		return &namedHealthChecker{
+			Name: "mojang-api-textures-provider-response-checker",
+			Checker: es.MojangApiTexturesProviderResponseChecker(
+				emitter,
+				config.GetDuration("healthcheck.mojang_api_textures_provider_cool_down_duration"),
+			),
+		}
+	}); err != nil {
+		return nil, err
+	}
+
+	return &mojangtextures.RemoteApiUuidsProvider{
+		Emitter: emitter,
+		Url:     *remoteUrl,
+	}, nil
+}
+
+func newMojangSignedTexturesProvider(emitter mojangtextures.Emitter) mojangtextures.TexturesProvider {
+	return &mojangtextures.MojangApiTexturesProvider{
+		Emitter: emitter,
+	}
+}
+
+func newMojangTexturesStorageFactory(
+	uuidsStorage mojangtextures.UUIDsStorage,
+	texturesStorage mojangtextures.TexturesStorage,
+) mojangtextures.Storage {
+	return &mojangtextures.SeparatedStorage{
+		UUIDsStorage:    uuidsStorage,
+		TexturesStorage: texturesStorage,
+	}
+}

di/server.go

@@ -0,0 +1,79 @@
+package di
+
+import (
+	"errors"
+	"fmt"
+	"net/http"
+	"runtime/debug"
+	"time"
+
+	"github.com/defval/di"
+	"github.com/getsentry/raven-go"
+	"github.com/spf13/viper"
+
+	. "github.com/elyby/chrly/http"
+)
+
+var server = di.Options(
+	di.Provide(newAuthenticator, di.As(new(Authenticator))),
+	di.Provide(newServer),
+)
+
+func newAuthenticator(config *viper.Viper, emitter Emitter) (*JwtAuth, error) {
+	key := config.GetString("chrly.secret")
+	if key == "" {
+		return nil, errors.New("chrly.secret must be set in order to use authenticator")
+	}
+
+	return &JwtAuth{
+		Key:     []byte(key),
+		Emitter: emitter,
+	}, nil
+}
+
+type serverParams struct {
+	di.Inject
+
+	Config  *viper.Viper  `di:""`
+	Handler http.Handler  `di:""`
+	Sentry  *raven.Client `di:"" optional:"true"`
+}
+
+func newServer(params serverParams) *http.Server {
+	params.Config.SetDefault("server.host", "")
+	params.Config.SetDefault("server.port", 80)
+
+	var handler http.Handler
+	if params.Sentry != nil {
+		// raven.Recoverer uses DefaultClient and nothing can be done about it
+		// To avoid code duplication, if the Sentry service is successfully initiated,
+		// it will also replace DefaultClient, so raven.Recoverer will work with the instance
+		// created in the application constructor
+		handler = raven.Recoverer(params.Handler)
+	} else {
+		// Raven's Recoverer is prints the stacktrace and sets the corresponding status itself.
+		// But there is no magic and if you don't define a panic handler, Mux will just reset the connection
+		handler = http.HandlerFunc(func(request http.ResponseWriter, response *http.Request) {
+			defer func() {
+				if recovered := recover(); recovered != nil {
+					debug.PrintStack() // TODO: colorize output
+					request.WriteHeader(http.StatusInternalServerError)
+				}
+			}()
+
+			params.Handler.ServeHTTP(request, response)
+		})
+	}
+
+	address := fmt.Sprintf("%s:%d", params.Config.GetString("server.host"), params.Config.GetInt("server.port"))
+	server := &http.Server{
+		Addr:           address,
+		ReadTimeout:    5 * time.Second,
+		WriteTimeout:   5 * time.Second,
+		IdleTimeout:    60 * time.Second,
+		MaxHeaderBytes: 1 << 16,
+		Handler:        handler,
+	}
+
+	return server
+}

di/signer.go

@@ -0,0 +1,48 @@
+package di
+
+import (
+	"crypto/x509"
+	"encoding/base64"
+	"encoding/pem"
+	"errors"
+	"github.com/elyby/chrly/http"
+	. "github.com/elyby/chrly/signer"
+	"strings"
+
+	"github.com/defval/di"
+	"github.com/spf13/viper"
+)
+
+var signer = di.Options(
+	di.Provide(newTexturesSigner,
+		di.As(new(http.TexturesSigner)),
+	),
+)
+
+func newTexturesSigner(config *viper.Viper) (*Signer, error) {
+	keyStr := config.GetString("chrly.signing.key")
+	if keyStr == "" {
+		return nil, errors.New("chrly.signing.key must be set in order to sign textures")
+	}
+
+	var keyBytes []byte
+	if strings.HasPrefix(keyStr, "base64:") {
+		base64Value := keyStr[7:]
+		decodedKey, err := base64.URLEncoding.DecodeString(base64Value)
+		if err != nil {
+			return nil, err
+		}
+
+		keyBytes = decodedKey
+	} else {
+		keyBytes = []byte(keyStr)
+	}
+
+	rawPem, _ := pem.Decode(keyBytes)
+	key, err := x509.ParsePKCS1PrivateKey(rawPem.Bytes)
+	if err != nil {
+		return nil, err
+	}
+
+	return &Signer{Key: key}, nil
+}

dispatcher/dispatcher.go

@@ -0,0 +1,34 @@
+package dispatcher
+
+import "github.com/asaskevich/EventBus"
+
+type Subscriber interface {
+	Subscribe(topic string, fn interface{})
+}
+
+type Emitter interface {
+	Emit(topic string, args ...interface{})
+}
+
+type Dispatcher interface {
+	Subscriber
+	Emitter
+}
+
+type localEventDispatcher struct {
+	bus EventBus.Bus
+}
+
+func (d *localEventDispatcher) Subscribe(topic string, fn interface{}) {
+	_ = d.bus.Subscribe(topic, fn)
+}
+
+func (d *localEventDispatcher) Emit(topic string, args ...interface{}) {
+	d.bus.Publish(topic, args...)
+}
+
+func New() Dispatcher {
+	return &localEventDispatcher{
+		bus: EventBus.New(),
+	}
+}

docker-compose.dev.yml

@@ -0,0 +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:
+  redis:
+    image: redis:4.0-32bit
+    ports:
+      - "6379:6379"
+    volumes:
+      - ./data/redis:/data

docker-compose.prod.yml

@@ -0,0 +1,36 @@
+# 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: elyby/chrly
+    hostname: chrly0
+    restart: always
+    links:
+      - redis
+    volumes:
+      - ./data/capes:/data/capes
+    ports:
+      - "80:80"
+    environment:
+      CHRLY_SECRET: replace_this_value_in_production
+
+  # Use this configuration in case when you need a remote Mojang UUIDs provider
+  # worker:
+  #   image: elyby/chrly
+  #   hostname: chrly0
+  #   restart: always
+  #   ports:
+  #     - "8080:80"
+  #   command: ["worker"]
+
+  redis:
+    image: redis:4.0-32bit # 32-bit version is recommended to spare some memory
+    restart: always
+    volumes:
+      - ./data/redis:/data

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" = "worker" ] || [ "$1" = "token" ] || [ "$1" = "version" ]; then
+    set -- /usr/local/bin/chrly "$@"
+fi
+
+exec "$@"

eventsubscribers/health_checkers.go

@@ -0,0 +1,111 @@
+package eventsubscribers
+
+import (
+	"context"
+	"errors"
+	"sync"
+	"time"
+
+	"github.com/etherlabsio/healthcheck/v2"
+
+	"github.com/elyby/chrly/api/mojang"
+)
+
+type Pingable interface {
+	Ping() error
+}
+
+func DatabaseChecker(connection Pingable) healthcheck.CheckerFunc {
+	return func(ctx context.Context) error {
+		done := make(chan error)
+		go func() {
+			done <- connection.Ping()
+		}()
+
+		select {
+		case <-ctx.Done():
+			return errors.New("check timeout")
+		case err := <-done:
+			return err
+		}
+	}
+}
+
+func MojangBatchUuidsProviderResponseChecker(dispatcher Subscriber, resetDuration time.Duration) healthcheck.CheckerFunc {
+	errHolder := &expiringErrHolder{D: resetDuration}
+	dispatcher.Subscribe(
+		"mojang_textures:batch_uuids_provider:result",
+		func(usernames []string, profiles []*mojang.ProfileInfo, err error) {
+			errHolder.Set(err)
+		},
+	)
+
+	return func(ctx context.Context) error {
+		return errHolder.Get()
+	}
+}
+
+func MojangBatchUuidsProviderQueueLengthChecker(dispatcher Subscriber, maxLength int) healthcheck.CheckerFunc {
+	var mutex sync.Mutex
+	queueLength := 0
+	dispatcher.Subscribe("mojang_textures:batch_uuids_provider:round", func(usernames []string, tasksInQueue int) {
+		mutex.Lock()
+		queueLength = tasksInQueue
+		mutex.Unlock()
+	})
+
+	return func(ctx context.Context) error {
+		mutex.Lock()
+		defer mutex.Unlock()
+
+		if queueLength < maxLength {
+			return nil
+		}
+
+		return errors.New("the maximum number of tasks in the queue has been exceeded")
+	}
+}
+
+func MojangApiTexturesProviderResponseChecker(dispatcher Subscriber, resetDuration time.Duration) healthcheck.CheckerFunc {
+	errHolder := &expiringErrHolder{D: resetDuration}
+	dispatcher.Subscribe(
+		"mojang_textures:mojang_api_textures_provider:after_request",
+		func(uuid string, profile *mojang.SignedTexturesResponse, err error) {
+			errHolder.Set(err)
+		},
+	)
+
+	return func(ctx context.Context) error {
+		return errHolder.Get()
+	}
+}
+
+type expiringErrHolder struct {
+	D   time.Duration
+	err error
+	l   sync.Mutex
+	t   *time.Timer
+}
+
+func (h *expiringErrHolder) Get() error {
+	h.l.Lock()
+	defer h.l.Unlock()
+
+	return h.err
+}
+
+func (h *expiringErrHolder) Set(err error) {
+	h.l.Lock()
+	defer h.l.Unlock()
+	if h.t != nil {
+		h.t.Stop()
+		h.t = nil
+	}
+
+	h.err = err
+	if err != nil {
+		h.t = time.AfterFunc(h.D, func() {
+			h.Set(nil)
+		})
+	}
+}

eventsubscribers/health_checkers_test.go

@@ -0,0 +1,148 @@
+package eventsubscribers
+
+import (
+	"context"
+	"errors"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/mock"
+
+	"github.com/elyby/chrly/api/mojang"
+	"github.com/elyby/chrly/dispatcher"
+)
+
+type pingableMock struct {
+	mock.Mock
+}
+
+func (p *pingableMock) Ping() error {
+	args := p.Called()
+	return args.Error(0)
+}
+
+func TestDatabaseChecker(t *testing.T) {
+	t.Run("no error", func(t *testing.T) {
+		p := &pingableMock{}
+		p.On("Ping").Return(nil)
+		checker := DatabaseChecker(p)
+		assert.Nil(t, checker(context.Background()))
+	})
+
+	t.Run("with error", func(t *testing.T) {
+		err := errors.New("mock error")
+		p := &pingableMock{}
+		p.On("Ping").Return(err)
+		checker := DatabaseChecker(p)
+		assert.Equal(t, err, checker(context.Background()))
+	})
+
+	t.Run("context timeout", func(t *testing.T) {
+		p := &pingableMock{}
+		waitChan := make(chan time.Time, 1)
+		p.On("Ping").WaitUntil(waitChan).Return(nil)
+
+		ctx, cancel := context.WithTimeout(context.Background(), 0)
+		defer cancel()
+
+		checker := DatabaseChecker(p)
+		assert.Errorf(t, checker(ctx), "check timeout")
+		close(waitChan)
+	})
+}
+
+func TestMojangBatchUuidsProviderChecker(t *testing.T) {
+	t.Run("empty state", func(t *testing.T) {
+		d := dispatcher.New()
+		checker := MojangBatchUuidsProviderResponseChecker(d, time.Millisecond)
+		assert.Nil(t, checker(context.Background()))
+	})
+
+	t.Run("when no error occurred", func(t *testing.T) {
+		d := dispatcher.New()
+		checker := MojangBatchUuidsProviderResponseChecker(d, time.Millisecond)
+		d.Emit("mojang_textures:batch_uuids_provider:result", []string{"username"}, []*mojang.ProfileInfo{}, nil)
+		assert.Nil(t, checker(context.Background()))
+	})
+
+	t.Run("when error occurred", func(t *testing.T) {
+		d := dispatcher.New()
+		checker := MojangBatchUuidsProviderResponseChecker(d, time.Millisecond)
+		err := errors.New("some error occurred")
+		d.Emit("mojang_textures:batch_uuids_provider:result", []string{"username"}, nil, err)
+		assert.Equal(t, err, checker(context.Background()))
+	})
+
+	t.Run("should reset value after passed duration", func(t *testing.T) {
+		d := dispatcher.New()
+		checker := MojangBatchUuidsProviderResponseChecker(d, 20*time.Millisecond)
+		err := errors.New("some error occurred")
+		d.Emit("mojang_textures:batch_uuids_provider:result", []string{"username"}, nil, err)
+		assert.Equal(t, err, checker(context.Background()))
+		time.Sleep(40 * time.Millisecond)
+		assert.Nil(t, checker(context.Background()))
+	})
+}
+
+func TestMojangBatchUuidsProviderQueueLengthChecker(t *testing.T) {
+	t.Run("empty state", func(t *testing.T) {
+		d := dispatcher.New()
+		checker := MojangBatchUuidsProviderQueueLengthChecker(d, 10)
+		assert.Nil(t, checker(context.Background()))
+	})
+
+	t.Run("less than allowed limit", func(t *testing.T) {
+		d := dispatcher.New()
+		checker := MojangBatchUuidsProviderQueueLengthChecker(d, 10)
+		d.Emit("mojang_textures:batch_uuids_provider:round", []string{"username"}, 9)
+		assert.Nil(t, checker(context.Background()))
+	})
+
+	t.Run("greater than allowed limit", func(t *testing.T) {
+		d := dispatcher.New()
+		checker := MojangBatchUuidsProviderQueueLengthChecker(d, 10)
+		d.Emit("mojang_textures:batch_uuids_provider:round", []string{"username"}, 10)
+		checkResult := checker(context.Background())
+		if assert.Error(t, checkResult) {
+			assert.Equal(t, "the maximum number of tasks in the queue has been exceeded", checkResult.Error())
+		}
+	})
+}
+
+func TestMojangApiTexturesProviderResponseChecker(t *testing.T) {
+	t.Run("empty state", func(t *testing.T) {
+		d := dispatcher.New()
+		checker := MojangApiTexturesProviderResponseChecker(d, time.Millisecond)
+		assert.Nil(t, checker(context.Background()))
+	})
+
+	t.Run("when no error occurred", func(t *testing.T) {
+		d := dispatcher.New()
+		checker := MojangApiTexturesProviderResponseChecker(d, time.Millisecond)
+		d.Emit("mojang_textures:mojang_api_textures_provider:after_request",
+			"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+			&mojang.SignedTexturesResponse{},
+			nil,
+		)
+		assert.Nil(t, checker(context.Background()))
+	})
+
+	t.Run("when error occurred", func(t *testing.T) {
+		d := dispatcher.New()
+		checker := MojangApiTexturesProviderResponseChecker(d, time.Millisecond)
+		err := errors.New("some error occurred")
+		d.Emit("mojang_textures:mojang_api_textures_provider:after_request", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", nil, err)
+		assert.Equal(t, err, checker(context.Background()))
+	})
+
+	t.Run("should reset value after passed duration", func(t *testing.T) {
+		d := dispatcher.New()
+		checker := MojangApiTexturesProviderResponseChecker(d, 20*time.Millisecond)
+		err := errors.New("some error occurred")
+		d.Emit("mojang_textures:mojang_api_textures_provider:after_request", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", nil, err)
+		assert.Equal(t, err, checker(context.Background()))
+		time.Sleep(40 * time.Millisecond)
+		assert.Nil(t, checker(context.Background()))
+	})
+}

eventsubscribers/logger.go

@@ -0,0 +1,94 @@
+package eventsubscribers
+
+import (
+	"net"
+	"net/http"
+	"net/url"
+	"strings"
+	"syscall"
+
+	"github.com/mono83/slf"
+	"github.com/mono83/slf/wd"
+
+	"github.com/elyby/chrly/api/mojang"
+)
+
+type Logger struct {
+	slf.Logger
+}
+
+func (l *Logger) ConfigureWithDispatcher(d Subscriber) {
+	d.Subscribe("skinsystem:after_request", l.handleAfterSkinsystemRequest)
+
+	d.Subscribe("mojang_textures:usernames:after_call", l.createMojangTexturesErrorHandler("usernames"))
+	d.Subscribe("mojang_textures:textures:after_call", l.createMojangTexturesErrorHandler("textures"))
+}
+
+func (l *Logger) handleAfterSkinsystemRequest(req *http.Request, statusCode int) {
+	path := req.URL.Path
+	if req.URL.RawQuery != "" {
+		path += "?" + req.URL.RawQuery
+	}
+
+	l.Info(
+		":ip - - \":method :path\" :statusCode - \":userAgent\" \":forwardedIp\"",
+		wd.StringParam("ip", trimPort(req.RemoteAddr)),
+		wd.StringParam("method", req.Method),
+		wd.StringParam("path", path),
+		wd.IntParam("statusCode", statusCode),
+		wd.StringParam("userAgent", req.UserAgent()),
+		wd.StringParam("forwardedIp", req.Header.Get("X-Forwarded-For")),
+	)
+}
+
+func (l *Logger) createMojangTexturesErrorHandler(provider string) func(identity string, result interface{}, err error) {
+	providerParam := wd.NameParam(provider)
+	return func(identity string, result interface{}, err error) {
+		if err == nil {
+			return
+		}
+
+		errParam := wd.ErrParam(err)
+
+		switch err.(type) {
+		case *mojang.BadRequestError:
+			l.logMojangTexturesWarning(providerParam, errParam)
+			return
+		case *mojang.ForbiddenError:
+			l.logMojangTexturesWarning(providerParam, errParam)
+			return
+		case *mojang.TooManyRequestsError:
+			l.logMojangTexturesWarning(providerParam, errParam)
+			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
+			}
+		}
+
+		l.Error(":name: Unexpected Mojang response error: :err", providerParam, errParam)
+	}
+}
+
+func (l *Logger) logMojangTexturesWarning(providerParam slf.Param, errParam slf.Param) {
+	l.Warning(":name: :err", providerParam, errParam)
+}
+
+func trimPort(ip string) string {
+	// Don't care about possible -1 result because RemoteAddr will always contain ip and port
+	cutTo := strings.LastIndexByte(ip, ':')
+
+	return ip[0:cutTo]
+}

eventsubscribers/logger_test.go

@@ -0,0 +1,256 @@
+package eventsubscribers
+
+import (
+	"net"
+	"net/http"
+	"net/http/httptest"
+	"net/url"
+	"syscall"
+	"testing"
+
+	"github.com/mono83/slf"
+	"github.com/mono83/slf/params"
+	"github.com/stretchr/testify/mock"
+
+	"github.com/elyby/chrly/api/mojang"
+	"github.com/elyby/chrly/dispatcher"
+)
+
+type LoggerMock struct {
+	mock.Mock
+}
+
+func prepareLoggerArgs(message string, params []slf.Param) []interface{} {
+	args := []interface{}{message}
+	for _, v := range params {
+		args = append(args, v.(interface{}))
+	}
+
+	return args
+}
+
+func (l *LoggerMock) Trace(message string, params ...slf.Param) {
+	l.Called(prepareLoggerArgs(message, params)...)
+}
+
+func (l *LoggerMock) Debug(message string, params ...slf.Param) {
+	l.Called(prepareLoggerArgs(message, params)...)
+}
+
+func (l *LoggerMock) Info(message string, params ...slf.Param) {
+	l.Called(prepareLoggerArgs(message, params)...)
+}
+
+func (l *LoggerMock) Warning(message string, params ...slf.Param) {
+	l.Called(prepareLoggerArgs(message, params)...)
+}
+
+func (l *LoggerMock) Error(message string, params ...slf.Param) {
+	l.Called(prepareLoggerArgs(message, params)...)
+}
+
+func (l *LoggerMock) Alert(message string, params ...slf.Param) {
+	l.Called(prepareLoggerArgs(message, params)...)
+}
+
+func (l *LoggerMock) Emergency(message string, params ...slf.Param) {
+	l.Called(prepareLoggerArgs(message, params)...)
+}
+
+type LoggerTestCase struct {
+	Events        [][]interface{}
+	ExpectedCalls [][]interface{}
+}
+
+var loggerTestCases = map[string]*LoggerTestCase{
+	"should log each request to the skinsystem": {
+		Events: [][]interface{}{
+			{"skinsystem:after_request",
+				(func() *http.Request {
+					req := httptest.NewRequest("GET", "http://localhost/skins/username.png", nil)
+					req.Header.Add("User-Agent", "Test user agent")
+
+					return req
+				})(),
+				201,
+			},
+		},
+		ExpectedCalls: [][]interface{}{
+			{"Info",
+				":ip - - \":method :path\" :statusCode - \":userAgent\" \":forwardedIp\"",
+				mock.MatchedBy(func(strParam params.String) bool {
+					return strParam.Key == "ip" && strParam.Value == "192.0.2.1"
+				}),
+				mock.MatchedBy(func(strParam params.String) bool {
+					return strParam.Key == "method" && strParam.Value == "GET"
+				}),
+				mock.MatchedBy(func(strParam params.String) bool {
+					return strParam.Key == "path" && strParam.Value == "/skins/username.png"
+				}),
+				mock.MatchedBy(func(strParam params.Int) bool {
+					return strParam.Key == "statusCode" && strParam.Value == 201
+				}),
+				mock.MatchedBy(func(strParam params.String) bool {
+					return strParam.Key == "userAgent" && strParam.Value == "Test user agent"
+				}),
+				mock.MatchedBy(func(strParam params.String) bool {
+					return strParam.Key == "forwardedIp" && strParam.Value == ""
+				}),
+			},
+		},
+	},
+	"should log each request to the skinsystem 2": {
+		Events: [][]interface{}{
+			{"skinsystem:after_request",
+				(func() *http.Request {
+					req := httptest.NewRequest("GET", "http://localhost/skins/username.png?authlib=1.5.2", nil)
+					req.Header.Add("User-Agent", "Test user agent")
+					req.Header.Add("X-Forwarded-For", "1.2.3.4")
+
+					return req
+				})(),
+				201,
+			},
+		},
+		ExpectedCalls: [][]interface{}{
+			{"Info",
+				":ip - - \":method :path\" :statusCode - \":userAgent\" \":forwardedIp\"",
+				mock.Anything, // Already tested
+				mock.Anything, // Already tested
+				mock.MatchedBy(func(strParam params.String) bool {
+					return strParam.Key == "path" && strParam.Value == "/skins/username.png?authlib=1.5.2"
+				}),
+				mock.Anything, // Already tested
+				mock.Anything, // Already tested
+				mock.MatchedBy(func(strParam params.String) bool {
+					return strParam.Key == "forwardedIp" && strParam.Value == "1.2.3.4"
+				}),
+			},
+		},
+	},
+}
+
+type timeoutError struct{}
+
+func (*timeoutError) Error() string   { return "timeout error" }
+func (*timeoutError) Timeout() bool   { return true }
+func (*timeoutError) Temporary() bool { return false }
+
+func init() {
+	// mojang_textures providers errors
+	for _, providerName := range []string{"usernames", "textures"} {
+		pn := providerName // Store pointer to iteration value
+		loggerTestCases["should not log when no error occurred for "+pn+" provider"] = &LoggerTestCase{
+			Events: [][]interface{}{
+				{"mojang_textures:" + pn + ":after_call", pn, &mojang.ProfileInfo{}, nil},
+			},
+			ExpectedCalls: nil,
+		}
+
+		loggerTestCases["should not log when some network errors occured for "+pn+" provider"] = &LoggerTestCase{
+			Events: [][]interface{}{
+				{"mojang_textures:" + pn + ":after_call", pn, nil, &timeoutError{}},
+				{"mojang_textures:" + pn + ":after_call", pn, nil, &url.Error{Op: "GET", URL: "http://localhost"}},
+				{"mojang_textures:" + pn + ":after_call", pn, nil, &net.OpError{Op: "read"}},
+				{"mojang_textures:" + pn + ":after_call", pn, nil, &net.OpError{Op: "dial"}},
+				{"mojang_textures:" + pn + ":after_call", pn, nil, syscall.ECONNREFUSED},
+			},
+			ExpectedCalls: nil,
+		}
+
+		loggerTestCases["should log expected mojang errors for "+pn+" provider"] = &LoggerTestCase{
+			Events: [][]interface{}{
+				{"mojang_textures:" + pn + ":after_call", pn, nil, &mojang.BadRequestError{
+					ErrorType: "IllegalArgumentException",
+					Message:   "profileName can not be null or empty.",
+				}},
+				{"mojang_textures:" + pn + ":after_call", pn, nil, &mojang.ForbiddenError{}},
+				{"mojang_textures:" + pn + ":after_call", pn, nil, &mojang.TooManyRequestsError{}},
+			},
+			ExpectedCalls: [][]interface{}{
+				{"Warning",
+					":name: :err",
+					mock.MatchedBy(func(strParam params.String) bool {
+						return strParam.Key == "name" && strParam.Value == pn
+					}),
+					mock.MatchedBy(func(errParam params.Error) bool {
+						if errParam.Key != "err" {
+							return false
+						}
+
+						if _, ok := errParam.Value.(*mojang.BadRequestError); ok {
+							return true
+						}
+
+						if _, ok := errParam.Value.(*mojang.ForbiddenError); ok {
+							return true
+						}
+
+						if _, ok := errParam.Value.(*mojang.TooManyRequestsError); ok {
+							return true
+						}
+
+						return false
+					}),
+				},
+			},
+		}
+
+		loggerTestCases["should call error when unexpected error occurred for "+pn+" provider"] = &LoggerTestCase{
+			Events: [][]interface{}{
+				{"mojang_textures:" + pn + ":after_call", pn, nil, &mojang.ServerError{Status: 500}},
+			},
+			ExpectedCalls: [][]interface{}{
+				{"Error",
+					":name: Unexpected Mojang response error: :err",
+					mock.MatchedBy(func(strParam params.String) bool {
+						return strParam.Key == "name" && strParam.Value == pn
+					}),
+					mock.MatchedBy(func(errParam params.Error) bool {
+						if errParam.Key != "err" {
+							return false
+						}
+
+						if _, ok := errParam.Value.(*mojang.ServerError); !ok {
+							return false
+						}
+
+						return true
+					}),
+				},
+			},
+		}
+	}
+}
+
+func TestLogger(t *testing.T) {
+	for name, c := range loggerTestCases {
+		t.Run(name, func(t *testing.T) {
+			loggerMock := &LoggerMock{}
+			if c.ExpectedCalls != nil {
+				for _, c := range c.ExpectedCalls {
+					topicName, _ := c[0].(string)
+					loggerMock.On(topicName, c[1:]...)
+				}
+			}
+
+			reporter := &Logger{
+				Logger: loggerMock,
+			}
+
+			d := dispatcher.New()
+			reporter.ConfigureWithDispatcher(d)
+			for _, args := range c.Events {
+				eventName, _ := args[0].(string)
+				d.Emit(eventName, args[1:]...)
+			}
+
+			if c.ExpectedCalls != nil {
+				for _, c := range c.ExpectedCalls {
+					topicName, _ := c[0].(string)
+					loggerMock.AssertCalled(t, topicName, c[1:]...)
+				}
+			}
+		})
+	}
+}

eventsubscribers/stats_reporter.go

@@ -0,0 +1,190 @@
+package eventsubscribers
+
+import (
+	"net/http"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/mono83/slf"
+
+	"github.com/elyby/chrly/api/mojang"
+)
+
+type StatsReporter struct {
+	slf.StatsReporter
+	Prefix string
+
+	timersMap   map[string]time.Time
+	timersMutex sync.Mutex
+}
+
+type Reporter interface {
+	Enable(reporter slf.StatsReporter)
+}
+
+type ReporterFunc func(reporter slf.StatsReporter)
+
+func (f ReporterFunc) Enable(reporter slf.StatsReporter) {
+	f(reporter)
+}
+
+// TODO: rework all reporters in the same style as it was there: https://github.com/elyby/chrly/blob/1543e98b/di/db.go#L48-L52
+func (s *StatsReporter) ConfigureWithDispatcher(d Subscriber) {
+	s.timersMap = make(map[string]time.Time)
+
+	// Per request events
+	d.Subscribe("skinsystem:before_request", s.handleBeforeRequest)
+	d.Subscribe("skinsystem:after_request", s.handleAfterRequest)
+
+	// Authentication events
+	d.Subscribe("authenticator:success", s.incCounterHandler("authentication.challenge")) // TODO: legacy, remove in v5
+	d.Subscribe("authenticator:success", s.incCounterHandler("authentication.success"))
+	d.Subscribe("authentication:error", s.incCounterHandler("authentication.challenge")) // TODO: legacy, remove in v5
+	d.Subscribe("authentication:error", s.incCounterHandler("authentication.failed"))
+
+	// Mojang signed textures source events
+	d.Subscribe("mojang_textures:call", s.incCounterHandler("mojang_textures.request"))
+	d.Subscribe("mojang_textures:usernames:after_cache", func(username string, uuid string, found bool, err error) {
+		if err != nil || !found {
+			return
+		}
+
+		if uuid == "" {
+			s.IncCounter("mojang_textures.usernames.cache_hit_nil", 1)
+		} else {
+			s.IncCounter("mojang_textures.usernames.cache_hit", 1)
+		}
+	})
+	d.Subscribe("mojang_textures:textures:after_cache", func(uuid string, textures *mojang.SignedTexturesResponse, err error) {
+		if err != nil {
+			return
+		}
+
+		if textures != nil {
+			s.IncCounter("mojang_textures.textures.cache_hit", 1)
+		}
+	})
+	d.Subscribe("mojang_textures:already_processing", s.incCounterHandler("mojang_textures.already_scheduled"))
+	d.Subscribe("mojang_textures:usernames:after_call", func(username string, profile *mojang.ProfileInfo, err error) {
+		if err != nil {
+			return
+		}
+
+		if profile == nil {
+			s.IncCounter("mojang_textures.usernames.uuid_miss", 1)
+		} else {
+			s.IncCounter("mojang_textures.usernames.uuid_hit", 1)
+		}
+	})
+	d.Subscribe("mojang_textures:textures:before_call", s.incCounterHandler("mojang_textures.textures.request"))
+	d.Subscribe("mojang_textures:textures:after_call", func(uuid string, textures *mojang.SignedTexturesResponse, err error) {
+		if err != nil {
+			return
+		}
+
+		if textures == nil {
+			s.IncCounter("mojang_textures.usernames.textures_miss", 1)
+		} else {
+			s.IncCounter("mojang_textures.usernames.textures_hit", 1)
+		}
+	})
+	d.Subscribe("mojang_textures:before_result", func(username string, uuid string) {
+		s.startTimeRecording("mojang_textures_result_time_" + username)
+	})
+	d.Subscribe("mojang_textures:after_result", func(username string, textures *mojang.SignedTexturesResponse, err error) {
+		s.finalizeTimeRecording("mojang_textures_result_time_"+username, "mojang_textures.result_time")
+	})
+	d.Subscribe("mojang_textures:textures:before_call", func(uuid string) {
+		s.startTimeRecording("mojang_textures_provider_time_" + uuid)
+	})
+	d.Subscribe("mojang_textures:textures:after_call", func(uuid string, textures *mojang.SignedTexturesResponse, err error) {
+		s.finalizeTimeRecording("mojang_textures_provider_time_"+uuid, "mojang_textures.textures.request_time")
+	})
+
+	// Mojang UUIDs batch provider metrics
+	d.Subscribe("mojang_textures:batch_uuids_provider:queued", s.incCounterHandler("mojang_textures.usernames.queued"))
+	d.Subscribe("mojang_textures:batch_uuids_provider:round", func(usernames []string, queueSize int) {
+		s.UpdateGauge("mojang_textures.usernames.iteration_size", int64(len(usernames)))
+		s.UpdateGauge("mojang_textures.usernames.queue_size", int64(queueSize))
+		if len(usernames) != 0 {
+			s.startTimeRecording("batch_uuids_provider_round_time_" + strings.Join(usernames, "|"))
+		}
+	})
+	d.Subscribe("mojang_textures:batch_uuids_provider:result", func(usernames []string, profiles []*mojang.ProfileInfo, err error) {
+		s.finalizeTimeRecording("batch_uuids_provider_round_time_"+strings.Join(usernames, "|"), "mojang_textures.usernames.round_time")
+	})
+}
+
+func (s *StatsReporter) handleBeforeRequest(req *http.Request) {
+	var key string
+	m := req.Method
+	p := req.URL.Path
+	if p == "/skins" {
+		key = "skins.get_request"
+	} else if strings.HasPrefix(p, "/skins/") {
+		key = "skins.request"
+	} else if p == "/cloaks" {
+		key = "capes.get_request"
+	} else if strings.HasPrefix(p, "/cloaks/") {
+		key = "capes.request"
+	} else if strings.HasPrefix(p, "/textures/signed/") {
+		key = "signed_textures.request"
+	} else if strings.HasPrefix(p, "/textures/") {
+		key = "textures.request"
+	} else if strings.HasPrefix(p, "/profile/") {
+		key = "profiles.request"
+	} else if m == http.MethodPost && p == "/api/skins" {
+		key = "api.skins.post.request"
+	} else if m == http.MethodDelete && strings.HasPrefix(p, "/api/skins/") {
+		key = "api.skins.delete.request"
+	} else {
+		return
+	}
+
+	s.IncCounter(key, 1)
+}
+
+func (s *StatsReporter) handleAfterRequest(req *http.Request, code int) {
+	var key string
+	m := req.Method
+	p := req.URL.Path
+	if m == http.MethodPost && p == "/api/skins" && code == http.StatusCreated {
+		key = "api.skins.post.success"
+	} else if m == http.MethodPost && p == "/api/skins" && code == http.StatusBadRequest {
+		key = "api.skins.post.validation_failed"
+	} else if m == http.MethodDelete && strings.HasPrefix(p, "/api/skins/") && code == http.StatusNoContent {
+		key = "api.skins.delete.success"
+	} else if m == http.MethodDelete && strings.HasPrefix(p, "/api/skins/") && code == http.StatusNotFound {
+		key = "api.skins.delete.not_found"
+	} else {
+		return
+	}
+
+	s.IncCounter(key, 1)
+}
+
+func (s *StatsReporter) incCounterHandler(name string) func(...interface{}) {
+	return func(...interface{}) {
+		s.IncCounter(name, 1)
+	}
+}
+
+func (s *StatsReporter) startTimeRecording(timeKey string) {
+	s.timersMutex.Lock()
+	defer s.timersMutex.Unlock()
+	s.timersMap[timeKey] = time.Now()
+}
+
+func (s *StatsReporter) finalizeTimeRecording(timeKey string, statName string) {
+	s.timersMutex.Lock()
+	defer s.timersMutex.Unlock()
+	startedAt, ok := s.timersMap[timeKey]
+	if !ok {
+		return
+	}
+
+	delete(s.timersMap, timeKey)
+
+	s.RecordTimer(statName, time.Since(startedAt))
+}

eventsubscribers/stats_reporter_test.go

@@ -0,0 +1,402 @@
+package eventsubscribers
+
+import (
+	"errors"
+	"net/http/httptest"
+	"testing"
+	"time"
+
+	"github.com/mono83/slf"
+
+	"github.com/elyby/chrly/api/mojang"
+	"github.com/elyby/chrly/dispatcher"
+
+	"github.com/stretchr/testify/mock"
+)
+
+func prepareStatsReporterArgs(name string, value interface{}, params []slf.Param) []interface{} {
+	args := []interface{}{name, value}
+	for _, v := range params {
+		args = append(args, v.(interface{}))
+	}
+
+	return args
+}
+
+type StatsReporterMock struct {
+	mock.Mock
+}
+
+func (r *StatsReporterMock) IncCounter(name string, value int64, params ...slf.Param) {
+	r.Called(prepareStatsReporterArgs(name, value, params)...)
+}
+
+func (r *StatsReporterMock) UpdateGauge(name string, value int64, params ...slf.Param) {
+	r.Called(prepareStatsReporterArgs(name, value, params)...)
+}
+
+func (r *StatsReporterMock) RecordTimer(name string, duration time.Duration, params ...slf.Param) {
+	r.Called(prepareStatsReporterArgs(name, duration, params)...)
+}
+
+func (r *StatsReporterMock) Timer(name string, params ...slf.Param) slf.Timer {
+	return slf.NewTimer(name, params, r)
+}
+
+type StatsReporterTestCase struct {
+	Events        [][]interface{}
+	ExpectedCalls [][]interface{}
+}
+
+var statsReporterTestCases = []*StatsReporterTestCase{
+	// Before request
+	{
+		Events: [][]interface{}{
+			{"skinsystem:before_request", httptest.NewRequest("GET", "http://localhost/skins/username", nil)},
+		},
+		ExpectedCalls: [][]interface{}{
+			{"IncCounter", "skins.request", int64(1)},
+		},
+	},
+	{
+		Events: [][]interface{}{
+			{"skinsystem:before_request", httptest.NewRequest("GET", "http://localhost/skins?name=username", nil)},
+		},
+		ExpectedCalls: [][]interface{}{
+			{"IncCounter", "skins.get_request", int64(1)},
+		},
+	},
+	{
+		Events: [][]interface{}{
+			{"skinsystem:before_request", httptest.NewRequest("GET", "http://localhost/cloaks/username", nil)},
+		},
+		ExpectedCalls: [][]interface{}{
+			{"IncCounter", "capes.request", int64(1)},
+		},
+	},
+	{
+		Events: [][]interface{}{
+			{"skinsystem:before_request", httptest.NewRequest("GET", "http://localhost/cloaks?name=username", nil)},
+		},
+		ExpectedCalls: [][]interface{}{
+			{"IncCounter", "capes.get_request", int64(1)},
+		},
+	},
+	{
+		Events: [][]interface{}{
+			{"skinsystem:before_request", httptest.NewRequest("GET", "http://localhost/textures/username", nil)},
+		},
+		ExpectedCalls: [][]interface{}{
+			{"IncCounter", "textures.request", int64(1)},
+		},
+	},
+	{
+		Events: [][]interface{}{
+			{"skinsystem:before_request", httptest.NewRequest("GET", "http://localhost/textures/signed/username", nil)},
+		},
+		ExpectedCalls: [][]interface{}{
+			{"IncCounter", "signed_textures.request", int64(1)},
+		},
+	},
+	{
+		Events: [][]interface{}{
+			{"skinsystem:before_request", httptest.NewRequest("GET", "http://localhost/profile/username", nil)},
+		},
+		ExpectedCalls: [][]interface{}{
+			{"IncCounter", "profiles.request", int64(1)},
+		},
+	},
+	{
+		Events: [][]interface{}{
+			{"skinsystem:before_request", httptest.NewRequest("POST", "http://localhost/api/skins", nil)},
+		},
+		ExpectedCalls: [][]interface{}{
+			{"IncCounter", "api.skins.post.request", int64(1)},
+		},
+	},
+	{
+		Events: [][]interface{}{
+			{"skinsystem:before_request", httptest.NewRequest("DELETE", "http://localhost/api/skins/username", nil)},
+		},
+		ExpectedCalls: [][]interface{}{
+			{"IncCounter", "api.skins.delete.request", int64(1)},
+		},
+	},
+	{
+		Events: [][]interface{}{
+			{"skinsystem:before_request", httptest.NewRequest("DELETE", "http://localhost/api/skins/id:1", nil)},
+		},
+		ExpectedCalls: [][]interface{}{
+			{"IncCounter", "api.skins.delete.request", int64(1)},
+		},
+	},
+	{
+		Events: [][]interface{}{
+			{"skinsystem:before_request", httptest.NewRequest("GET", "http://localhost/unknown", nil)},
+		},
+		ExpectedCalls: nil,
+	},
+	// After request
+	{
+		Events: [][]interface{}{
+			{"skinsystem:after_request", httptest.NewRequest("POST", "http://localhost/api/skins", nil), 201},
+		},
+		ExpectedCalls: [][]interface{}{
+			{"IncCounter", "api.skins.post.success", int64(1)},
+		},
+	},
+	{
+		Events: [][]interface{}{
+			{"skinsystem:after_request", httptest.NewRequest("POST", "http://localhost/api/skins", nil), 400},
+		},
+		ExpectedCalls: [][]interface{}{
+			{"IncCounter", "api.skins.post.validation_failed", int64(1)},
+		},
+	},
+	{
+		Events: [][]interface{}{
+			{"skinsystem:after_request", httptest.NewRequest("DELETE", "http://localhost/api/skins/username", nil), 204},
+		},
+		ExpectedCalls: [][]interface{}{
+			{"IncCounter", "api.skins.delete.success", int64(1)},
+		},
+	},
+	{
+		Events: [][]interface{}{
+			{"skinsystem:after_request", httptest.NewRequest("DELETE", "http://localhost/api/skins/username", nil), 404},
+		},
+		ExpectedCalls: [][]interface{}{
+			{"IncCounter", "api.skins.delete.not_found", int64(1)},
+		},
+	},
+	{
+		Events: [][]interface{}{
+			{"skinsystem:after_request", httptest.NewRequest("DELETE", "http://localhost/api/skins/id:1", nil), 204},
+		},
+		ExpectedCalls: [][]interface{}{
+			{"IncCounter", "api.skins.delete.success", int64(1)},
+		},
+	},
+	{
+		Events: [][]interface{}{
+			{"skinsystem:after_request", httptest.NewRequest("DELETE", "http://localhost/api/skins/id:1", nil), 404},
+		},
+		ExpectedCalls: [][]interface{}{
+			{"IncCounter", "api.skins.delete.not_found", int64(1)},
+		},
+	},
+	{
+		Events: [][]interface{}{
+			{"skinsystem:after_request", httptest.NewRequest("DELETE", "http://localhost/unknown", nil), 404},
+		},
+		ExpectedCalls: nil,
+	},
+	// Authenticator
+	{
+		Events: [][]interface{}{
+			{"authenticator:success"},
+		},
+		ExpectedCalls: [][]interface{}{
+			{"IncCounter", "authentication.challenge", int64(1)},
+			{"IncCounter", "authentication.success", int64(1)},
+		},
+	},
+	{
+		Events: [][]interface{}{
+			{"authentication:error", errors.New("error")},
+		},
+		ExpectedCalls: [][]interface{}{
+			{"IncCounter", "authentication.challenge", int64(1)},
+			{"IncCounter", "authentication.failed", int64(1)},
+		},
+	},
+	// Mojang signed textures provider
+	{
+		Events: [][]interface{}{
+			{"mojang_textures:call", "username"},
+		},
+		ExpectedCalls: [][]interface{}{
+			{"IncCounter", "mojang_textures.request", int64(1)},
+		},
+	},
+	{
+		Events: [][]interface{}{
+			{"mojang_textures:usernames:after_cache", "username", "", false, errors.New("error")},
+		},
+		ExpectedCalls: [][]interface{}{},
+	},
+	{
+		Events: [][]interface{}{
+			{"mojang_textures:usernames:after_cache", "username", "", false, nil},
+		},
+		ExpectedCalls: [][]interface{}{},
+	},
+	{
+		Events: [][]interface{}{
+			{"mojang_textures:usernames:after_cache", "username", "", true, nil},
+		},
+		ExpectedCalls: [][]interface{}{
+			{"IncCounter", "mojang_textures.usernames.cache_hit_nil", int64(1)},
+		},
+	},
+	{
+		Events: [][]interface{}{
+			{"mojang_textures:usernames:after_cache", "username", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", true, nil},
+		},
+		ExpectedCalls: [][]interface{}{
+			{"IncCounter", "mojang_textures.usernames.cache_hit", int64(1)},
+		},
+	},
+	{
+		Events: [][]interface{}{
+			{"mojang_textures:textures:after_cache", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", nil, errors.New("error")},
+		},
+		ExpectedCalls: [][]interface{}{},
+	},
+	{
+		Events: [][]interface{}{
+			{"mojang_textures:textures:after_cache", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", nil, nil},
+		},
+		ExpectedCalls: [][]interface{}{},
+	},
+	{
+		Events: [][]interface{}{
+			{"mojang_textures:textures:after_cache", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", &mojang.SignedTexturesResponse{}, nil},
+		},
+		ExpectedCalls: [][]interface{}{
+			{"IncCounter", "mojang_textures.textures.cache_hit", int64(1)},
+		},
+	},
+	{
+		Events: [][]interface{}{
+			{"mojang_textures:already_processing", "username"},
+		},
+		ExpectedCalls: [][]interface{}{
+			{"IncCounter", "mojang_textures.already_scheduled", int64(1)},
+		},
+	},
+	{
+		Events: [][]interface{}{
+			{"mojang_textures:usernames:after_call", "username", nil, errors.New("error")},
+		},
+		ExpectedCalls: [][]interface{}{},
+	},
+	{
+		Events: [][]interface{}{
+			{"mojang_textures:usernames:after_call", "username", nil, nil},
+		},
+		ExpectedCalls: [][]interface{}{
+			{"IncCounter", "mojang_textures.usernames.uuid_miss", int64(1)},
+		},
+	},
+	{
+		Events: [][]interface{}{
+			{"mojang_textures:usernames:after_call", "username", &mojang.ProfileInfo{}, nil},
+		},
+		ExpectedCalls: [][]interface{}{
+			{"IncCounter", "mojang_textures.usernames.uuid_hit", int64(1)},
+		},
+	},
+	{
+		Events: [][]interface{}{
+			{"mojang_textures:textures:after_call", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", nil, errors.New("error")},
+		},
+		ExpectedCalls: [][]interface{}{},
+	},
+	{
+		Events: [][]interface{}{
+			{"mojang_textures:textures:after_call", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", nil, nil},
+		},
+		ExpectedCalls: [][]interface{}{
+			{"IncCounter", "mojang_textures.usernames.textures_miss", int64(1)},
+		},
+	},
+	{
+		Events: [][]interface{}{
+			{"mojang_textures:textures:after_call", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", &mojang.SignedTexturesResponse{}, nil},
+		},
+		ExpectedCalls: [][]interface{}{
+			{"IncCounter", "mojang_textures.usernames.textures_hit", int64(1)},
+		},
+	},
+	{
+		Events: [][]interface{}{
+			{"mojang_textures:before_result", "username", ""},
+			{"mojang_textures:after_result", "username", &mojang.SignedTexturesResponse{}, nil},
+		},
+		ExpectedCalls: [][]interface{}{
+			{"RecordTimer", "mojang_textures.result_time", mock.AnythingOfType("time.Duration")},
+		},
+	},
+	{
+		Events: [][]interface{}{
+			{"mojang_textures:textures:before_call", "аааааааааааааааааааааааааааааааа"},
+			{"mojang_textures:textures:after_call", "аааааааааааааааааааааааааааааааа", &mojang.SignedTexturesResponse{}, nil},
+		},
+		ExpectedCalls: [][]interface{}{
+			{"IncCounter", "mojang_textures.textures.request", int64(1)},
+			{"IncCounter", "mojang_textures.usernames.textures_hit", int64(1)},
+			{"RecordTimer", "mojang_textures.textures.request_time", mock.AnythingOfType("time.Duration")},
+		},
+	},
+	// Batch UUIDs provider
+	{
+		Events: [][]interface{}{
+			{"mojang_textures:batch_uuids_provider:queued", "username"},
+		},
+		ExpectedCalls: [][]interface{}{
+			{"IncCounter", "mojang_textures.usernames.queued", int64(1)},
+		},
+	},
+	{
+		Events: [][]interface{}{
+			{"mojang_textures:batch_uuids_provider:round", []string{"username1", "username2"}, 5},
+			{"mojang_textures:batch_uuids_provider:result", []string{"username1", "username2"}, []*mojang.ProfileInfo{}, nil},
+		},
+		ExpectedCalls: [][]interface{}{
+			{"UpdateGauge", "mojang_textures.usernames.iteration_size", int64(2)},
+			{"UpdateGauge", "mojang_textures.usernames.queue_size", int64(5)},
+			{"RecordTimer", "mojang_textures.usernames.round_time", mock.AnythingOfType("time.Duration")},
+		},
+	},
+	{
+		Events: [][]interface{}{
+			{"mojang_textures:batch_uuids_provider:round", []string{}, 0},
+			// This event will be not emitted, but we emit it to ensure, that RecordTimer will not be called
+			{"mojang_textures:batch_uuids_provider:result", []string{}, []*mojang.ProfileInfo{}, nil},
+		},
+		ExpectedCalls: [][]interface{}{
+			{"UpdateGauge", "mojang_textures.usernames.iteration_size", int64(0)},
+			{"UpdateGauge", "mojang_textures.usernames.queue_size", int64(0)},
+			// Should not call RecordTimer
+		},
+	},
+}
+
+func TestStatsReporter(t *testing.T) {
+	for _, c := range statsReporterTestCases {
+		t.Run("handle events", func(t *testing.T) {
+			statsReporterMock := &StatsReporterMock{}
+			if c.ExpectedCalls != nil {
+				for _, c := range c.ExpectedCalls {
+					topicName, _ := c[0].(string)
+					statsReporterMock.On(topicName, c[1:]...).Once()
+				}
+			}
+
+			reporter := &StatsReporter{
+				StatsReporter: statsReporterMock,
+				Prefix:        "mock_prefix",
+			}
+
+			d := dispatcher.New()
+			reporter.ConfigureWithDispatcher(d)
+			for _, e := range c.Events {
+				eventName, _ := e[0].(string)
+				d.Emit(eventName, e[1:]...)
+			}
+
+			statsReporterMock.AssertExpectations(t)
+		})
+	}
+}

eventsubscribers/subscriber.go

@@ -0,0 +1,7 @@
+package eventsubscribers
+
+import "github.com/elyby/chrly/dispatcher"
+
+type Subscriber interface {
+	dispatcher.Subscriber
+}

go.mod

@@ -0,0 +1,55 @@
+module github.com/elyby/chrly
+
+go 1.21
+
+replace github.com/asaskevich/EventBus v0.0.0-20200330115301-33b3bc6a7ddc => github.com/erickskrauch/EventBus v0.0.0-20200330115301-33b3bc6a7ddc
+
+// Main dependencies
+require (
+	github.com/SermoDigital/jose v0.9.2-0.20161205224733-f6df55f235c2
+	github.com/asaskevich/EventBus v0.0.0-20200330115301-33b3bc6a7ddc
+	github.com/defval/di v1.12.0
+	github.com/etherlabsio/healthcheck/v2 v2.0.0
+	github.com/getsentry/raven-go v0.2.1-0.20190419175539-919484f041ea
+	github.com/gorilla/mux v1.8.1
+	github.com/mediocregopher/radix/v4 v4.1.4
+	github.com/mono83/slf v0.0.0-20170919161409-79153e9636db
+	github.com/spf13/cobra v1.8.0
+	github.com/spf13/viper v1.18.1
+	github.com/thedevsaddam/govalidator v1.9.10
+)
+
+// Dev dependencies
+require (
+	github.com/h2non/gock v1.2.0
+	github.com/stretchr/testify v1.8.4
+)
+
+require (
+	github.com/certifi/gocertifi v0.0.0-20210507211836-431795d63e8d // indirect
+	github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc // indirect
+	github.com/fsnotify/fsnotify v1.7.0 // indirect
+	github.com/h2non/parth v0.0.0-20190131123155-b4df798d6542 // indirect
+	github.com/hashicorp/hcl v1.0.0 // indirect
+	github.com/inconshreveable/mousetrap v1.1.0 // indirect
+	github.com/magiconair/properties v1.8.7 // indirect
+	github.com/mitchellh/mapstructure v1.5.0 // indirect
+	github.com/mono83/udpwriter v1.0.2 // indirect
+	github.com/pelletier/go-toml/v2 v2.1.1 // indirect
+	github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 // indirect
+	github.com/sagikazarmark/locafero v0.4.0 // indirect
+	github.com/sagikazarmark/slog-shim v0.1.0 // indirect
+	github.com/sourcegraph/conc v0.3.0 // indirect
+	github.com/spf13/afero v1.11.0 // indirect
+	github.com/spf13/cast v1.6.0 // indirect
+	github.com/spf13/pflag v1.0.5 // indirect
+	github.com/stretchr/objx v0.5.0 // indirect
+	github.com/subosito/gotenv v1.6.0 // indirect
+	github.com/tilinna/clock v1.0.2 // indirect
+	go.uber.org/multierr v1.11.0 // indirect
+	golang.org/x/exp v0.0.0-20231206192017-f3f8817b8deb // indirect
+	golang.org/x/sys v0.15.0 // indirect
+	golang.org/x/text v0.14.0 // indirect
+	gopkg.in/ini.v1 v1.67.0 // indirect
+	gopkg.in/yaml.v3 v3.0.1 // indirect
+)

go.sum

@@ -0,0 +1,106 @@
+github.com/SermoDigital/jose v0.9.2-0.20161205224733-f6df55f235c2 h1:koK7z0nSsRiRiBWwa+E714Puh+DO+ZRdIyAXiXzL+lg=
+github.com/SermoDigital/jose v0.9.2-0.20161205224733-f6df55f235c2/go.mod h1:ARgCUhI1MHQH+ONky/PAtmVHQrP5JlGY0F3poXOp/fA=
+github.com/certifi/gocertifi v0.0.0-20210507211836-431795d63e8d h1:S2NE3iHSwP0XV47EEXL8mWmRdEfGscSJ+7EgePNgt0s=
+github.com/certifi/gocertifi v0.0.0-20210507211836-431795d63e8d/go.mod h1:sGbDF6GwGcLpkNXPUTkMRoywsNa/ol15pxFe6ERfguA=
+github.com/cpuguy83/go-md2man/v2 v2.0.3/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o=
+github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc h1:U9qPSI2PIWSS1VwoXQT9A3Wy9MM3WgvqSxFWenqJduM=
+github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/defval/di v1.12.0 h1:xXm7BMX2+Nr0Yyu55DeJl/rmfCA7CQX89f4AGE0zA6U=
+github.com/defval/di v1.12.0/go.mod h1:PhVbOxQOvU7oawTOJXXTvqOJp1Dvsjs5PuzMw9gGl0I=
+github.com/erickskrauch/EventBus v0.0.0-20200330115301-33b3bc6a7ddc h1:kz3f5uMA1LxfRvJjZmMYG7Zu2rddTfJy6QZofz2YoGQ=
+github.com/erickskrauch/EventBus v0.0.0-20200330115301-33b3bc6a7ddc/go.mod h1:RHSo3YFV/SbOGyFR36RKWaXPy3g9nKAmn6ebNLpbco4=
+github.com/etherlabsio/healthcheck/v2 v2.0.0 h1:oKq8cbpwM/yNGPXf2Sff6MIjVUjx/pGYFydWzeK2MpA=
+github.com/etherlabsio/healthcheck/v2 v2.0.0/go.mod h1:huNVOjKzu6FI1eaO1CGD3ZjhrmPWf5Obu/pzpI6/wog=
+github.com/frankban/quicktest v1.14.6 h1:7Xjx+VpznH+oBnejlPUj8oUpdxnVs4f8XU8WnHkI4W8=
+github.com/frankban/quicktest v1.14.6/go.mod h1:4ptaffx2x8+WTWXmUCuVU6aPUX1/Mz7zb5vbUoiM6w0=
+github.com/fsnotify/fsnotify v1.7.0 h1:8JEhPFa5W2WU7YfeZzPNqzMP6Lwt7L2715Ggo0nosvA=
+github.com/fsnotify/fsnotify v1.7.0/go.mod h1:40Bi/Hjc2AVfZrqy+aj+yEI+/bRxZnMJyTJwOpGvigM=
+github.com/getsentry/raven-go v0.2.1-0.20190419175539-919484f041ea h1:t6e33/eet/VyiHHHKs0cBytUISUWQ/hmQwOlqtFoGEo=
+github.com/getsentry/raven-go v0.2.1-0.20190419175539-919484f041ea/go.mod h1:KungGk8q33+aIAZUIVWZDr2OfAEBsO49PX4NzFV5kcQ=
+github.com/google/go-cmp v0.5.9 h1:O2Tfq5qg4qc4AmwVlvv0oLiVAGB7enBSJ2x2DqQFi38=
+github.com/google/go-cmp v0.5.9/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
+github.com/gorilla/mux v1.8.1 h1:TuBL49tXwgrFYWhqrNgrUNEY92u81SPhu7sTdzQEiWY=
+github.com/gorilla/mux v1.8.1/go.mod h1:AKf9I4AEqPTmMytcMc0KkNouC66V3BtZ4qD5fmWSiMQ=
+github.com/h2non/gock v1.2.0 h1:K6ol8rfrRkUOefooBC8elXoaNGYkpp7y2qcxGG6BzUE=
+github.com/h2non/gock v1.2.0/go.mod h1:tNhoxHYW2W42cYkYb1WqzdbYIieALC99kpYr7rH/BQk=
+github.com/h2non/parth v0.0.0-20190131123155-b4df798d6542 h1:2VTzZjLZBgl62/EtslCrtky5vbi9dd7HrQPQIx6wqiw=
+github.com/h2non/parth v0.0.0-20190131123155-b4df798d6542/go.mod h1:Ow0tF8D4Kplbc8s8sSb3V2oUCygFHVp8gC3Dn6U4MNI=
+github.com/hashicorp/hcl v1.0.0 h1:0Anlzjpi4vEasTeNFn2mLJgTSwt0+6sfsiTG8qcWGx4=
+github.com/hashicorp/hcl v1.0.0/go.mod h1:E5yfLk+7swimpb2L/Alb/PJmXilQ/rhwaUYs4T20WEQ=
+github.com/inconshreveable/mousetrap v1.1.0 h1:wN+x4NVGpMsO7ErUn/mUI3vEoE6Jt13X2s0bqwp9tc8=
+github.com/inconshreveable/mousetrap v1.1.0/go.mod h1:vpF70FUmC8bwa3OWnCshd2FqLfsEA9PFc4w1p2J65bw=
+github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
+github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk=
+github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
+github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
+github.com/magiconair/properties v1.8.7 h1:IeQXZAiQcpL9mgcAe1Nu6cX9LLw6ExEHKjN0VQdvPDY=
+github.com/magiconair/properties v1.8.7/go.mod h1:Dhd985XPs7jluiymwWYZ0G4Z61jb3vdS329zhj2hYo0=
+github.com/mediocregopher/radix/v4 v4.1.4 h1:Uze6DEbEAvL+VHXUEu/EDBTkUk5CLct5h3nVSGpc6Ts=
+github.com/mediocregopher/radix/v4 v4.1.4/go.mod h1:ajchozX/6ELmydxWeWM6xCFHVpZ4+67LXHOTOVR0nCE=
+github.com/mitchellh/mapstructure v1.5.0 h1:jeMsZIYE/09sWLaz43PL7Gy6RuMjD2eJVyuac5Z2hdY=
+github.com/mitchellh/mapstructure v1.5.0/go.mod h1:bFUtVrKA4DC2yAKiSyO/QUcy7e+RRV2QTWOzhPopBRo=
+github.com/mono83/slf v0.0.0-20170919161409-79153e9636db h1:tlz4fTklh5mttoq5M+0yEc5Lap8W/02A2HCXCJn5iz0=
+github.com/mono83/slf v0.0.0-20170919161409-79153e9636db/go.mod h1:MfF+zNMZz+5IGY9h8jpFaGLyGoJ2ZPri2FmUVftBoUU=
+github.com/mono83/udpwriter v1.0.2 h1:JiQ/N646oZoJA1G0FOMvn2teMt6SdL1KwNH2mszOlQs=
+github.com/mono83/udpwriter v1.0.2/go.mod h1:mTDiyLtA0tXoxckkV9T4NUkJTgSQIuO8pAUKx/dSRkQ=
+github.com/nbio/st v0.0.0-20140626010706-e9e8d9816f32 h1:W6apQkHrMkS0Muv8G/TipAy/FJl/rCYT0+EuS8+Z0z4=
+github.com/nbio/st v0.0.0-20140626010706-e9e8d9816f32/go.mod h1:9wM+0iRr9ahx58uYLpLIr5fm8diHn0JbqRycJi6w0Ms=
+github.com/pelletier/go-toml/v2 v2.1.1 h1:LWAJwfNvjQZCFIDKWYQaM62NcYeYViCmWIwmOStowAI=
+github.com/pelletier/go-toml/v2 v2.1.1/go.mod h1:tJU2Z3ZkXwnxa4DPO899bsyIoywizdUvyaeZurnPPDc=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 h1:Jamvg5psRIccs7FGNTlIRMkT8wgtp5eCXdBlqhYGL6U=
+github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/rogpeppe/go-internal v1.9.0 h1:73kH8U+JUqXU8lRuOHeVHaa/SZPifC7BkcraZVejAe8=
+github.com/rogpeppe/go-internal v1.9.0/go.mod h1:WtVeX8xhTBvf0smdhujwtBcq4Qrzq/fJaraNFVN+nFs=
+github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
+github.com/sagikazarmark/locafero v0.4.0 h1:HApY1R9zGo4DBgr7dqsTH/JJxLTTsOt7u6keLGt6kNQ=
+github.com/sagikazarmark/locafero v0.4.0/go.mod h1:Pe1W6UlPYUk/+wc/6KFhbORCfqzgYEpgQ3O5fPuL3H4=
+github.com/sagikazarmark/slog-shim v0.1.0 h1:diDBnUNK9N/354PgrxMywXnAwEr1QZcOr6gto+ugjYE=
+github.com/sagikazarmark/slog-shim v0.1.0/go.mod h1:SrcSrq8aKtyuqEI1uvTDTK1arOWRIczQRv+GVI1AkeQ=
+github.com/sourcegraph/conc v0.3.0 h1:OQTbbt6P72L20UqAkXXuLOj79LfEanQ+YQFNpLA9ySo=
+github.com/sourcegraph/conc v0.3.0/go.mod h1:Sdozi7LEKbFPqYX2/J+iBAM6HpqSLTASQIKqDmF7Mt0=
+github.com/spf13/afero v1.11.0 h1:WJQKhtpdm3v2IzqG8VMqrr6Rf3UYpEF239Jy9wNepM8=
+github.com/spf13/afero v1.11.0/go.mod h1:GH9Y3pIexgf1MTIWtNGyogA5MwRIDXGUr+hbWNoBjkY=
+github.com/spf13/cast v1.6.0 h1:GEiTHELF+vaR5dhz3VqZfFSzZjYbgeKDpBxQVS4GYJ0=
+github.com/spf13/cast v1.6.0/go.mod h1:ancEpBxwJDODSW/UG4rDrAqiKolqNNh2DX3mk86cAdo=
+github.com/spf13/cobra v1.8.0 h1:7aJaZx1B85qltLMc546zn58BxxfZdR/W22ej9CFoEf0=
+github.com/spf13/cobra v1.8.0/go.mod h1:WXLWApfZ71AjXPya3WOlMsY9yMs7YeiHhFVlvLyhcho=
+github.com/spf13/pflag v1.0.5 h1:iy+VFUOCP1a+8yFto/drg2CJ5u0yRoB7fZw3DKv/JXA=
+github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
+github.com/spf13/viper v1.18.1 h1:rmuU42rScKWlhhJDyXZRKJQHXFX02chSVW1IvkPGiVM=
+github.com/spf13/viper v1.18.1/go.mod h1:EKmWIqdnk5lOcmR72yw6hS+8OPYcwD0jteitLMVB+yk=
+github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
+github.com/stretchr/objx v0.5.0 h1:1zr/of2m5FGMsad5YfcqgdqdWrIhu+EBEJRhR1U7z/c=
+github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=
+github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
+github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
+github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk=
+github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
+github.com/subosito/gotenv v1.6.0 h1:9NlTDc1FTs4qu0DDq7AEtTPNw6SVm7uBMsUCUjABIf8=
+github.com/subosito/gotenv v1.6.0/go.mod h1:Dk4QP5c2W3ibzajGcXpNraDfq2IrhjMIvMSWPKKo0FU=
+github.com/thedevsaddam/govalidator v1.9.10 h1:m3dLRbSZ5Hts3VUWYe+vxLMG+FdyQuWOjzTeQRiMCvU=
+github.com/thedevsaddam/govalidator v1.9.10/go.mod h1:Ilx8u7cg5g3LXbSS943cx5kczyNuUn7LH/cK5MYuE90=
+github.com/tilinna/clock v1.0.2 h1:6BO2tyAC9JbPExKH/z9zl44FLu1lImh3nDNKA0kgrkI=
+github.com/tilinna/clock v1.0.2/go.mod h1:ZsP7BcY7sEEz7ktc0IVy8Us6boDrK8VradlKRUGfOao=
+go.uber.org/multierr v1.11.0 h1:blXXJkSxSSfBVBlC76pxqeO+LN3aDfLQo+309xJstO0=
+go.uber.org/multierr v1.11.0/go.mod h1:20+QtiLqy0Nd6FdQB9TLXag12DsQkrbs3htMFfDN80Y=
+golang.org/x/exp v0.0.0-20231206192017-f3f8817b8deb h1:c0vyKkb6yr3KR7jEfJaOSv4lG7xPkbN6r52aJz1d8a8=
+golang.org/x/exp v0.0.0-20231206192017-f3f8817b8deb/go.mod h1:iRJReGqOEeBhDZGkGbynYwcHlctCvnjTYIamk7uXpHI=
+golang.org/x/sys v0.15.0 h1:h48lPFYpsTvQJZF4EKyI4aLHaev3CxivZmv7yZig9pc=
+golang.org/x/sys v0.15.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/text v0.14.0 h1:ScX5w1eTa3QqT8oi6+ziP7dTV1S2+ALU0bI+0zXKWiQ=
+golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15 h1:YR8cESwS4TdDjEe65xsg0ogRM/Nc3DYOhEAlW+xobZo=
+gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/ini.v1 v1.67.0 h1:Dgnx+6+nfE+IfzjUEISNeydPJh9AXNNsWbGP9KzCsOA=
+gopkg.in/ini.v1 v1.67.0/go.mod h1:pNLf8WUiyNEtQjuu5G5vTm06TEv9tsIgeAvK8hOrP4k=
+gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
+gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

http/api.go

@@ -0,0 +1,199 @@
+package http
+
+import (
+	"errors"
+	"fmt"
+	"net/http"
+	"regexp"
+	"strconv"
+
+	"github.com/gorilla/mux"
+	"github.com/thedevsaddam/govalidator"
+
+	"github.com/elyby/chrly/model"
+)
+
+// 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() {
+	// 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
+	})
+}
+
+type Api struct {
+	SkinsRepo SkinsRepository
+}
+
+func (ctx *Api) Handler() *mux.Router {
+	router := mux.NewRouter().StrictSlash(true)
+	router.HandleFunc("/skins", ctx.postSkinHandler).Methods(http.MethodPost)
+	router.HandleFunc("/skins/id:{id:[0-9]+}", ctx.deleteSkinByUserIdHandler).Methods(http.MethodDelete)
+	router.HandleFunc("/skins/{username}", ctx.deleteSkinByUsernameHandler).Methods(http.MethodDelete)
+
+	return router
+}
+
+func (ctx *Api) postSkinHandler(resp http.ResponseWriter, req *http.Request) {
+	validationErrors := validatePostSkinRequest(req)
+	if validationErrors != nil {
+		apiBadRequest(resp, validationErrors)
+		return
+	}
+
+	identityId, _ := strconv.Atoi(req.Form.Get("identityId"))
+	username := req.Form.Get("username")
+
+	record, err := ctx.findIdentityOrCleanup(identityId, username)
+	if err != nil {
+		panic(err)
+	}
+
+	if record == nil {
+		record = &model.Skin{
+			UserId:   identityId,
+			Username: username,
+		}
+	}
+
+	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 = ctx.SkinsRepo.SaveSkin(record)
+	if err != nil {
+		panic(err)
+	}
+
+	resp.WriteHeader(http.StatusCreated)
+}
+
+func (ctx *Api) deleteSkinByUserIdHandler(resp http.ResponseWriter, req *http.Request) {
+	id, _ := strconv.Atoi(mux.Vars(req)["id"])
+	skin, err := ctx.SkinsRepo.FindSkinByUserId(id)
+	ctx.deleteSkin(skin, err, resp)
+}
+
+func (ctx *Api) deleteSkinByUsernameHandler(resp http.ResponseWriter, req *http.Request) {
+	username := mux.Vars(req)["username"]
+	skin, err := ctx.SkinsRepo.FindSkinByUsername(username)
+	ctx.deleteSkin(skin, err, resp)
+}
+
+func (ctx *Api) deleteSkin(skin *model.Skin, err error, resp http.ResponseWriter) {
+	if err != nil {
+		panic(err)
+	}
+
+	if skin == nil {
+		apiNotFound(resp, "Cannot find record for the requested identifier")
+		return
+	}
+
+	err = ctx.SkinsRepo.RemoveSkinByUserId(skin.UserId)
+	if err != nil {
+		panic(err)
+	}
+
+	resp.WriteHeader(http.StatusNoContent)
+}
+
+func (ctx *Api) findIdentityOrCleanup(identityId int, username string) (*model.Skin, error) {
+	record, err := ctx.SkinsRepo.FindSkinByUserId(identityId)
+	if err != nil {
+		return nil, err
+	}
+
+	if record != nil {
+		// The username may have changed in the external database,
+		// so we need to remove the old association
+		if record.Username != username {
+			_ = ctx.SkinsRepo.RemoveSkinByUserId(identityId)
+			record.Username = username
+		}
+
+		return record, nil
+	}
+
+	// If the requested id was not found, then username was reassigned to another user
+	// who has not uploaded his data to Chrly yet
+	record, err = ctx.SkinsRepo.FindSkinByUsername(username)
+	if err != nil {
+		return nil, err
+	}
+
+	// If the target username does exist, clear it as it will be reassigned to the new user
+	if record != nil {
+		_ = ctx.SkinsRepo.RemoveSkinByUsername(username)
+		record.UserId = identityId
+
+		return record, nil
+	}
+
+	return nil, nil
+}
+
+func validatePostSkinRequest(request *http.Request) map[string][]string {
+	_ = request.ParseForm()
+
+	validationRules := govalidator.MapData{
+		"identityId":      {"required", "numeric", "min:1"},
+		"username":        {"required"},
+		"uuid":            {"required", "uuid_any"},
+		"skinId":          {"required", "numeric"},
+		"url":             {},
+		"is1_8":           {"bool"},
+		"isSlim":          {"bool"},
+		"mojangTextures":  {},
+		"mojangSignature": {},
+	}
+
+	url := request.Form.Get("url")
+	if url == "" {
+		validationRules["skinId"] = append(validationRules["skinId"], "numeric_between:0,0")
+	} else {
+		validationRules["url"] = append(validationRules["url"], "url")
+		validationRules["skinId"] = append(validationRules["skinId"], "numeric_between:1,")
+		validationRules["is1_8"] = append(validationRules["is1_8"], "required")
+		validationRules["isSlim"] = append(validationRules["isSlim"], "required")
+	}
+
+	mojangTextures := request.Form.Get("mojangTextures")
+	if mojangTextures != "" {
+		validationRules["mojangSignature"] = append(validationRules["mojangSignature"], "required")
+	}
+
+	validator := govalidator.New(govalidator.Options{
+		Request:         request,
+		Rules:           validationRules,
+		RequiredDefault: false,
+	})
+	validationResults := validator.Validate()
+
+	if len(validationResults) != 0 {
+		return validationResults
+	}
+
+	return nil
+}

http/api_test.go

@@ -0,0 +1,418 @@
+package http
+
+import (
+	"bytes"
+	"encoding/base64"
+	"errors"
+	"io"
+	"io/ioutil"
+	"net/http"
+	"net/http/httptest"
+	"net/url"
+	"testing"
+
+	"github.com/stretchr/testify/mock"
+	"github.com/stretchr/testify/suite"
+
+	"github.com/elyby/chrly/model"
+)
+
+/***************
+ * Setup mocks *
+ ***************/
+
+type apiTestSuite struct {
+	suite.Suite
+
+	App *Api
+
+	SkinsRepository *skinsRepositoryMock
+}
+
+/********************
+ * Setup test suite *
+ ********************/
+
+func (suite *apiTestSuite) SetupTest() {
+	suite.SkinsRepository = &skinsRepositoryMock{}
+
+	suite.App = &Api{
+		SkinsRepo: suite.SkinsRepository,
+	}
+}
+
+func (suite *apiTestSuite) TearDownTest() {
+	suite.SkinsRepository.AssertExpectations(suite.T())
+}
+
+func (suite *apiTestSuite) RunSubTest(name string, subTest func()) {
+	suite.SetupTest()
+	suite.Run(name, subTest)
+	suite.TearDownTest()
+}
+
+/*************
+ * Run tests *
+ *************/
+
+func TestApi(t *testing.T) {
+	suite.Run(t, new(apiTestSuite))
+}
+
+/*************************
+ * Post skin tests cases *
+ *************************/
+
+type postSkinTestCase struct {
+	Name       string
+	Form       io.Reader
+	BeforeTest func(suite *apiTestSuite)
+	PanicErr   string
+	AfterTest  func(suite *apiTestSuite, response *http.Response)
+}
+
+var postSkinTestsCases = []*postSkinTestCase{
+	{
+		Name: "Upload new identity with textures data",
+		Form: bytes.NewBufferString(url.Values{
+			"identityId": {"1"},
+			"username":   {"mock_username"},
+			"uuid":       {"0f657aa8-bfbe-415d-b700-5750090d3af3"},
+			"skinId":     {"5"},
+			"is1_8":      {"0"},
+			"isSlim":     {"0"},
+			"url":        {"http://example.com/skin.png"},
+		}.Encode()),
+		BeforeTest: func(suite *apiTestSuite) {
+			suite.SkinsRepository.On("FindSkinByUserId", 1).Return(nil, nil)
+			suite.SkinsRepository.On("FindSkinByUsername", "mock_username").Return(nil, nil)
+			suite.SkinsRepository.On("SaveSkin", mock.MatchedBy(func(model *model.Skin) bool {
+				suite.Equal(1, model.UserId)
+				suite.Equal("mock_username", model.Username)
+				suite.Equal("0f657aa8-bfbe-415d-b700-5750090d3af3", model.Uuid)
+				suite.Equal(5, model.SkinId)
+				suite.False(model.Is1_8)
+				suite.False(model.IsSlim)
+				suite.Equal("http://example.com/skin.png", model.Url)
+
+				return true
+			})).Times(1).Return(nil)
+		},
+		AfterTest: func(suite *apiTestSuite, response *http.Response) {
+			suite.Equal(201, response.StatusCode)
+			body, _ := ioutil.ReadAll(response.Body)
+			suite.Empty(body)
+		},
+	},
+	{
+		Name: "Update exists identity by changing only textures data",
+		Form: bytes.NewBufferString(url.Values{
+			"identityId": {"1"},
+			"username":   {"mock_username"},
+			"uuid":       {"0f657aa8-bfbe-415d-b700-5750090d3af3"},
+			"skinId":     {"5"},
+			"is1_8":      {"1"},
+			"isSlim":     {"1"},
+			"url":        {"http://textures-server.com/skin.png"},
+		}.Encode()),
+		BeforeTest: func(suite *apiTestSuite) {
+			suite.SkinsRepository.On("FindSkinByUserId", 1).Return(createSkinModel("mock_username", false), nil)
+			suite.SkinsRepository.On("SaveSkin", mock.MatchedBy(func(model *model.Skin) bool {
+				suite.Equal(1, model.UserId)
+				suite.Equal("mock_username", model.Username)
+				suite.Equal("0f657aa8-bfbe-415d-b700-5750090d3af3", model.Uuid)
+				suite.Equal(5, model.SkinId)
+				suite.True(model.Is1_8)
+				suite.True(model.IsSlim)
+				suite.Equal("http://textures-server.com/skin.png", model.Url)
+
+				return true
+			})).Times(1).Return(nil)
+		},
+		AfterTest: func(suite *apiTestSuite, response *http.Response) {
+			suite.Equal(201, response.StatusCode)
+			body, _ := ioutil.ReadAll(response.Body)
+			suite.Empty(body)
+		},
+	},
+	{
+		Name: "Update exists identity by changing textures data to empty",
+		Form: bytes.NewBufferString(url.Values{
+			"identityId":      {"1"},
+			"username":        {"mock_username"},
+			"uuid":            {"0f657aa8-bfbe-415d-b700-5750090d3af3"},
+			"skinId":          {"0"},
+			"is1_8":           {"0"},
+			"isSlim":          {"0"},
+			"url":             {""},
+			"mojangTextures":  {""},
+			"mojangSignature": {""},
+		}.Encode()),
+		BeforeTest: func(suite *apiTestSuite) {
+			suite.SkinsRepository.On("FindSkinByUserId", 1).Return(createSkinModel("mock_username", false), nil)
+			suite.SkinsRepository.On("SaveSkin", mock.MatchedBy(func(model *model.Skin) bool {
+				suite.Equal(1, model.UserId)
+				suite.Equal("mock_username", model.Username)
+				suite.Equal("0f657aa8-bfbe-415d-b700-5750090d3af3", model.Uuid)
+				suite.Equal(0, model.SkinId)
+				suite.False(model.Is1_8)
+				suite.False(model.IsSlim)
+				suite.Equal("", model.Url)
+				suite.Equal("", model.MojangTextures)
+				suite.Equal("", model.MojangSignature)
+
+				return true
+			})).Times(1).Return(nil)
+		},
+		AfterTest: func(suite *apiTestSuite, response *http.Response) {
+			suite.Equal(201, response.StatusCode)
+			body, _ := io.ReadAll(response.Body)
+			suite.Equal("", string(body))
+		},
+	},
+	{
+		Name: "Update exists identity by changing its identityId",
+		Form: bytes.NewBufferString(url.Values{
+			"identityId": {"2"},
+			"username":   {"mock_username"},
+			"uuid":       {"0f657aa8-bfbe-415d-b700-5750090d3af3"},
+			"skinId":     {"5"},
+			"is1_8":      {"0"},
+			"isSlim":     {"0"},
+			"url":        {"http://example.com/skin.png"},
+		}.Encode()),
+		BeforeTest: func(suite *apiTestSuite) {
+			suite.SkinsRepository.On("FindSkinByUserId", 2).Return(nil, nil)
+			suite.SkinsRepository.On("FindSkinByUsername", "mock_username").Return(createSkinModel("mock_username", false), nil)
+			suite.SkinsRepository.On("RemoveSkinByUsername", "mock_username").Times(1).Return(nil)
+			suite.SkinsRepository.On("SaveSkin", mock.MatchedBy(func(model *model.Skin) bool {
+				suite.Equal(2, model.UserId)
+				suite.Equal("mock_username", model.Username)
+				suite.Equal("0f657aa8-bfbe-415d-b700-5750090d3af3", model.Uuid)
+
+				return true
+			})).Times(1).Return(nil)
+		},
+		AfterTest: func(suite *apiTestSuite, response *http.Response) {
+			suite.Equal(201, response.StatusCode)
+			body, _ := ioutil.ReadAll(response.Body)
+			suite.Empty(body)
+		},
+	},
+	{
+		Name: "Update exists identity by changing its username",
+		Form: bytes.NewBufferString(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"},
+		}.Encode()),
+		BeforeTest: func(suite *apiTestSuite) {
+			suite.SkinsRepository.On("FindSkinByUserId", 1).Return(createSkinModel("mock_username", false), nil)
+			suite.SkinsRepository.On("RemoveSkinByUserId", 1).Times(1).Return(nil)
+			suite.SkinsRepository.On("SaveSkin", mock.MatchedBy(func(model *model.Skin) bool {
+				suite.Equal(1, model.UserId)
+				suite.Equal("changed_username", model.Username)
+				suite.Equal("0f657aa8-bfbe-415d-b700-5750090d3af3", model.Uuid)
+
+				return true
+			})).Times(1).Return(nil)
+		},
+		AfterTest: func(suite *apiTestSuite, response *http.Response) {
+			suite.Equal(201, response.StatusCode)
+			body, _ := ioutil.ReadAll(response.Body)
+			suite.Empty(body)
+		},
+	},
+	{
+		Name: "Handle an error when loading the data from the repository",
+		Form: bytes.NewBufferString(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"},
+		}.Encode()),
+		BeforeTest: func(suite *apiTestSuite) {
+			suite.SkinsRepository.On("FindSkinByUserId", 1).Return(nil, errors.New("can't find skin by user id"))
+		},
+		PanicErr: "can't find skin by user id",
+	},
+	{
+		Name: "Handle an error when saving the data into the repository",
+		Form: bytes.NewBufferString(url.Values{
+			"identityId": {"1"},
+			"username":   {"mock_username"},
+			"uuid":       {"0f657aa8-bfbe-415d-b700-5750090d3af3"},
+			"skinId":     {"5"},
+			"is1_8":      {"1"},
+			"isSlim":     {"1"},
+			"url":        {"http://textures-server.com/skin.png"},
+		}.Encode()),
+		BeforeTest: func(suite *apiTestSuite) {
+			suite.SkinsRepository.On("FindSkinByUserId", 1).Return(createSkinModel("mock_username", false), nil)
+			suite.SkinsRepository.On("SaveSkin", mock.Anything).Return(errors.New("can't save textures"))
+		},
+		PanicErr: "can't save textures",
+	},
+}
+
+func (suite *apiTestSuite) TestPostSkin() {
+	for _, testCase := range postSkinTestsCases {
+		suite.RunSubTest(testCase.Name, func() {
+			testCase.BeforeTest(suite)
+
+			req := httptest.NewRequest("POST", "http://chrly/skins", testCase.Form)
+			req.Header.Add("Content-Type", "application/x-www-form-urlencoded")
+			w := httptest.NewRecorder()
+
+			if testCase.PanicErr != "" {
+				suite.PanicsWithError(testCase.PanicErr, func() {
+					suite.App.Handler().ServeHTTP(w, req)
+				})
+			} else {
+				suite.App.Handler().ServeHTTP(w, req)
+				testCase.AfterTest(suite, w.Result())
+			}
+		})
+	}
+
+	suite.RunSubTest("Get errors about required fields", func() {
+		req := httptest.NewRequest("POST", "http://chrly/skins", bytes.NewBufferString(url.Values{
+			"mojangTextures": {"someBase64EncodedString"},
+		}.Encode()))
+		req.Header.Add("Content-Type", "application/x-www-form-urlencoded")
+		w := httptest.NewRecorder()
+
+		suite.App.Handler().ServeHTTP(w, req)
+
+		resp := w.Result()
+		defer resp.Body.Close()
+		suite.Equal(400, resp.StatusCode)
+		body, _ := ioutil.ReadAll(resp.Body)
+		suite.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 numeric value between 0 and 0"
+				],
+				"username": [
+					"The username field is required"
+				],
+				"uuid": [
+					"The uuid field is required",
+					"The uuid field must contain valid UUID"
+				],
+				"mojangSignature": [
+					"The mojangSignature field is required"
+				]
+			}
+		}`, string(body))
+	})
+}
+
+/**************************************
+ * Delete skin by user id tests cases *
+ **************************************/
+
+func (suite *apiTestSuite) TestDeleteByUserId() {
+	suite.RunSubTest("Delete skin by its identity id", func() {
+		suite.SkinsRepository.On("FindSkinByUserId", 1).Return(createSkinModel("mock_username", false), nil)
+		suite.SkinsRepository.On("RemoveSkinByUserId", 1).Once().Return(nil)
+
+		req := httptest.NewRequest("DELETE", "http://chrly/skins/id:1", nil)
+		w := httptest.NewRecorder()
+
+		suite.App.Handler().ServeHTTP(w, req)
+
+		resp := w.Result()
+		defer resp.Body.Close()
+		suite.Equal(204, resp.StatusCode)
+		body, _ := ioutil.ReadAll(resp.Body)
+		suite.Empty(body)
+	})
+
+	suite.RunSubTest("Try to remove not exists identity id", func() {
+		suite.SkinsRepository.On("FindSkinByUserId", 1).Return(nil, nil)
+
+		req := httptest.NewRequest("DELETE", "http://chrly/skins/id:1", nil)
+		w := httptest.NewRecorder()
+
+		suite.App.Handler().ServeHTTP(w, req)
+
+		resp := w.Result()
+		defer resp.Body.Close()
+		suite.Equal(404, resp.StatusCode)
+		body, _ := ioutil.ReadAll(resp.Body)
+		suite.JSONEq(`[
+			"Cannot find record for the requested identifier"
+		]`, string(body))
+	})
+}
+
+/***************************************
+ * Delete skin by username tests cases *
+ ***************************************/
+
+func (suite *apiTestSuite) TestDeleteByUsername() {
+	suite.RunSubTest("Delete skin by its identity username", func() {
+		suite.SkinsRepository.On("FindSkinByUsername", "mock_username").Return(createSkinModel("mock_username", false), nil)
+		suite.SkinsRepository.On("RemoveSkinByUserId", 1).Once().Return(nil)
+
+		req := httptest.NewRequest("DELETE", "http://chrly/skins/mock_username", nil)
+		w := httptest.NewRecorder()
+
+		suite.App.Handler().ServeHTTP(w, req)
+
+		resp := w.Result()
+		defer resp.Body.Close()
+		suite.Equal(204, resp.StatusCode)
+		body, _ := ioutil.ReadAll(resp.Body)
+		suite.Empty(body)
+	})
+
+	suite.RunSubTest("Try to remove not exists identity username", func() {
+		suite.SkinsRepository.On("FindSkinByUsername", "mock_username").Return(nil, nil)
+
+		req := httptest.NewRequest("DELETE", "http://chrly/skins/mock_username", nil)
+		w := httptest.NewRecorder()
+
+		suite.App.Handler().ServeHTTP(w, req)
+
+		resp := w.Result()
+		defer resp.Body.Close()
+		suite.Equal(404, resp.StatusCode)
+		body, _ := ioutil.ReadAll(resp.Body)
+		suite.JSONEq(`[
+			"Cannot find record for the requested identifier"
+		]`, string(body))
+	})
+}
+
+/*************
+ * Utilities *
+ *************/
+
+// 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
+}

http/http.go

@@ -0,0 +1,137 @@
+package http
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+	"os"
+	"os/signal"
+	"strings"
+	"syscall"
+
+	"github.com/gorilla/mux"
+	"github.com/mono83/slf"
+	"github.com/mono83/slf/wd"
+
+	"github.com/elyby/chrly/dispatcher"
+	v "github.com/elyby/chrly/version"
+)
+
+type Emitter interface {
+	dispatcher.Emitter
+}
+
+func StartServer(server *http.Server, logger slf.Logger) {
+	logger.Debug("Chrly :v (:c)", wd.StringParam("v", v.Version()), wd.StringParam("c", v.Commit()))
+
+	done := make(chan bool, 1)
+	go func() {
+		logger.Info("Starting the server, HTTP on: :addr", wd.StringParam("addr", server.Addr))
+		if err := server.ListenAndServe(); err != nil && err != http.ErrServerClosed {
+			logger.Emergency("Error in main(): :err", wd.ErrParam(err))
+			close(done)
+		}
+	}()
+
+	go func() {
+		s := waitForExitSignal()
+		logger.Info("Got signal: :signal, starting graceful shutdown", wd.StringParam("signal", s.String()))
+		_ = server.Shutdown(context.Background())
+		logger.Info("Graceful shutdown succeed, exiting", wd.StringParam("signal", s.String()))
+		close(done)
+	}()
+
+	<-done
+}
+
+func waitForExitSignal() os.Signal {
+	ch := make(chan os.Signal, 1)
+	signal.Notify(ch, os.Interrupt, syscall.SIGTERM, os.Kill)
+
+	return <-ch
+}
+
+type loggingResponseWriter struct {
+	http.ResponseWriter
+	statusCode int
+}
+
+func (lrw *loggingResponseWriter) WriteHeader(code int) {
+	lrw.statusCode = code
+	lrw.ResponseWriter.WriteHeader(code)
+}
+
+func CreateRequestEventsMiddleware(emitter Emitter, prefix string) mux.MiddlewareFunc {
+	beforeTopic := strings.Join([]string{prefix, "before_request"}, ":")
+	afterTopic := strings.Join([]string{prefix, "after_request"}, ":")
+
+	return func(handler http.Handler) http.Handler {
+		return http.HandlerFunc(func(resp http.ResponseWriter, req *http.Request) {
+			emitter.Emit(beforeTopic, req)
+
+			lrw := &loggingResponseWriter{
+				ResponseWriter: resp,
+				statusCode:     http.StatusOK,
+			}
+			handler.ServeHTTP(lrw, req)
+
+			emitter.Emit(afterTopic, req, lrw.statusCode)
+		})
+	}
+}
+
+type Authenticator interface {
+	Authenticate(req *http.Request) error
+}
+
+func CreateAuthenticationMiddleware(checker Authenticator) mux.MiddlewareFunc {
+	return func(handler http.Handler) http.Handler {
+		return http.HandlerFunc(func(resp http.ResponseWriter, req *http.Request) {
+			err := checker.Authenticate(req)
+			if err != nil {
+				apiForbidden(resp, err.Error())
+				return
+			}
+
+			handler.ServeHTTP(resp, req)
+		})
+	}
+}
+
+func NotFoundHandler(response http.ResponseWriter, _ *http.Request) {
+	data, _ := json.Marshal(map[string]string{
+		"status":  "404",
+		"message": "Not Found",
+	})
+
+	response.Header().Set("Content-Type", "application/json")
+	response.WriteHeader(http.StatusNotFound)
+	_, _ = response.Write(data)
+}
+
+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)
+}

http/http_test.go

@@ -0,0 +1,112 @@
+package http
+
+import (
+	"errors"
+	"io/ioutil"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	testify "github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/mock"
+)
+
+type emitterMock struct {
+	mock.Mock
+}
+
+func (e *emitterMock) Emit(name string, args ...interface{}) {
+	e.Called(append([]interface{}{name}, args...)...)
+}
+
+func TestCreateRequestEventsMiddleware(t *testing.T) {
+	req := httptest.NewRequest("GET", "http://example.com", nil)
+	resp := httptest.NewRecorder()
+
+	emitter := &emitterMock{}
+	emitter.On("Emit", "test_prefix:before_request", req)
+	emitter.On("Emit", "test_prefix:after_request", req, 400)
+
+	isHandlerCalled := false
+	middlewareFunc := CreateRequestEventsMiddleware(emitter, "test_prefix")
+	middlewareFunc.Middleware(http.HandlerFunc(func(resp http.ResponseWriter, req *http.Request) {
+		resp.WriteHeader(400)
+		isHandlerCalled = true
+	})).ServeHTTP(resp, req)
+
+	if !isHandlerCalled {
+		t.Fatal("Handler isn't called from the middleware")
+	}
+
+	emitter.AssertExpectations(t)
+}
+
+type authCheckerMock struct {
+	mock.Mock
+}
+
+func (m *authCheckerMock) Authenticate(req *http.Request) error {
+	args := m.Called(req)
+	return args.Error(0)
+}
+
+func TestCreateAuthenticationMiddleware(t *testing.T) {
+	t.Run("pass", func(t *testing.T) {
+		req := httptest.NewRequest("GET", "http://example.com", nil)
+		resp := httptest.NewRecorder()
+
+		auth := &authCheckerMock{}
+		auth.On("Authenticate", req).Once().Return(nil)
+
+		isHandlerCalled := false
+		middlewareFunc := CreateAuthenticationMiddleware(auth)
+		middlewareFunc.Middleware(http.HandlerFunc(func(resp http.ResponseWriter, req *http.Request) {
+			isHandlerCalled = true
+		})).ServeHTTP(resp, req)
+
+		testify.True(t, isHandlerCalled, "Handler isn't called from the middleware")
+
+		auth.AssertExpectations(t)
+	})
+
+	t.Run("fail", func(t *testing.T) {
+		req := httptest.NewRequest("GET", "http://example.com", nil)
+		resp := httptest.NewRecorder()
+
+		auth := &authCheckerMock{}
+		auth.On("Authenticate", req).Once().Return(errors.New("error reason"))
+
+		isHandlerCalled := false
+		middlewareFunc := CreateAuthenticationMiddleware(auth)
+		middlewareFunc.Middleware(http.HandlerFunc(func(resp http.ResponseWriter, req *http.Request) {
+			isHandlerCalled = true
+		})).ServeHTTP(resp, req)
+
+		testify.False(t, isHandlerCalled, "Handler shouldn't be called")
+		testify.Equal(t, 403, resp.Code)
+		body, _ := ioutil.ReadAll(resp.Body)
+		testify.JSONEq(t, `{
+			"error": "error reason"
+		}`, string(body))
+
+		auth.AssertExpectations(t)
+	})
+}
+
+func TestNotFoundHandler(t *testing.T) {
+	assert := testify.New(t)
+
+	req := httptest.NewRequest("GET", "http://example.com", nil)
+	w := httptest.NewRecorder()
+
+	NotFoundHandler(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"
+	}`, string(response))
+}

http/jwt.go

@@ -0,0 +1,78 @@
+package http
+
+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 {
+	Emitter
+	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) Authenticate(req *http.Request) error {
+	if len(t.Key) == 0 {
+		return t.emitErr(errors.New("Signing key not set"))
+	}
+
+	bearerToken := req.Header.Get("Authorization")
+	if bearerToken == "" {
+		return t.emitErr(errors.New("Authentication header not presented"))
+	}
+
+	if !strings.EqualFold(bearerToken[0:7], "BEARER ") {
+		return t.emitErr(errors.New("Cannot recognize JWT token in passed value"))
+	}
+
+	tokenStr := bearerToken[7:]
+	token, err := jws.ParseJWT([]byte(tokenStr))
+	if err != nil {
+		return t.emitErr(errors.New("Cannot parse passed JWT token"))
+	}
+
+	err = token.Validate(t.Key, hashAlg)
+	if err != nil {
+		return t.emitErr(errors.New("JWT token have invalid signature. It may be corrupted or expired"))
+	}
+
+	t.Emit("authentication:success")
+
+	return nil
+}
+
+func (t *JwtAuth) emitErr(err error) error {
+	t.Emit("authentication:error", err)
+	return err
+}

http/jwt_test.go

@@ -0,0 +1,127 @@
+package http
+
+import (
+	"net/http/httptest"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/mock"
+)
+
+const jwt = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxNTE2NjU4MTkzIiwic2NvcGVzIjoic2tpbiJ9.agbBS0qdyYMBaVfTZJAZcTTRgW1Y0kZty4H3N2JHBO8"
+
+func TestJwtAuth_NewToken(t *testing.T) {
+	t.Run("success", func(t *testing.T) {
+		jwt := &JwtAuth{Key: []byte("secret")}
+		token, err := jwt.NewToken(SkinScope)
+		assert.Nil(t, err)
+		assert.NotNil(t, token)
+	})
+
+	t.Run("key not provided", func(t *testing.T) {
+		jwt := &JwtAuth{}
+		token, err := jwt.NewToken(SkinScope)
+		assert.Error(t, err, "signing key not available")
+		assert.Nil(t, token)
+	})
+}
+
+func TestJwtAuth_Authenticate(t *testing.T) {
+	t.Run("success", func(t *testing.T) {
+		emitter := &emitterMock{}
+		emitter.On("Emit", "authentication:success")
+
+		req := httptest.NewRequest("POST", "http://localhost", nil)
+		req.Header.Add("Authorization", "Bearer "+jwt)
+		jwt := &JwtAuth{Key: []byte("secret"), Emitter: emitter}
+
+		err := jwt.Authenticate(req)
+		assert.Nil(t, err)
+
+		emitter.AssertExpectations(t)
+	})
+
+	t.Run("request without auth header", func(t *testing.T) {
+		emitter := &emitterMock{}
+		emitter.On("Emit", "authentication:error", mock.MatchedBy(func(err error) bool {
+			assert.Error(t, err, "Authentication header not presented")
+			return true
+		}))
+
+		req := httptest.NewRequest("POST", "http://localhost", nil)
+		jwt := &JwtAuth{Key: []byte("secret"), Emitter: emitter}
+
+		err := jwt.Authenticate(req)
+		assert.Error(t, err, "Authentication header not presented")
+
+		emitter.AssertExpectations(t)
+	})
+
+	t.Run("no bearer token prefix", func(t *testing.T) {
+		emitter := &emitterMock{}
+		emitter.On("Emit", "authentication:error", mock.MatchedBy(func(err error) bool {
+			assert.Error(t, err, "Cannot recognize JWT token in passed value")
+			return true
+		}))
+
+		req := httptest.NewRequest("POST", "http://localhost", nil)
+		req.Header.Add("Authorization", "this is not jwt")
+		jwt := &JwtAuth{Key: []byte("secret"), Emitter: emitter}
+
+		err := jwt.Authenticate(req)
+		assert.Error(t, err, "Cannot recognize JWT token in passed value")
+
+		emitter.AssertExpectations(t)
+	})
+
+	t.Run("bearer token but not jwt", func(t *testing.T) {
+		emitter := &emitterMock{}
+		emitter.On("Emit", "authentication:error", mock.MatchedBy(func(err error) bool {
+			assert.Error(t, err, "Cannot parse passed JWT token")
+			return true
+		}))
+
+		req := httptest.NewRequest("POST", "http://localhost", nil)
+		req.Header.Add("Authorization", "Bearer thisIs.Not.Jwt")
+		jwt := &JwtAuth{Key: []byte("secret"), Emitter: emitter}
+
+		err := jwt.Authenticate(req)
+		assert.Error(t, err, "Cannot parse passed JWT token")
+
+		emitter.AssertExpectations(t)
+	})
+
+	t.Run("when secret is not set", func(t *testing.T) {
+		emitter := &emitterMock{}
+		emitter.On("Emit", "authentication:error", mock.MatchedBy(func(err error) bool {
+			assert.Error(t, err, "Signing key not set")
+			return true
+		}))
+
+		req := httptest.NewRequest("POST", "http://localhost", nil)
+		req.Header.Add("Authorization", "Bearer "+jwt)
+		jwt := &JwtAuth{Emitter: emitter}
+
+		err := jwt.Authenticate(req)
+		assert.Error(t, err, "Signing key not set")
+
+		emitter.AssertExpectations(t)
+	})
+
+	t.Run("invalid signature", func(t *testing.T) {
+		emitter := &emitterMock{}
+		emitter.On("Emit", "authentication:error", mock.MatchedBy(func(err error) bool {
+			assert.Error(t, err, "JWT token have invalid signature. It may be corrupted or expired")
+			return true
+		}))
+
+		req := httptest.NewRequest("POST", "http://localhost", nil)
+		req.Header.Add("Authorization", "Bearer "+jwt)
+		jwt := &JwtAuth{Key: []byte("this is another secret"), Emitter: emitter}
+
+		err := jwt.Authenticate(req)
+		assert.Error(t, err, "JWT token have invalid signature. It may be corrupted or expired")
+
+		emitter.AssertExpectations(t)
+	})
+}

http/skinsystem.go

@@ -0,0 +1,405 @@
+package http
+
+import (
+	"crypto/rsa"
+	"crypto/x509"
+	"encoding/base64"
+	"encoding/json"
+	"encoding/pem"
+	"fmt"
+	"io"
+	"net/http"
+	"strings"
+	"time"
+
+	"github.com/gorilla/mux"
+
+	"github.com/elyby/chrly/api/mojang"
+	"github.com/elyby/chrly/model"
+	"github.com/elyby/chrly/utils"
+)
+
+var timeNow = time.Now
+
+type SkinsRepository interface {
+	FindSkinByUsername(username string) (*model.Skin, error)
+	FindSkinByUserId(id int) (*model.Skin, error)
+	SaveSkin(skin *model.Skin) error
+	RemoveSkinByUserId(id int) error
+	RemoveSkinByUsername(username string) error
+}
+
+type CapesRepository interface {
+	FindCapeByUsername(username string) (*model.Cape, error)
+}
+
+type MojangTexturesProvider interface {
+	GetForUsername(username string) (*mojang.SignedTexturesResponse, error)
+}
+
+type TexturesSigner interface {
+	SignTextures(textures string) (string, error)
+	GetPublicKey() (*rsa.PublicKey, error)
+}
+
+type Skinsystem struct {
+	Emitter
+	SkinsRepo                   SkinsRepository
+	CapesRepo                   CapesRepository
+	MojangTexturesProvider      MojangTexturesProvider
+	TexturesSigner              TexturesSigner
+	TexturesExtraParamName      string
+	TexturesExtraParamValue     string
+	texturesExtraParamSignature string
+}
+
+func NewSkinsystem(
+	emitter Emitter,
+	skinsRepo SkinsRepository,
+	capesRepo CapesRepository,
+	mojangTexturesProvider MojangTexturesProvider,
+	texturesSigner TexturesSigner,
+	texturesExtraParamName string,
+	texturesExtraParamValue string,
+) (*Skinsystem, error) {
+	texturesExtraParamSignature, err := texturesSigner.SignTextures(texturesExtraParamValue)
+	if err != nil {
+		return nil, fmt.Errorf("unable to generate signature for textures extra param: %w", err)
+	}
+
+	return &Skinsystem{
+		Emitter:                     emitter,
+		SkinsRepo:                   skinsRepo,
+		CapesRepo:                   capesRepo,
+		MojangTexturesProvider:      mojangTexturesProvider,
+		TexturesSigner:              texturesSigner,
+		TexturesExtraParamName:      texturesExtraParamName,
+		TexturesExtraParamValue:     texturesExtraParamValue,
+		texturesExtraParamSignature: texturesExtraParamSignature,
+	}, nil
+}
+
+type profile struct {
+	Id              string
+	Username        string
+	Textures        *mojang.TexturesResponse
+	CapeFile        io.Reader
+	MojangTextures  string
+	MojangSignature string
+}
+
+func (ctx *Skinsystem) Handler() *mux.Router {
+	router := mux.NewRouter().StrictSlash(true)
+
+	router.HandleFunc("/skins/{username}", ctx.skinHandler).Methods(http.MethodGet)
+	router.HandleFunc("/cloaks/{username}", ctx.capeHandler).Methods(http.MethodGet).Name("cloaks")
+	router.HandleFunc("/textures/{username}", ctx.texturesHandler).Methods(http.MethodGet)
+	router.HandleFunc("/textures/signed/{username}", ctx.signedTexturesHandler).Methods(http.MethodGet)
+	router.HandleFunc("/profile/{username}", ctx.profileHandler).Methods(http.MethodGet)
+	// Legacy
+	router.HandleFunc("/skins", ctx.skinGetHandler).Methods(http.MethodGet)
+	router.HandleFunc("/cloaks", ctx.capeGetHandler).Methods(http.MethodGet)
+	// Utils
+	router.HandleFunc("/signature-verification-key.der", ctx.signatureVerificationKeyHandler).Methods(http.MethodGet)
+	router.HandleFunc("/signature-verification-key.pem", ctx.signatureVerificationKeyHandler).Methods(http.MethodGet)
+
+	return router
+}
+
+func (ctx *Skinsystem) skinHandler(response http.ResponseWriter, request *http.Request) {
+	profile, err := ctx.getProfile(request, true)
+	if err != nil {
+		panic(err)
+	}
+
+	if profile == nil || profile.Textures == nil || profile.Textures.Skin == nil {
+		response.WriteHeader(http.StatusNotFound)
+		return
+	}
+
+	http.Redirect(response, request, profile.Textures.Skin.Url, 301)
+}
+
+func (ctx *Skinsystem) skinGetHandler(response http.ResponseWriter, request *http.Request) {
+	username := request.URL.Query().Get("name")
+	if username == "" {
+		response.WriteHeader(http.StatusBadRequest)
+		return
+	}
+
+	mux.Vars(request)["username"] = username
+
+	ctx.skinHandler(response, request)
+}
+
+func (ctx *Skinsystem) capeHandler(response http.ResponseWriter, request *http.Request) {
+	profile, err := ctx.getProfile(request, true)
+	if err != nil {
+		panic(err)
+	}
+
+	if profile == nil || profile.Textures == nil || (profile.CapeFile == nil && profile.Textures.Cape == nil) {
+		response.WriteHeader(http.StatusNotFound)
+		return
+	}
+
+	if profile.CapeFile == nil {
+		http.Redirect(response, request, profile.Textures.Cape.Url, 301)
+	} else {
+		request.Header.Set("Content-Type", "image/png")
+		_, _ = io.Copy(response, profile.CapeFile)
+	}
+}
+
+func (ctx *Skinsystem) capeGetHandler(response http.ResponseWriter, request *http.Request) {
+	username := request.URL.Query().Get("name")
+	if username == "" {
+		response.WriteHeader(http.StatusBadRequest)
+		return
+	}
+
+	mux.Vars(request)["username"] = username
+
+	ctx.capeHandler(response, request)
+}
+
+func (ctx *Skinsystem) texturesHandler(response http.ResponseWriter, request *http.Request) {
+	profile, err := ctx.getProfile(request, true)
+	if err != nil {
+		panic(err)
+	}
+
+	if profile == nil || profile.Textures == nil || (profile.Textures.Skin == nil && profile.Textures.Cape == nil) {
+		response.WriteHeader(http.StatusNoContent)
+		return
+	}
+
+	responseData, _ := json.Marshal(profile.Textures)
+	response.Header().Set("Content-Type", "application/json")
+	_, _ = response.Write(responseData)
+}
+
+func (ctx *Skinsystem) signedTexturesHandler(response http.ResponseWriter, request *http.Request) {
+	profile, err := ctx.getProfile(request, request.URL.Query().Get("proxy") != "")
+	if err != nil {
+		panic(err)
+	}
+
+	if profile == nil || profile.MojangTextures == "" {
+		response.WriteHeader(http.StatusNoContent)
+		return
+	}
+
+	profileResponse := &mojang.SignedTexturesResponse{
+		Id:   profile.Id,
+		Name: profile.Username,
+		Props: []*mojang.Property{
+			{
+				Name:      "textures",
+				Signature: profile.MojangSignature,
+				Value:     profile.MojangTextures,
+			},
+			{
+				Name:  ctx.TexturesExtraParamName,
+				Value: ctx.TexturesExtraParamValue,
+			},
+		},
+	}
+
+	responseJson, _ := json.Marshal(profileResponse)
+	response.Header().Set("Content-Type", "application/json")
+	_, _ = response.Write(responseJson)
+}
+
+func (ctx *Skinsystem) profileHandler(response http.ResponseWriter, request *http.Request) {
+	profile, err := ctx.getProfile(request, true)
+	if err != nil {
+		panic(err)
+	}
+
+	if profile == nil {
+		forceResponseWithUuid := request.URL.Query().Get("onUnknownProfileRespondWithUuid")
+		if forceResponseWithUuid == "" {
+			response.WriteHeader(http.StatusNoContent)
+			return
+		}
+
+		profile = createEmptyProfile()
+		profile.Id = formatUuid(forceResponseWithUuid)
+		profile.Username = parseUsername(mux.Vars(request)["username"])
+	}
+
+	texturesPropContent := &mojang.TexturesProp{
+		Timestamp:   utils.UnixMillisecond(timeNow()),
+		ProfileID:   profile.Id,
+		ProfileName: profile.Username,
+		Textures:    profile.Textures,
+	}
+
+	texturesPropValueJson, _ := json.Marshal(texturesPropContent)
+	texturesPropEncodedValue := base64.StdEncoding.EncodeToString(texturesPropValueJson)
+
+	texturesProp := &mojang.Property{
+		Name:  "textures",
+		Value: texturesPropEncodedValue,
+	}
+	customProp := &mojang.Property{
+		Name:  ctx.TexturesExtraParamName,
+		Value: ctx.TexturesExtraParamValue,
+	}
+
+	if request.URL.Query().Get("unsigned") == "false" {
+		customProp.Signature = ctx.texturesExtraParamSignature
+
+		texturesSignature, err := ctx.TexturesSigner.SignTextures(texturesProp.Value)
+		if err != nil {
+			panic(err)
+		}
+
+		texturesProp.Signature = texturesSignature
+	}
+
+	profileResponse := &mojang.SignedTexturesResponse{
+		Id:   profile.Id,
+		Name: profile.Username,
+		Props: []*mojang.Property{
+			texturesProp,
+			customProp,
+		},
+	}
+
+	responseJson, _ := json.Marshal(profileResponse)
+	response.Header().Set("Content-Type", "application/json")
+	_, _ = response.Write(responseJson)
+}
+
+func (ctx *Skinsystem) signatureVerificationKeyHandler(response http.ResponseWriter, request *http.Request) {
+	publicKey, err := ctx.TexturesSigner.GetPublicKey()
+	if err != nil {
+		panic(err)
+	}
+
+	asn1Bytes, err := x509.MarshalPKIXPublicKey(publicKey)
+	if err != nil {
+		panic(err)
+	}
+
+	if strings.HasSuffix(request.URL.Path, ".pem") {
+		publicKeyBlock := pem.Block{
+			Type:  "PUBLIC KEY",
+			Bytes: asn1Bytes,
+		}
+
+		publicKeyPemBytes := pem.EncodeToMemory(&publicKeyBlock)
+
+		response.Header().Set("Content-Disposition", "attachment; filename=\"yggdrasil_session_pubkey.pem\"")
+		_, _ = response.Write(publicKeyPemBytes)
+	} else {
+		response.Header().Set("Content-Type", "application/octet-stream")
+		response.Header().Set("Content-Disposition", "attachment; filename=\"yggdrasil_session_pubkey.der\"")
+		_, _ = response.Write(asn1Bytes)
+	}
+}
+
+// TODO: in v5 should be extracted into some ProfileProvider interface,
+//
+//	which will encapsulate all logics, declared in this method
+func (ctx *Skinsystem) getProfile(request *http.Request, proxy bool) (*profile, error) {
+	username := parseUsername(mux.Vars(request)["username"])
+
+	skin, err := ctx.SkinsRepo.FindSkinByUsername(username)
+	if err != nil {
+		return nil, err
+	}
+
+	profile := createEmptyProfile()
+
+	if skin != nil {
+		profile.Id = formatUuid(skin.Uuid)
+		profile.Username = skin.Username
+	}
+
+	if skin != nil && skin.Url != "" {
+		profile.Textures.Skin = &mojang.SkinTexturesResponse{
+			Url: skin.Url,
+		}
+
+		if skin.IsSlim {
+			profile.Textures.Skin.Metadata = &mojang.SkinTexturesMetadata{
+				Model: "slim",
+			}
+		}
+
+		cape, _ := ctx.CapesRepo.FindCapeByUsername(username)
+		if cape != nil {
+			profile.CapeFile = cape.File
+			profile.Textures.Cape = &mojang.CapeTexturesResponse{
+				// Use statically http since the application doesn't support TLS
+				Url: "http://" + request.Host + "/cloaks/" + username,
+			}
+		}
+
+		profile.MojangTextures = skin.MojangTextures
+		profile.MojangSignature = skin.MojangSignature
+	} else if proxy {
+		mojangProfile, err := ctx.MojangTexturesProvider.GetForUsername(username)
+		// If we at least know something about a user,
+		// than we can ignore an error and return profile without textures
+		if err != nil && profile.Id != "" {
+			return profile, nil
+		}
+
+		if err != nil || mojangProfile == nil {
+			return nil, err
+		}
+
+		decodedTextures, err := mojangProfile.DecodeTextures()
+		if err != nil {
+			return nil, err
+		}
+
+		// There might be no textures property
+		if decodedTextures != nil {
+			profile.Textures = decodedTextures.Textures
+		}
+
+		var texturesProp *mojang.Property
+		for _, prop := range mojangProfile.Props {
+			if prop.Name == "textures" {
+				texturesProp = prop
+				break
+			}
+		}
+
+		if texturesProp != nil {
+			profile.MojangTextures = texturesProp.Value
+			profile.MojangSignature = texturesProp.Signature
+		}
+
+		// If user id is unknown at this point, then use values from Mojang profile
+		if profile.Id == "" {
+			profile.Id = mojangProfile.Id
+			profile.Username = mojangProfile.Name
+		}
+	} else if profile.Id != "" {
+		return profile, nil
+	} else {
+		return nil, nil
+	}
+
+	return profile, nil
+}
+
+func createEmptyProfile() *profile {
+	return &profile{
+		Textures: &mojang.TexturesResponse{}, // Field must be initialized to avoid "null" after json encoding
+	}
+}
+
+func formatUuid(uuid string) string {
+	return strings.Replace(uuid, "-", "", -1)
+}
+
+func parseUsername(username string) string {
+	return strings.TrimSuffix(username, ".png")
+}

http/uuids_worker.go

@@ -0,0 +1,53 @@
+package http
+
+import (
+	"encoding/json"
+	"net/http"
+
+	"github.com/gorilla/mux"
+
+	"github.com/elyby/chrly/api/mojang"
+)
+
+type MojangUuidsProvider interface {
+	GetUuid(username string) (*mojang.ProfileInfo, error)
+}
+
+type UUIDsWorker struct {
+	MojangUuidsProvider
+}
+
+func (ctx *UUIDsWorker) Handler() *mux.Router {
+	router := mux.NewRouter().StrictSlash(true)
+	router.Handle("/mojang-uuid/{username}", http.HandlerFunc(ctx.getUUIDHandler)).Methods("GET")
+
+	return router
+}
+
+func (ctx *UUIDsWorker) getUUIDHandler(response http.ResponseWriter, request *http.Request) {
+	username := mux.Vars(request)["username"]
+	profile, err := ctx.GetUuid(username)
+	if err != nil {
+		if _, ok := err.(*mojang.TooManyRequestsError); ok {
+			response.WriteHeader(http.StatusTooManyRequests)
+			return
+		}
+
+		response.Header().Set("Content-Type", "application/json")
+		response.WriteHeader(http.StatusInternalServerError)
+		result, _ := json.Marshal(map[string]interface{}{
+			"provider": err.Error(),
+		})
+		_, _ = response.Write(result)
+		return
+	}
+
+	if profile == nil {
+		response.WriteHeader(http.StatusNoContent)
+		return
+	}
+
+	response.Header().Set("Content-Type", "application/json")
+	responseData, _ := json.Marshal(profile)
+	_, _ = response.Write(responseData)
+}

http/uuids_worker_test.go

@@ -0,0 +1,154 @@
+package http
+
+import (
+	"errors"
+	"io/ioutil"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	"github.com/stretchr/testify/mock"
+	"github.com/stretchr/testify/suite"
+
+	"github.com/elyby/chrly/api/mojang"
+)
+
+/***************
+ * Setup mocks *
+ ***************/
+
+type uuidsProviderMock struct {
+	mock.Mock
+}
+
+func (m *uuidsProviderMock) GetUuid(username string) (*mojang.ProfileInfo, error) {
+	args := m.Called(username)
+	var result *mojang.ProfileInfo
+	if casted, ok := args.Get(0).(*mojang.ProfileInfo); ok {
+		result = casted
+	}
+
+	return result, args.Error(1)
+}
+
+type uuidsWorkerTestSuite struct {
+	suite.Suite
+
+	App *UUIDsWorker
+
+	UuidsProvider *uuidsProviderMock
+}
+
+/********************
+ * Setup test suite *
+ ********************/
+
+func (suite *uuidsWorkerTestSuite) SetupTest() {
+	suite.UuidsProvider = &uuidsProviderMock{}
+
+	suite.App = &UUIDsWorker{
+		MojangUuidsProvider: suite.UuidsProvider,
+	}
+}
+
+func (suite *uuidsWorkerTestSuite) TearDownTest() {
+	suite.UuidsProvider.AssertExpectations(suite.T())
+}
+
+func (suite *uuidsWorkerTestSuite) RunSubTest(name string, subTest func()) {
+	suite.SetupTest()
+	suite.Run(name, subTest)
+	suite.TearDownTest()
+}
+
+/*************
+ * Run tests *
+ *************/
+
+func TestUUIDsWorker(t *testing.T) {
+	suite.Run(t, new(uuidsWorkerTestSuite))
+}
+
+type uuidsWorkerTestCase struct {
+	Name       string
+	BeforeTest func(suite *uuidsWorkerTestSuite)
+	AfterTest  func(suite *uuidsWorkerTestSuite, response *http.Response)
+}
+
+/************************
+ * Get UUID tests cases *
+ ************************/
+
+var getUuidTestsCases = []*uuidsWorkerTestCase{
+	{
+		Name: "Success provider response",
+		BeforeTest: func(suite *uuidsWorkerTestSuite) {
+			suite.UuidsProvider.On("GetUuid", "mock_username").Return(&mojang.ProfileInfo{
+				Id:   "0fcc38620f1845f3a54e1b523c1bd1c7",
+				Name: "mock_username",
+			}, nil)
+		},
+		AfterTest: func(suite *uuidsWorkerTestSuite, response *http.Response) {
+			suite.Equal(200, response.StatusCode)
+			suite.Equal("application/json", response.Header.Get("Content-Type"))
+			body, _ := ioutil.ReadAll(response.Body)
+			suite.JSONEq(`{
+				"id": "0fcc38620f1845f3a54e1b523c1bd1c7",
+				"name": "mock_username"
+			}`, string(body))
+		},
+	},
+	{
+		Name: "Receive empty response from UUIDs provider",
+		BeforeTest: func(suite *uuidsWorkerTestSuite) {
+			suite.UuidsProvider.On("GetUuid", "mock_username").Return(nil, nil)
+		},
+		AfterTest: func(suite *uuidsWorkerTestSuite, response *http.Response) {
+			suite.Equal(204, response.StatusCode)
+			body, _ := ioutil.ReadAll(response.Body)
+			suite.Assert().Empty(body)
+		},
+	},
+	{
+		Name: "Receive error from UUIDs provider",
+		BeforeTest: func(suite *uuidsWorkerTestSuite) {
+			err := errors.New("this is an error")
+			suite.UuidsProvider.On("GetUuid", "mock_username").Return(nil, err)
+		},
+		AfterTest: func(suite *uuidsWorkerTestSuite, response *http.Response) {
+			suite.Equal(500, response.StatusCode)
+			suite.Equal("application/json", response.Header.Get("Content-Type"))
+			body, _ := ioutil.ReadAll(response.Body)
+			suite.JSONEq(`{
+				"provider": "this is an error"
+			}`, string(body))
+		},
+	},
+	{
+		Name: "Receive Too Many Requests from UUIDs provider",
+		BeforeTest: func(suite *uuidsWorkerTestSuite) {
+			err := &mojang.TooManyRequestsError{}
+			suite.UuidsProvider.On("GetUuid", "mock_username").Return(nil, err)
+		},
+		AfterTest: func(suite *uuidsWorkerTestSuite, response *http.Response) {
+			suite.Equal(429, response.StatusCode)
+			body, _ := ioutil.ReadAll(response.Body)
+			suite.Empty(body)
+		},
+	},
+}
+
+func (suite *uuidsWorkerTestSuite) TestGetUUID() {
+	for _, testCase := range getUuidTestsCases {
+		suite.RunSubTest(testCase.Name, func() {
+			testCase.BeforeTest(suite)
+
+			req := httptest.NewRequest("GET", "http://chrly/mojang-uuid/mock_username", nil)
+			w := httptest.NewRecorder()
+
+			suite.App.Handler().ServeHTTP(w, req)
+
+			testCase.AfterTest(suite, w.Result())
+		})
+	}
+}

main.go

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

model/cape.go

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

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"` // deprecated
+	Url             string `json:"url"`
+	Is1_8           bool   `json:"is1_8"`
+	IsSlim          bool   `json:"isSlim"`
+	MojangTextures  string `json:"mojangTextures"`
+	MojangSignature string `json:"mojangSignature"`
+	OldUsername     string
+}

models/Skins.php

@@ -1,39 +0,0 @@
-<?php
-
-use Phalcon\Mvc\Collection;
-
-/**
- * @property string $id
- */
-class Skins extends Collection {
-
-    public $_id;
-    public $userId;
-    public $nickname;
-    public $skinId;
-    public $url;
-    public $is1_8;
-    public $isSlim;
-    public $hash;
-
-    public function getId() {
-        return $this->_id;
-    }
-
-    public function getSource() {
-        return 'skins';
-    }
-
-    /**
-     * @param string $nickname
-     * @return bool|Skins
-     */
-    public static function findByNickname($nickname) {
-        return static::findFirst([
-            [
-                'nickname' => mb_convert_case($nickname, MB_CASE_LOWER, ENCODING),
-            ],
-        ]);
-    }
-
-}

mojangtextures/batch_uuids_provider.go

@@ -0,0 +1,249 @@
+package mojangtextures
+
+import (
+	"context"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/elyby/chrly/api/mojang"
+)
+
+type jobResult struct {
+	Profile *mojang.ProfileInfo
+	Error   error
+}
+
+type job struct {
+	Username    string
+	RespondChan chan *jobResult
+}
+
+type jobsQueue struct {
+	lock  sync.Mutex
+	items []*job
+}
+
+func newJobsQueue() *jobsQueue {
+	return &jobsQueue{
+		items: []*job{},
+	}
+}
+
+func (s *jobsQueue) Enqueue(job *job) int {
+	s.lock.Lock()
+	defer s.lock.Unlock()
+
+	s.items = append(s.items, job)
+
+	return len(s.items)
+}
+
+func (s *jobsQueue) Dequeue(n int) ([]*job, int) {
+	s.lock.Lock()
+	defer s.lock.Unlock()
+
+	l := len(s.items)
+	if n > l {
+		n = l
+	}
+
+	items := s.items[0:n]
+	s.items = s.items[n:l]
+
+	return items, l - n
+}
+
+var usernamesToUuids = mojang.UsernamesToUuids
+
+type JobsIteration struct {
+	Jobs  []*job
+	Queue int
+	c     chan struct{}
+}
+
+func (j *JobsIteration) Done() {
+	if j.c != nil {
+		close(j.c)
+	}
+}
+
+type BatchUuidsProviderStrategy interface {
+	Queue(job *job)
+	GetJobs(abort context.Context) <-chan *JobsIteration
+}
+
+type PeriodicStrategy struct {
+	Delay time.Duration
+	Batch int
+	queue *jobsQueue
+	done  chan struct{}
+}
+
+func NewPeriodicStrategy(delay time.Duration, batch int) *PeriodicStrategy {
+	return &PeriodicStrategy{
+		Delay: delay,
+		Batch: batch,
+		queue: newJobsQueue(),
+	}
+}
+
+func (ctx *PeriodicStrategy) Queue(job *job) {
+	ctx.queue.Enqueue(job)
+}
+
+func (ctx *PeriodicStrategy) GetJobs(abort context.Context) <-chan *JobsIteration {
+	ch := make(chan *JobsIteration)
+	go func() {
+		for {
+			select {
+			case <-abort.Done():
+				close(ch)
+				return
+			case <-time.After(ctx.Delay):
+				jobs, queueLen := ctx.queue.Dequeue(ctx.Batch)
+				jobDoneChan := make(chan struct{})
+				ch <- &JobsIteration{jobs, queueLen, jobDoneChan}
+				<-jobDoneChan
+			}
+		}
+	}()
+
+	return ch
+}
+
+type FullBusStrategy struct {
+	Delay     time.Duration
+	Batch     int
+	queue     *jobsQueue
+	busIsFull chan bool
+}
+
+func NewFullBusStrategy(delay time.Duration, batch int) *FullBusStrategy {
+	return &FullBusStrategy{
+		Delay:     delay,
+		Batch:     batch,
+		queue:     newJobsQueue(),
+		busIsFull: make(chan bool),
+	}
+}
+
+func (ctx *FullBusStrategy) Queue(job *job) {
+	n := ctx.queue.Enqueue(job)
+	if n%ctx.Batch == 0 {
+		ctx.busIsFull <- true
+	}
+}
+
+// Формально, это описание логики водителя маршрутки xD
+func (ctx *FullBusStrategy) GetJobs(abort context.Context) <-chan *JobsIteration {
+	ch := make(chan *JobsIteration)
+	go func() {
+		for {
+			t := time.NewTimer(ctx.Delay)
+			select {
+			case <-abort.Done():
+				close(ch)
+				return
+			case <-t.C:
+				ctx.sendJobs(ch)
+			case <-ctx.busIsFull:
+				t.Stop()
+				ctx.sendJobs(ch)
+			}
+		}
+	}()
+
+	return ch
+}
+
+func (ctx *FullBusStrategy) sendJobs(ch chan *JobsIteration) {
+	jobs, queueLen := ctx.queue.Dequeue(ctx.Batch)
+	ch <- &JobsIteration{jobs, queueLen, nil}
+}
+
+type BatchUuidsProvider struct {
+	context     context.Context
+	emitter     Emitter
+	strategy    BatchUuidsProviderStrategy
+	onFirstCall sync.Once
+}
+
+func NewBatchUuidsProvider(
+	context context.Context,
+	strategy BatchUuidsProviderStrategy,
+	emitter Emitter,
+) *BatchUuidsProvider {
+	return &BatchUuidsProvider{
+		context:  context,
+		emitter:  emitter,
+		strategy: strategy,
+	}
+}
+
+func (ctx *BatchUuidsProvider) GetUuid(username string) (*mojang.ProfileInfo, error) {
+	ctx.onFirstCall.Do(ctx.startQueue)
+
+	resultChan := make(chan *jobResult)
+	ctx.strategy.Queue(&job{username, resultChan})
+	ctx.emitter.Emit("mojang_textures:batch_uuids_provider:queued", username)
+
+	result := <-resultChan
+
+	return result.Profile, result.Error
+}
+
+func (ctx *BatchUuidsProvider) startQueue() {
+	// This synchronization chan is used to ensure that strategy's jobs provider
+	// will be initialized before any job will be scheduled
+	d := make(chan struct{})
+	go func() {
+		jobsChan := ctx.strategy.GetJobs(ctx.context)
+		close(d)
+		for {
+			select {
+			case <-ctx.context.Done():
+				return
+			case iteration := <-jobsChan:
+				go func() {
+					ctx.performRequest(iteration)
+					iteration.Done()
+				}()
+			}
+		}
+	}()
+
+	<-d
+}
+
+func (ctx *BatchUuidsProvider) performRequest(iteration *JobsIteration) {
+	usernames := make([]string, len(iteration.Jobs))
+	for i, job := range iteration.Jobs {
+		usernames[i] = job.Username
+	}
+
+	ctx.emitter.Emit("mojang_textures:batch_uuids_provider:round", usernames, iteration.Queue)
+	if len(usernames) == 0 {
+		return
+	}
+
+	profiles, err := usernamesToUuids(usernames)
+	ctx.emitter.Emit("mojang_textures:batch_uuids_provider:result", usernames, profiles, err)
+	for _, job := range iteration.Jobs {
+		response := &jobResult{}
+		if err == nil {
+			// The profiles in the response aren't ordered, so we must search each username over full array
+			for _, profile := range profiles {
+				if strings.EqualFold(job.Username, profile.Name) {
+					response.Profile = profile
+					break
+				}
+			}
+		} else {
+			response.Error = err
+		}
+
+		job.RespondChan <- response
+		close(job.RespondChan)
+	}
+}

mojangtextures/batch_uuids_provider_test.go

@@ -0,0 +1,441 @@
+package mojangtextures
+
+import (
+	"context"
+	"fmt"
+	"strconv"
+	"sync"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/mock"
+	"github.com/stretchr/testify/require"
+	"github.com/stretchr/testify/suite"
+
+	"github.com/elyby/chrly/api/mojang"
+)
+
+func TestJobsQueue(t *testing.T) {
+	t.Run("Enqueue", func(t *testing.T) {
+		s := newJobsQueue()
+		require.Equal(t, 1, s.Enqueue(&job{Username: "username1"}))
+		require.Equal(t, 2, s.Enqueue(&job{Username: "username2"}))
+		require.Equal(t, 3, s.Enqueue(&job{Username: "username3"}))
+	})
+
+	t.Run("Dequeue", func(t *testing.T) {
+		s := newJobsQueue()
+		s.Enqueue(&job{Username: "username1"})
+		s.Enqueue(&job{Username: "username2"})
+		s.Enqueue(&job{Username: "username3"})
+		s.Enqueue(&job{Username: "username4"})
+		s.Enqueue(&job{Username: "username5"})
+
+		items, queueLen := s.Dequeue(2)
+		require.Len(t, items, 2)
+		require.Equal(t, 3, queueLen)
+		require.Equal(t, "username1", items[0].Username)
+		require.Equal(t, "username2", items[1].Username)
+
+		items, queueLen = s.Dequeue(40)
+		require.Len(t, items, 3)
+		require.Equal(t, 0, queueLen)
+		require.Equal(t, "username3", items[0].Username)
+		require.Equal(t, "username4", items[1].Username)
+		require.Equal(t, "username5", items[2].Username)
+	})
+}
+
+type mojangUsernamesToUuidsRequestMock struct {
+	mock.Mock
+}
+
+func (o *mojangUsernamesToUuidsRequestMock) 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)
+}
+
+type manualStrategy struct {
+	ch   chan *JobsIteration
+	once sync.Once
+	lock sync.Mutex
+	jobs []*job
+}
+
+func (m *manualStrategy) Queue(job *job) {
+	m.lock.Lock()
+	m.jobs = append(m.jobs, job)
+	m.lock.Unlock()
+}
+
+func (m *manualStrategy) GetJobs(_ context.Context) <-chan *JobsIteration {
+	m.lock.Lock()
+	defer m.lock.Unlock()
+	m.ch = make(chan *JobsIteration)
+
+	return m.ch
+}
+
+func (m *manualStrategy) Iterate(countJobsToReturn int, countLeftJobsInQueue int) {
+	m.lock.Lock()
+	defer m.lock.Unlock()
+
+	m.ch <- &JobsIteration{
+		Jobs:  m.jobs[0:countJobsToReturn],
+		Queue: countLeftJobsInQueue,
+	}
+}
+
+type batchUuidsProviderGetUuidResult struct {
+	Result *mojang.ProfileInfo
+	Error  error
+}
+
+type batchUuidsProviderTestSuite struct {
+	suite.Suite
+
+	Provider *BatchUuidsProvider
+
+	Emitter   *mockEmitter
+	Strategy  *manualStrategy
+	MojangApi *mojangUsernamesToUuidsRequestMock
+
+	stop context.CancelFunc
+}
+
+func (suite *batchUuidsProviderTestSuite) GetUuidAsync(username string) <-chan *batchUuidsProviderGetUuidResult {
+	s := make(chan struct{})
+	// This dirty hack ensures, that the username will be queued before we return control to the caller.
+	// It's needed to keep expected calls order and prevent cases when iteration happens before
+	// all usernames will be queued.
+	suite.Emitter.On("Emit",
+		"mojang_textures:batch_uuids_provider:queued",
+		username,
+	).Once().Run(func(args mock.Arguments) {
+		close(s)
+	})
+
+	c := make(chan *batchUuidsProviderGetUuidResult)
+	go func() {
+		profile, err := suite.Provider.GetUuid(username)
+		c <- &batchUuidsProviderGetUuidResult{
+			Result: profile,
+			Error:  err,
+		}
+	}()
+
+	<-s
+
+	return c
+}
+
+func (suite *batchUuidsProviderTestSuite) SetupTest() {
+	suite.Emitter = &mockEmitter{}
+	suite.Strategy = &manualStrategy{}
+	ctx, stop := context.WithCancel(context.Background())
+	suite.stop = stop
+	suite.MojangApi = &mojangUsernamesToUuidsRequestMock{}
+	usernamesToUuids = suite.MojangApi.UsernamesToUuids
+
+	suite.Provider = NewBatchUuidsProvider(ctx, suite.Strategy, suite.Emitter)
+}
+
+func (suite *batchUuidsProviderTestSuite) TearDownTest() {
+	suite.stop()
+	suite.Emitter.AssertExpectations(suite.T())
+	suite.MojangApi.AssertExpectations(suite.T())
+}
+
+func TestBatchUuidsProvider(t *testing.T) {
+	suite.Run(t, new(batchUuidsProviderTestSuite))
+}
+
+func (suite *batchUuidsProviderTestSuite) TestGetUuidForFewUsernames() {
+	expectedUsernames := []string{"username1", "username2"}
+	expectedResult1 := &mojang.ProfileInfo{Id: "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", Name: "username1"}
+	expectedResult2 := &mojang.ProfileInfo{Id: "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb", Name: "username2"}
+	expectedResponse := []*mojang.ProfileInfo{expectedResult1, expectedResult2}
+
+	suite.Emitter.On("Emit", "mojang_textures:batch_uuids_provider:round", expectedUsernames, 0).Once()
+	suite.Emitter.On("Emit", "mojang_textures:batch_uuids_provider:result", expectedUsernames, expectedResponse, nil).Once()
+
+	suite.MojangApi.On("UsernamesToUuids", expectedUsernames).Once().Return([]*mojang.ProfileInfo{
+		expectedResult1,
+		expectedResult2,
+	}, nil)
+
+	resultChan1 := suite.GetUuidAsync("username1")
+	resultChan2 := suite.GetUuidAsync("username2")
+
+	suite.Strategy.Iterate(2, 0)
+
+	result1 := <-resultChan1
+	suite.Assert().Equal(expectedResult1, result1.Result)
+	suite.Assert().Nil(result1.Error)
+
+	result2 := <-resultChan2
+	suite.Assert().Equal(expectedResult2, result2.Result)
+	suite.Assert().Nil(result2.Error)
+}
+
+func (suite *batchUuidsProviderTestSuite) TestShouldNotSendRequestWhenNoJobsAreReturned() {
+	//noinspection GoPreferNilSlice
+	emptyUsernames := []string{}
+	done := make(chan struct{})
+	suite.Emitter.On("Emit",
+		"mojang_textures:batch_uuids_provider:round",
+		emptyUsernames,
+		1,
+	).Once().Run(func(args mock.Arguments) {
+		close(done)
+	})
+
+	suite.GetUuidAsync("username") // Schedule one username to run the queue
+
+	suite.Strategy.Iterate(0, 1) // Return no jobs and indicate that there is one job in queue
+
+	<-done
+}
+
+// Test written for multiple usernames to ensure that the error
+// will be returned for each iteration group
+func (suite *batchUuidsProviderTestSuite) TestGetUuidForFewUsernamesWithAnError() {
+	expectedUsernames := []string{"username1", "username2"}
+	expectedError := &mojang.TooManyRequestsError{}
+	var nilProfilesResponse []*mojang.ProfileInfo
+
+	suite.Emitter.On("Emit", "mojang_textures:batch_uuids_provider:round", expectedUsernames, 0).Once()
+	suite.Emitter.On("Emit", "mojang_textures:batch_uuids_provider:result", expectedUsernames, nilProfilesResponse, expectedError).Once()
+
+	suite.MojangApi.On("UsernamesToUuids", expectedUsernames).Once().Return(nil, expectedError)
+
+	resultChan1 := suite.GetUuidAsync("username1")
+	resultChan2 := suite.GetUuidAsync("username2")
+
+	suite.Strategy.Iterate(2, 0)
+
+	result1 := <-resultChan1
+	suite.Assert().Nil(result1.Result)
+	suite.Assert().Equal(expectedError, result1.Error)
+
+	result2 := <-resultChan2
+	suite.Assert().Nil(result2.Result)
+	suite.Assert().Equal(expectedError, result2.Error)
+}
+
+func TestPeriodicStrategy(t *testing.T) {
+	t.Run("should return first job only after duration", func(t *testing.T) {
+		d := 20 * time.Millisecond
+		strategy := NewPeriodicStrategy(d, 10)
+		j := &job{}
+		strategy.Queue(j)
+
+		ctx, cancel := context.WithCancel(context.Background())
+		startedAt := time.Now()
+		ch := strategy.GetJobs(ctx)
+		iteration := <-ch
+		durationBeforeResult := time.Now().Sub(startedAt)
+		require.True(t, durationBeforeResult >= d)
+		require.True(t, durationBeforeResult < d*2)
+
+		require.Equal(t, []*job{j}, iteration.Jobs)
+		require.Equal(t, 0, iteration.Queue)
+
+		cancel()
+	})
+
+	t.Run("should return the configured batch size", func(t *testing.T) {
+		strategy := NewPeriodicStrategy(0, 10)
+		jobs := make([]*job, 15)
+		for i := 0; i < 15; i++ {
+			jobs[i] = &job{Username: strconv.Itoa(i)}
+			strategy.Queue(jobs[i])
+		}
+
+		ctx, cancel := context.WithCancel(context.Background())
+		ch := strategy.GetJobs(ctx)
+		iteration := <-ch
+		require.Len(t, iteration.Jobs, 10)
+		require.Equal(t, jobs[0:10], iteration.Jobs)
+		require.Equal(t, 5, iteration.Queue)
+
+		cancel()
+	})
+
+	t.Run("should not return the next iteration until the previous one is finished", func(t *testing.T) {
+		strategy := NewPeriodicStrategy(0, 10)
+		strategy.Queue(&job{})
+
+		ctx, cancel := context.WithCancel(context.Background())
+		ch := strategy.GetJobs(ctx)
+		iteration := <-ch
+		require.Len(t, iteration.Jobs, 1)
+		require.Equal(t, 0, iteration.Queue)
+
+		time.Sleep(time.Millisecond) // Let strategy's internal loop to work (if the implementation is broken)
+
+		select {
+		case <-ch:
+			require.Fail(t, "the previous iteration isn't marked as done")
+		default:
+			// ok
+		}
+
+		iteration.Done()
+
+		time.Sleep(time.Millisecond) // Let strategy's internal loop to work
+
+		select {
+		case iteration = <-ch:
+			// ok
+		default:
+			require.Fail(t, "iteration should be provided")
+		}
+
+		require.Empty(t, iteration.Jobs)
+		require.Equal(t, 0, iteration.Queue)
+		iteration.Done()
+
+		cancel()
+	})
+
+	t.Run("each iteration should be returned only after the configured duration", func(t *testing.T) {
+		d := 5 * time.Millisecond
+		strategy := NewPeriodicStrategy(d, 10)
+		ctx, cancel := context.WithCancel(context.Background())
+		ch := strategy.GetJobs(ctx)
+		for i := 0; i < 3; i++ {
+			startedAt := time.Now()
+			iteration := <-ch
+			durationBeforeResult := time.Now().Sub(startedAt)
+			require.True(t, durationBeforeResult >= d)
+			require.True(t, durationBeforeResult < d*2)
+
+			require.Empty(t, iteration.Jobs)
+			require.Equal(t, 0, iteration.Queue)
+
+			// Sleep for at least doubled duration before calling Done() to check,
+			// that this duration isn't included into the next iteration time
+			time.Sleep(d * 2)
+			iteration.Done()
+		}
+
+		cancel()
+	})
+}
+
+func TestFullBusStrategy(t *testing.T) {
+	t.Run("should provide iteration immediately when the batch size exceeded", func(t *testing.T) {
+		jobs := make([]*job, 10)
+		for i := 0; i < 10; i++ {
+			jobs[i] = &job{}
+		}
+
+		d := 20 * time.Millisecond
+		strategy := NewFullBusStrategy(d, 10)
+		ctx, cancel := context.WithCancel(context.Background())
+		ch := strategy.GetJobs(ctx)
+
+		done := make(chan struct{})
+		go func() {
+			defer close(done)
+			select {
+			case iteration := <-ch:
+				require.Len(t, iteration.Jobs, 10)
+				require.Equal(t, 0, iteration.Queue)
+			case <-time.After(d):
+				require.Fail(t, "iteration should be provided immediately")
+			}
+		}()
+
+		for _, j := range jobs {
+			strategy.Queue(j)
+		}
+
+		<-done
+
+		cancel()
+	})
+
+	t.Run("should provide iteration after duration if batch size isn't exceeded", func(t *testing.T) {
+		jobs := make([]*job, 9)
+		for i := 0; i < 9; i++ {
+			jobs[i] = &job{}
+		}
+
+		d := 20 * time.Millisecond
+		strategy := NewFullBusStrategy(d, 10)
+		ctx, cancel := context.WithCancel(context.Background())
+
+		startedAt := time.Now()
+		ch := strategy.GetJobs(ctx)
+
+		done := make(chan struct{})
+		go func() {
+			defer close(done)
+			iteration := <-ch
+			duration := time.Now().Sub(startedAt)
+			require.True(t, duration >= d, fmt.Sprintf("has %d, expected %d", duration, d))
+			require.True(t, duration < d*2)
+			require.Equal(t, jobs, iteration.Jobs)
+			require.Equal(t, 0, iteration.Queue)
+		}()
+
+		for _, j := range jobs {
+			strategy.Queue(j)
+		}
+
+		<-done
+
+		cancel()
+	})
+
+	t.Run("should provide iteration as soon as the bus is full, without waiting for the previous iteration to finish", func(t *testing.T) {
+		d := 20 * time.Millisecond
+		strategy := NewFullBusStrategy(d, 10)
+		ctx, cancel := context.WithCancel(context.Background())
+		ch := strategy.GetJobs(ctx)
+
+		done := make(chan struct{})
+		go func() {
+			defer close(done)
+			for i := 0; i < 3; i++ {
+				time.Sleep(5 * time.Millisecond) // See comment below
+				select {
+				case iteration := <-ch:
+					require.Len(t, iteration.Jobs, 10)
+					// Don't assert iteration.Queue length since it might be unstable
+					// Don't call iteration.Done()
+				case <-time.After(d):
+					t.Errorf("iteration should be provided as soon as the bus is full")
+					return
+				}
+			}
+
+			// Scheduled 31 tasks. 3 iterations should be performed immediately
+			// and should be executed only after timeout. The timeout above is used
+			// to increase overall time to ensure, that timer resets on every iteration
+
+			startedAt := time.Now()
+			iteration := <-ch
+			duration := time.Now().Sub(startedAt)
+			require.True(t, duration >= d)
+			require.True(t, duration < d*2)
+			require.Len(t, iteration.Jobs, 1)
+			require.Equal(t, 0, iteration.Queue)
+		}()
+
+		for i := 0; i < 31; i++ {
+			strategy.Queue(&job{})
+		}
+
+		<-done
+
+		cancel()
+	})
+}

mojangtextures/in_memory_textures_storage.go

@@ -0,0 +1,94 @@
+package mojangtextures
+
+import (
+	"sync"
+	"time"
+
+	"github.com/elyby/chrly/api/mojang"
+	"github.com/elyby/chrly/utils"
+)
+
+type inMemoryItem struct {
+	textures  *mojang.SignedTexturesResponse
+	timestamp int64
+}
+
+type InMemoryTexturesStorage struct {
+	GCPeriod time.Duration
+	Duration time.Duration
+
+	once sync.Once
+	lock sync.RWMutex
+	data map[string]*inMemoryItem
+	done chan struct{}
+}
+
+func NewInMemoryTexturesStorage() *InMemoryTexturesStorage {
+	storage := &InMemoryTexturesStorage{
+		GCPeriod: 10 * time.Second,
+		Duration: time.Minute + 10*time.Second,
+		data:     make(map[string]*inMemoryItem),
+	}
+
+	return storage
+}
+
+func (s *InMemoryTexturesStorage) GetTextures(uuid string) (*mojang.SignedTexturesResponse, error) {
+	s.lock.RLock()
+	defer s.lock.RUnlock()
+
+	item, exists := s.data[uuid]
+	validRange := s.getMinimalNotExpiredTimestamp()
+	if !exists || validRange > item.timestamp {
+		return nil, nil
+	}
+
+	return item.textures, nil
+}
+
+func (s *InMemoryTexturesStorage) StoreTextures(uuid string, textures *mojang.SignedTexturesResponse) {
+	s.once.Do(s.start)
+
+	s.lock.Lock()
+	defer s.lock.Unlock()
+
+	s.data[uuid] = &inMemoryItem{
+		textures:  textures,
+		timestamp: utils.UnixMillisecond(time.Now()),
+	}
+}
+
+func (s *InMemoryTexturesStorage) start() {
+	s.done = make(chan struct{})
+	ticker := time.NewTicker(s.GCPeriod)
+	go func() {
+		for {
+			select {
+			case <-s.done:
+				return
+			case <-ticker.C:
+				s.gc()
+			}
+		}
+	}()
+}
+
+func (s *InMemoryTexturesStorage) Stop() {
+	close(s.done)
+}
+
+func (s *InMemoryTexturesStorage) gc() {
+	s.lock.Lock()
+	defer s.lock.Unlock()
+
+	maxTime := s.getMinimalNotExpiredTimestamp()
+	for uuid, value := range s.data {
+		if maxTime > value.timestamp {
+			delete(s.data, uuid)
+		}
+	}
+}
+
+func (s *InMemoryTexturesStorage) getMinimalNotExpiredTimestamp() int64 {
+	return utils.UnixMillisecond(time.Now().Add(s.Duration * time.Duration(-1)))
+}

mojangtextures/in_memory_textures_storage_test.go

@@ -0,0 +1,164 @@
+package mojangtextures
+
+import (
+	"testing"
+	"time"
+
+	assert "github.com/stretchr/testify/require"
+
+	"github.com/elyby/chrly/api/mojang"
+)
+
+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("should return nil, nil when textures are unavailable", func(t *testing.T) {
+		storage := NewInMemoryTexturesStorage()
+		result, err := storage.GetTextures("b5d58475007d4f9e9ddd1403e2497579")
+
+		assert.Nil(t, result)
+		assert.Nil(t, err)
+	})
+
+	t.Run("get textures object, when uuid is stored in the storage", func(t *testing.T) {
+		storage := NewInMemoryTexturesStorage()
+		storage.StoreTextures("dead24f9a4fa4877b7b04c8c6c72bb46", texturesWithSkin)
+		result, err := storage.GetTextures("dead24f9a4fa4877b7b04c8c6c72bb46")
+
+		assert.Equal(t, texturesWithSkin, result)
+		assert.Nil(t, err)
+	})
+
+	t.Run("should return nil, nil when textures are exists, but cache duration is expired", func(t *testing.T) {
+		storage := NewInMemoryTexturesStorage()
+		storage.Duration = 10 * time.Millisecond
+		storage.GCPeriod = time.Minute
+		storage.StoreTextures("dead24f9a4fa4877b7b04c8c6c72bb46", texturesWithSkin)
+
+		time.Sleep(storage.Duration * 2)
+
+		result, err := storage.GetTextures("dead24f9a4fa4877b7b04c8c6c72bb46")
+
+		assert.Nil(t, result)
+		assert.Nil(t, err)
+	})
+}
+
+func TestInMemoryTexturesStorage_StoreTextures(t *testing.T) {
+	t.Run("store textures for previously not existed uuid", func(t *testing.T) {
+		storage := NewInMemoryTexturesStorage()
+		storage.StoreTextures("dead24f9a4fa4877b7b04c8c6c72bb46", texturesWithSkin)
+		result, err := storage.GetTextures("dead24f9a4fa4877b7b04c8c6c72bb46")
+
+		assert.Equal(t, texturesWithSkin, result)
+		assert.Nil(t, err)
+	})
+
+	t.Run("override already existed textures for uuid", func(t *testing.T) {
+		storage := NewInMemoryTexturesStorage()
+		storage.StoreTextures("dead24f9a4fa4877b7b04c8c6c72bb46", texturesWithoutSkin)
+		storage.StoreTextures("dead24f9a4fa4877b7b04c8c6c72bb46", texturesWithSkin)
+		result, err := storage.GetTextures("dead24f9a4fa4877b7b04c8c6c72bb46")
+
+		assert.NotEqual(t, texturesWithoutSkin, result)
+		assert.Equal(t, texturesWithSkin, result)
+		assert.Nil(t, err)
+	})
+
+	t.Run("store textures with empty properties", func(t *testing.T) {
+		texturesWithEmptyProps := &mojang.SignedTexturesResponse{
+			Id:    "dead24f9a4fa4877b7b04c8c6c72bb46",
+			Name:  "mock",
+			Props: []*mojang.Property{},
+		}
+
+		storage := NewInMemoryTexturesStorage()
+		storage.StoreTextures("dead24f9a4fa4877b7b04c8c6c72bb46", texturesWithEmptyProps)
+		result, err := storage.GetTextures("dead24f9a4fa4877b7b04c8c6c72bb46")
+
+		assert.Exactly(t, texturesWithEmptyProps, result)
+		assert.Nil(t, err)
+	})
+
+	t.Run("store nil textures", func(t *testing.T) {
+		storage := NewInMemoryTexturesStorage()
+		storage.StoreTextures("dead24f9a4fa4877b7b04c8c6c72bb46", nil)
+		result, err := storage.GetTextures("dead24f9a4fa4877b7b04c8c6c72bb46")
+
+		assert.Nil(t, result)
+		assert.Nil(t, err)
+	})
+}
+
+func TestInMemoryTexturesStorage_GarbageCollection(t *testing.T) {
+	storage := NewInMemoryTexturesStorage()
+	defer storage.Stop()
+	storage.GCPeriod = 10 * time.Millisecond
+	storage.Duration = 9 * time.Millisecond
+
+	textures1 := &mojang.SignedTexturesResponse{
+		Id:    "dead24f9a4fa4877b7b04c8c6c72bb46",
+		Name:  "mock1",
+		Props: []*mojang.Property{},
+	}
+	textures2 := &mojang.SignedTexturesResponse{
+		Id:    "b5d58475007d4f9e9ddd1403e2497579",
+		Name:  "mock2",
+		Props: []*mojang.Property{},
+	}
+
+	storage.StoreTextures("dead24f9a4fa4877b7b04c8c6c72bb46", textures1)
+	// Store another texture a bit later to avoid it removing by GC after the first iteration
+	time.Sleep(2 * time.Millisecond)
+	storage.StoreTextures("b5d58475007d4f9e9ddd1403e2497579", textures2)
+
+	storage.lock.RLock()
+	assert.Len(t, storage.data, 2, "the GC period has not yet reached")
+	storage.lock.RUnlock()
+
+	time.Sleep(storage.GCPeriod) // Let it perform the first GC iteration
+
+	storage.lock.RLock()
+	assert.Len(t, storage.data, 1, "the first texture should be cleaned by GC")
+	assert.Contains(t, storage.data, "b5d58475007d4f9e9ddd1403e2497579")
+	storage.lock.RUnlock()
+
+	time.Sleep(storage.GCPeriod) // Let another iteration happen
+
+	storage.lock.RLock()
+	assert.Len(t, storage.data, 0)
+	storage.lock.RUnlock()
+}

mojangtextures/mojang_api_textures_provider.go

@@ -0,0 +1,19 @@
+package mojangtextures
+
+import (
+	"github.com/elyby/chrly/api/mojang"
+)
+
+var uuidToTextures = mojang.UuidToTextures
+
+type MojangApiTexturesProvider struct {
+	Emitter
+}
+
+func (ctx *MojangApiTexturesProvider) GetTextures(uuid string) (*mojang.SignedTexturesResponse, error) {
+	ctx.Emit("mojang_textures:mojang_api_textures_provider:before_request", uuid)
+	result, err := uuidToTextures(uuid, true)
+	ctx.Emit("mojang_textures:mojang_api_textures_provider:after_request", uuid, result, err)
+
+	return result, err
+}

mojangtextures/mojang_api_textures_provider_test.go

@@ -0,0 +1,98 @@
+package mojangtextures
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/mock"
+	"github.com/stretchr/testify/suite"
+
+	"github.com/elyby/chrly/api/mojang"
+)
+
+type mojangUuidToTexturesRequestMock struct {
+	mock.Mock
+}
+
+func (o *mojangUuidToTexturesRequestMock) 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 mojangApiTexturesProviderTestSuite struct {
+	suite.Suite
+
+	Provider  *MojangApiTexturesProvider
+	Emitter   *mockEmitter
+	MojangApi *mojangUuidToTexturesRequestMock
+}
+
+func (suite *mojangApiTexturesProviderTestSuite) SetupTest() {
+	suite.Emitter = &mockEmitter{}
+	suite.MojangApi = &mojangUuidToTexturesRequestMock{}
+
+	suite.Provider = &MojangApiTexturesProvider{
+		Emitter: suite.Emitter,
+	}
+
+	uuidToTextures = suite.MojangApi.UuidToTextures
+}
+
+func (suite *mojangApiTexturesProviderTestSuite) TearDownTest() {
+	suite.MojangApi.AssertExpectations(suite.T())
+	suite.Emitter.AssertExpectations(suite.T())
+}
+
+func TestMojangApiTexturesProvider(t *testing.T) {
+	suite.Run(t, new(mojangApiTexturesProviderTestSuite))
+}
+
+func (suite *mojangApiTexturesProviderTestSuite) TestGetTextures() {
+	expectedResult := &mojang.SignedTexturesResponse{
+		Id:   "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+		Name: "username",
+	}
+	suite.MojangApi.On("UuidToTextures", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", true).Once().Return(expectedResult, nil)
+
+	suite.Emitter.On("Emit",
+		"mojang_textures:mojang_api_textures_provider:before_request",
+		"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+	).Once()
+	suite.Emitter.On("Emit",
+		"mojang_textures:mojang_api_textures_provider:after_request",
+		"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+		expectedResult,
+		nil,
+	).Once()
+
+	result, err := suite.Provider.GetTextures("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa")
+
+	suite.Assert().Equal(expectedResult, result)
+	suite.Assert().Nil(err)
+}
+
+func (suite *mojangApiTexturesProviderTestSuite) TestGetTexturesWithError() {
+	var expectedResponse *mojang.SignedTexturesResponse
+	expectedError := &mojang.TooManyRequestsError{}
+	suite.MojangApi.On("UuidToTextures", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", true).Once().Return(nil, expectedError)
+
+	suite.Emitter.On("Emit",
+		"mojang_textures:mojang_api_textures_provider:before_request",
+		"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+	).Once()
+	suite.Emitter.On("Emit",
+		"mojang_textures:mojang_api_textures_provider:after_request",
+		"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+		expectedResponse,
+		expectedError,
+	).Once()
+
+	result, err := suite.Provider.GetTextures("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa")
+
+	suite.Assert().Nil(result)
+	suite.Assert().Equal(expectedError, err)
+}

mojangtextures/mojang_textures.go

@@ -0,0 +1,205 @@
+package mojangtextures
+
+import (
+	"regexp"
+	"strings"
+	"sync"
+
+	"github.com/elyby/chrly/api/mojang"
+	"github.com/elyby/chrly/dispatcher"
+)
+
+type broadcastResult struct {
+	textures *mojang.SignedTexturesResponse
+	error    error
+}
+
+type broadcaster struct {
+	lock      sync.Mutex
+	listeners map[string][]chan *broadcastResult
+}
+
+func createBroadcaster() *broadcaster {
+	return &broadcaster{
+		listeners: make(map[string][]chan *broadcastResult),
+	}
+}
+
+// Returns a boolean value, which will be true if the passed username didn't exist before
+func (c *broadcaster) AddListener(username string, resultChan chan *broadcastResult) 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 *broadcastResult{resultChan}
+
+	return true
+}
+
+func (c *broadcaster) BroadcastAndRemove(username string, result *broadcastResult) {
+	c.lock.Lock()
+	defer c.lock.Unlock()
+
+	val, ok := c.listeners[username]
+	if !ok {
+		return
+	}
+
+	for _, channel := range val {
+		go func(channel chan *broadcastResult) {
+			channel <- result
+			close(channel)
+		}(channel)
+	}
+
+	delete(c.listeners, username)
+}
+
+// https://help.minecraft.net/hc/en-us/articles/4408950195341#h_01GE5JX1Z0CZ833A7S54Y195KV
+var allowedUsernamesRegex = regexp.MustCompile(`(?i)^[0-9a-z_]{3,16}$`)
+
+type UUIDsProvider interface {
+	GetUuid(username string) (*mojang.ProfileInfo, error)
+}
+
+type TexturesProvider interface {
+	GetTextures(uuid string) (*mojang.SignedTexturesResponse, error)
+}
+
+type Emitter interface {
+	dispatcher.Emitter
+}
+
+type Provider struct {
+	Emitter
+	UUIDsProvider
+	TexturesProvider
+	Storage
+
+	onFirstCall sync.Once
+	*broadcaster
+}
+
+func (ctx *Provider) GetForUsername(username string) (*mojang.SignedTexturesResponse, error) {
+	ctx.onFirstCall.Do(func() {
+		ctx.broadcaster = createBroadcaster()
+	})
+
+	if !allowedUsernamesRegex.MatchString(username) {
+		return nil, nil
+	}
+
+	username = strings.ToLower(username)
+	ctx.Emit("mojang_textures:call", username)
+
+	uuid, found, err := ctx.getUuidFromCache(username)
+	if err != nil {
+		return nil, err
+	}
+
+	if found && uuid == "" {
+		return nil, nil
+	}
+
+	if uuid != "" {
+		textures, err := ctx.getTexturesFromCache(uuid)
+		if err == nil && textures != nil {
+			return textures, nil
+		}
+	}
+
+	resultChan := make(chan *broadcastResult)
+	isFirstListener := ctx.broadcaster.AddListener(username, resultChan)
+	if isFirstListener {
+		go ctx.getResultAndBroadcast(username, uuid)
+	} else {
+		ctx.Emit("mojang_textures:already_processing", username)
+	}
+
+	result := <-resultChan
+
+	return result.textures, result.error
+}
+
+func (ctx *Provider) getResultAndBroadcast(username string, uuid string) {
+	ctx.Emit("mojang_textures:before_result", username, uuid)
+	result := ctx.getResult(username, uuid)
+	ctx.Emit("mojang_textures:after_result", username, result.textures, result.error)
+
+	ctx.broadcaster.BroadcastAndRemove(username, result)
+}
+
+func (ctx *Provider) getResult(username string, cachedUuid string) *broadcastResult {
+	uuid := cachedUuid
+	if uuid == "" {
+		profile, err := ctx.getUuid(username)
+		if err != nil {
+			return &broadcastResult{nil, err}
+		}
+
+		uuid = ""
+		if profile != nil {
+			uuid = profile.Id
+		}
+
+		_ = ctx.Storage.StoreUuid(username, uuid)
+
+		if uuid == "" {
+			return &broadcastResult{nil, nil}
+		}
+	}
+
+	textures, err := ctx.getTextures(uuid)
+	if err != nil {
+		// Previously cached UUIDs may disappear
+		// In this case we must invalidate UUID cache for given username
+		if _, ok := err.(*mojang.EmptyResponse); ok && cachedUuid != "" {
+			return ctx.getResult(username, "")
+		}
+
+		return &broadcastResult{nil, err}
+	}
+
+	// Mojang can respond with an error, but it will still count as a hit,
+	// therefore store the result even if textures is nil to prevent 429 error
+	ctx.Storage.StoreTextures(uuid, textures)
+
+	return &broadcastResult{textures, nil}
+}
+
+func (ctx *Provider) getUuidFromCache(username string) (string, bool, error) {
+	ctx.Emit("mojang_textures:usernames:before_cache", username)
+	uuid, found, err := ctx.Storage.GetUuid(username)
+	ctx.Emit("mojang_textures:usernames:after_cache", username, uuid, found, err)
+
+	return uuid, found, err
+}
+
+func (ctx *Provider) getTexturesFromCache(uuid string) (*mojang.SignedTexturesResponse, error) {
+	ctx.Emit("mojang_textures:textures:before_cache", uuid)
+	textures, err := ctx.Storage.GetTextures(uuid)
+	ctx.Emit("mojang_textures:textures:after_cache", uuid, textures, err)
+
+	return textures, err
+}
+
+func (ctx *Provider) getUuid(username string) (*mojang.ProfileInfo, error) {
+	ctx.Emit("mojang_textures:usernames:before_call", username)
+	profile, err := ctx.UUIDsProvider.GetUuid(username)
+	ctx.Emit("mojang_textures:usernames:after_call", username, profile, err)
+
+	return profile, err
+}
+
+func (ctx *Provider) getTextures(uuid string) (*mojang.SignedTexturesResponse, error) {
+	ctx.Emit("mojang_textures:textures:before_call", uuid)
+	textures, err := ctx.TexturesProvider.GetTextures(uuid)
+	ctx.Emit("mojang_textures:textures:after_call", uuid, textures, err)
+
+	return textures, err
+}

mojangtextures/mojang_textures_test.go

@@ -0,0 +1,457 @@
+package mojangtextures
+
+import (
+	"errors"
+	"sync"
+	"testing"
+	"time"
+
+	testify "github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/mock"
+	"github.com/stretchr/testify/suite"
+
+	"github.com/elyby/chrly/api/mojang"
+)
+
+func TestBroadcaster(t *testing.T) {
+	t.Run("GetOrAppend", func(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 := createBroadcaster()
+			channel := make(chan *broadcastResult)
+			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 := createBroadcaster()
+			channel1 := make(chan *broadcastResult)
+			isFirstListener := broadcaster.AddListener("mock", channel1)
+
+			assert.True(isFirstListener)
+
+			channel2 := make(chan *broadcastResult)
+			isFirstListener = broadcaster.AddListener("mock", channel2)
+
+			assert.False(isFirstListener)
+
+			channel3 := make(chan *broadcastResult)
+			isFirstListener = broadcaster.AddListener("mock", channel3)
+
+			assert.False(isFirstListener)
+		})
+	})
+
+	t.Run("BroadcastAndRemove", func(t *testing.T) {
+		t.Run("should broadcast to all listeners and remove the key", func(t *testing.T) {
+			assert := testify.New(t)
+
+			broadcaster := createBroadcaster()
+			channel1 := make(chan *broadcastResult)
+			channel2 := make(chan *broadcastResult)
+			broadcaster.AddListener("mock", channel1)
+			broadcaster.AddListener("mock", channel2)
+
+			result := &broadcastResult{}
+			broadcaster.BroadcastAndRemove("mock", result)
+
+			assert.Equal(result, <-channel1)
+			assert.Equal(result, <-channel2)
+
+			channel3 := make(chan *broadcastResult)
+			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 := createBroadcaster()
+				broadcaster.BroadcastAndRemove("mock", &broadcastResult{})
+			})
+		})
+	})
+}
+
+type mockEmitter struct {
+	mock.Mock
+}
+
+func (e *mockEmitter) Emit(name string, args ...interface{}) {
+	e.Called(append([]interface{}{name}, args...)...)
+}
+
+type mockUuidsProvider struct {
+	mock.Mock
+}
+
+func (m *mockUuidsProvider) GetUuid(username string) (*mojang.ProfileInfo, error) {
+	args := m.Called(username)
+	var result *mojang.ProfileInfo
+	if casted, ok := args.Get(0).(*mojang.ProfileInfo); ok {
+		result = casted
+	}
+
+	return result, args.Error(1)
+}
+
+type mockTexturesProvider struct {
+	mock.Mock
+}
+
+func (m *mockTexturesProvider) 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)
+}
+
+type mockStorage struct {
+	mock.Mock
+}
+
+func (m *mockStorage) GetUuid(username string) (string, bool, error) {
+	args := m.Called(username)
+	return args.String(0), args.Bool(1), args.Error(2)
+}
+
+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 providerTestSuite struct {
+	suite.Suite
+	Provider         *Provider
+	Emitter          *mockEmitter
+	UuidsProvider    *mockUuidsProvider
+	TexturesProvider *mockTexturesProvider
+	Storage          *mockStorage
+}
+
+func (suite *providerTestSuite) SetupTest() {
+	suite.Emitter = &mockEmitter{}
+	suite.UuidsProvider = &mockUuidsProvider{}
+	suite.TexturesProvider = &mockTexturesProvider{}
+	suite.Storage = &mockStorage{}
+
+	suite.Provider = &Provider{
+		Emitter:          suite.Emitter,
+		UUIDsProvider:    suite.UuidsProvider,
+		TexturesProvider: suite.TexturesProvider,
+		Storage:          suite.Storage,
+	}
+}
+
+func (suite *providerTestSuite) TearDownTest() {
+	suite.Emitter.AssertExpectations(suite.T())
+	suite.UuidsProvider.AssertExpectations(suite.T())
+	suite.TexturesProvider.AssertExpectations(suite.T())
+	suite.Storage.AssertExpectations(suite.T())
+}
+
+func TestProvider(t *testing.T) {
+	suite.Run(t, new(providerTestSuite))
+}
+
+func (suite *providerTestSuite) TestGetForUsernameWithoutAnyCache() {
+	expectedProfile := &mojang.ProfileInfo{Id: "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", Name: "username"}
+	expectedResult := &mojang.SignedTexturesResponse{Id: "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", Name: "username"}
+
+	suite.Emitter.On("Emit", "mojang_textures:call", "username").Once()
+	suite.Emitter.On("Emit", "mojang_textures:usernames:before_cache", "username").Once()
+	suite.Emitter.On("Emit", "mojang_textures:usernames:after_cache", "username", "", false, nil).Once()
+	suite.Emitter.On("Emit", "mojang_textures:before_result", "username", "").Once()
+	suite.Emitter.On("Emit", "mojang_textures:usernames:before_call", "username").Once()
+	suite.Emitter.On("Emit", "mojang_textures:usernames:after_call", "username", expectedProfile, nil).Once()
+	suite.Emitter.On("Emit", "mojang_textures:textures:before_call", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa").Once()
+	suite.Emitter.On("Emit", "mojang_textures:textures:after_call", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", expectedResult, nil).Once()
+	suite.Emitter.On("Emit", "mojang_textures:after_result", "username", expectedResult, nil).Once()
+
+	suite.Storage.On("GetUuid", "username").Once().Return("", false, nil)
+	suite.Storage.On("StoreUuid", "username", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa").Once().Return(nil)
+	suite.Storage.On("StoreTextures", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", expectedResult).Once()
+
+	suite.UuidsProvider.On("GetUuid", "username").Once().Return(expectedProfile, nil)
+	suite.TexturesProvider.On("GetTextures", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa").Once().Return(expectedResult, nil)
+
+	result, err := suite.Provider.GetForUsername("username")
+
+	suite.Assert().Nil(err)
+	suite.Assert().Equal(expectedResult, result)
+}
+
+func (suite *providerTestSuite) TestGetForUsernameWithCachedUuid() {
+	var expectedCachedTextures *mojang.SignedTexturesResponse
+	expectedResult := &mojang.SignedTexturesResponse{Id: "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", Name: "username"}
+
+	suite.Emitter.On("Emit", "mojang_textures:call", "username").Once()
+	suite.Emitter.On("Emit", "mojang_textures:usernames:before_cache", "username").Once()
+	suite.Emitter.On("Emit", "mojang_textures:usernames:after_cache", "username", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", true, nil).Once()
+	suite.Emitter.On("Emit", "mojang_textures:textures:before_cache", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa").Once()
+	suite.Emitter.On("Emit", "mojang_textures:textures:after_cache", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", expectedCachedTextures, nil).Once()
+	suite.Emitter.On("Emit", "mojang_textures:before_result", "username", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa").Once()
+	suite.Emitter.On("Emit", "mojang_textures:textures:before_call", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa").Once()
+	suite.Emitter.On("Emit", "mojang_textures:textures:after_call", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", expectedResult, nil).Once()
+	suite.Emitter.On("Emit", "mojang_textures:after_result", "username", expectedResult, nil).Once()
+
+	suite.Storage.On("GetUuid", "username").Once().Return("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", true, nil)
+	suite.Storage.On("GetTextures", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa").Once().Return(nil, nil)
+	suite.Storage.On("StoreTextures", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", expectedResult).Once()
+
+	suite.TexturesProvider.On("GetTextures", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa").Return(expectedResult, nil)
+
+	result, err := suite.Provider.GetForUsername("username")
+
+	suite.Assert().Nil(err)
+	suite.Assert().Equal(expectedResult, result)
+}
+
+func (suite *providerTestSuite) TestGetForUsernameWithFullyCachedResult() {
+	expectedResult := &mojang.SignedTexturesResponse{Id: "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", Name: "username"}
+
+	suite.Emitter.On("Emit", "mojang_textures:call", "username").Once()
+	suite.Emitter.On("Emit", "mojang_textures:usernames:before_cache", "username").Once()
+	suite.Emitter.On("Emit", "mojang_textures:usernames:after_cache", "username", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", true, nil).Once()
+	suite.Emitter.On("Emit", "mojang_textures:textures:before_cache", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa").Once()
+	suite.Emitter.On("Emit", "mojang_textures:textures:after_cache", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", expectedResult, nil).Once()
+
+	suite.Storage.On("GetUuid", "username").Once().Return("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", true, nil)
+	suite.Storage.On("GetTextures", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa").Once().Return(expectedResult, nil)
+
+	result, err := suite.Provider.GetForUsername("username")
+
+	suite.Assert().Nil(err)
+	suite.Assert().Equal(expectedResult, result)
+}
+
+func (suite *providerTestSuite) TestGetForUsernameWithCachedUnknownUuid() {
+	suite.Emitter.On("Emit", "mojang_textures:call", "username").Once()
+	suite.Emitter.On("Emit", "mojang_textures:usernames:before_cache", "username").Once()
+	suite.Emitter.On("Emit", "mojang_textures:usernames:after_cache", "username", "", true, nil).Once()
+
+	suite.Storage.On("GetUuid", "username").Once().Return("", true, nil)
+
+	result, err := suite.Provider.GetForUsername("username")
+
+	suite.Assert().Nil(result)
+	suite.Assert().Nil(err)
+}
+
+func (suite *providerTestSuite) TestGetForUsernameWhichHasNoMojangAccount() {
+	var expectedProfile *mojang.ProfileInfo
+	var expectedResult *mojang.SignedTexturesResponse
+
+	suite.Emitter.On("Emit", "mojang_textures:call", "username").Once()
+	suite.Emitter.On("Emit", "mojang_textures:usernames:before_cache", "username").Once()
+	suite.Emitter.On("Emit", "mojang_textures:usernames:after_cache", "username", "", false, nil).Once()
+	suite.Emitter.On("Emit", "mojang_textures:before_result", "username", "").Once()
+	suite.Emitter.On("Emit", "mojang_textures:usernames:before_call", "username").Once()
+	suite.Emitter.On("Emit", "mojang_textures:usernames:after_call", "username", expectedProfile, nil).Once()
+	suite.Emitter.On("Emit", "mojang_textures:after_result", "username", expectedResult, nil).Once()
+
+	suite.Storage.On("GetUuid", "username").Once().Return("", false, nil)
+	suite.Storage.On("StoreUuid", "username", "").Once().Return(nil)
+
+	suite.UuidsProvider.On("GetUuid", "username").Once().Return(nil, nil)
+
+	result, err := suite.Provider.GetForUsername("username")
+
+	suite.Assert().Nil(err)
+	suite.Assert().Nil(result)
+}
+
+func (suite *providerTestSuite) TestGetForUsernameWhichHasMojangAccountButHasNoMojangSkin() {
+	expectedProfile := &mojang.ProfileInfo{Id: "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", Name: "username"}
+	var expectedResult *mojang.SignedTexturesResponse
+
+	suite.Emitter.On("Emit", "mojang_textures:call", "username").Once()
+	suite.Emitter.On("Emit", "mojang_textures:usernames:before_cache", "username").Once()
+	suite.Emitter.On("Emit", "mojang_textures:usernames:after_cache", "username", "", false, nil).Once()
+	suite.Emitter.On("Emit", "mojang_textures:before_result", "username", "").Once()
+	suite.Emitter.On("Emit", "mojang_textures:usernames:before_call", "username").Once()
+	suite.Emitter.On("Emit", "mojang_textures:usernames:after_call", "username", expectedProfile, nil).Once()
+	suite.Emitter.On("Emit", "mojang_textures:textures:before_call", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa").Once()
+	suite.Emitter.On("Emit", "mojang_textures:textures:after_call", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", expectedResult, nil).Once()
+	suite.Emitter.On("Emit", "mojang_textures:after_result", "username", expectedResult, nil).Once()
+
+	suite.Storage.On("GetUuid", "username").Once().Return("", false, nil)
+	suite.Storage.On("StoreUuid", "username", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa").Once().Return(nil)
+	suite.Storage.On("StoreTextures", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", expectedResult).Once()
+
+	suite.UuidsProvider.On("GetUuid", "username").Once().Return(expectedProfile, nil)
+	suite.TexturesProvider.On("GetTextures", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa").Once().Return(expectedResult, nil)
+
+	result, err := suite.Provider.GetForUsername("username")
+
+	suite.Assert().Equal(expectedResult, result)
+	suite.Assert().Nil(err)
+}
+
+// https://github.com/elyby/chrly/issues/29
+func (suite *providerTestSuite) TestGetForUsernameWithCachedUuidThatHasBeenDisappeared() {
+	expectedErr := &mojang.EmptyResponse{}
+	expectedProfile := &mojang.ProfileInfo{Id: "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb", Name: "username"}
+	var nilTexturesResponse *mojang.SignedTexturesResponse
+	expectedResult := &mojang.SignedTexturesResponse{Id: "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb", Name: "username"}
+
+	suite.Emitter.On("Emit", "mojang_textures:call", "username").Once()
+	suite.Emitter.On("Emit", "mojang_textures:usernames:before_cache", "username").Once()
+	suite.Emitter.On("Emit", "mojang_textures:usernames:after_cache", "username", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", true, nil).Once()
+	suite.Emitter.On("Emit", "mojang_textures:textures:before_cache", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa").Once()
+	suite.Emitter.On("Emit", "mojang_textures:textures:after_cache", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", nilTexturesResponse, nil).Once()
+	suite.Emitter.On("Emit", "mojang_textures:before_result", "username", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa").Once()
+	suite.Emitter.On("Emit", "mojang_textures:textures:before_call", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa").Once()
+	suite.Emitter.On("Emit", "mojang_textures:textures:after_call", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", nilTexturesResponse, expectedErr).Once()
+	suite.Emitter.On("Emit", "mojang_textures:usernames:before_call", "username").Once()
+	suite.Emitter.On("Emit", "mojang_textures:usernames:after_call", "username", expectedProfile, nil).Once()
+	suite.Emitter.On("Emit", "mojang_textures:textures:before_call", "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb").Once()
+	suite.Emitter.On("Emit", "mojang_textures:textures:after_call", "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb", expectedResult, nil).Once()
+	suite.Emitter.On("Emit", "mojang_textures:after_result", "username", expectedResult, nil).Once()
+
+	suite.Storage.On("GetUuid", "username").Once().Return("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", true, nil)
+	suite.Storage.On("GetTextures", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa").Once().Return(nil, nil)
+	suite.Storage.On("StoreUuid", "username", "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb").Once().Return(nil)
+	suite.Storage.On("StoreTextures", "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb", expectedResult).Once()
+
+	suite.UuidsProvider.On("GetUuid", "username").Return(expectedProfile, nil)
+	suite.TexturesProvider.On("GetTextures", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa").Return(nil, expectedErr)
+	suite.TexturesProvider.On("GetTextures", "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb").Return(expectedResult, nil)
+
+	result, err := suite.Provider.GetForUsername("username")
+
+	suite.Assert().Nil(err)
+	suite.Assert().Equal(expectedResult, result)
+}
+
+func (suite *providerTestSuite) TestGetForTheSameUsernames() {
+	expectedProfile := &mojang.ProfileInfo{Id: "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", Name: "username"}
+	expectedResult := &mojang.SignedTexturesResponse{Id: "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", Name: "username"}
+
+	suite.Emitter.On("Emit", "mojang_textures:call", "username").Twice()
+	suite.Emitter.On("Emit", "mojang_textures:usernames:before_cache", "username").Twice()
+	suite.Emitter.On("Emit", "mojang_textures:usernames:after_cache", "username", "", false, nil).Twice()
+	suite.Emitter.On("Emit", "mojang_textures:already_processing", "username").Once()
+	suite.Emitter.On("Emit", "mojang_textures:before_result", "username", "").Once()
+	suite.Emitter.On("Emit", "mojang_textures:usernames:before_call", "username").Once()
+	suite.Emitter.On("Emit", "mojang_textures:usernames:after_call", "username", expectedProfile, nil).Once()
+	suite.Emitter.On("Emit", "mojang_textures:textures:before_call", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa").Once()
+	suite.Emitter.On("Emit", "mojang_textures:textures:after_call", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", expectedResult, nil).Once()
+	suite.Emitter.On("Emit", "mojang_textures:after_result", "username", expectedResult, nil).Once()
+
+	suite.Storage.On("GetUuid", "username").Twice().Return("", false, nil)
+	suite.Storage.On("StoreUuid", "username", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa").Once().Return(nil)
+	suite.Storage.On("StoreTextures", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", expectedResult).Once()
+
+	// If possible, than remove this .After call
+	suite.UuidsProvider.On("GetUuid", "username").Once().After(time.Millisecond).Return(expectedProfile, nil)
+	suite.TexturesProvider.On("GetTextures", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa").Once().Return(expectedResult, nil)
+
+	results := make([]*mojang.SignedTexturesResponse, 2)
+	var wg sync.WaitGroup
+	for i := 0; i < 2; i++ {
+		wg.Add(1)
+		go func(i int) {
+			textures, _ := suite.Provider.GetForUsername("username")
+			results[i] = textures
+			wg.Done()
+		}(i)
+	}
+	wg.Wait()
+
+	suite.Assert().Equal(expectedResult, results[0])
+	suite.Assert().Equal(expectedResult, results[1])
+}
+
+func (suite *providerTestSuite) TestGetForNotAllowedMojangUsername() {
+	result, err := suite.Provider.GetForUsername("Not allowed")
+	suite.Assert().Nil(err)
+	suite.Assert().Nil(result)
+}
+
+func (suite *providerTestSuite) TestGetErrorFromUUIDsStorage() {
+	expectedErr := errors.New("mock error")
+
+	suite.Emitter.On("Emit", "mojang_textures:call", "username").Once()
+	suite.Emitter.On("Emit", "mojang_textures:usernames:before_cache", "username").Once()
+	suite.Emitter.On("Emit", "mojang_textures:usernames:after_cache", "username", "", false, expectedErr).Once()
+
+	suite.Storage.On("GetUuid", "username").Once().Return("", false, expectedErr)
+
+	result, err := suite.Provider.GetForUsername("username")
+
+	suite.Assert().Nil(result)
+	suite.Assert().Equal(expectedErr, err)
+}
+
+func (suite *providerTestSuite) TestGetErrorFromUuidsProvider() {
+	var expectedProfile *mojang.ProfileInfo
+	var expectedResult *mojang.SignedTexturesResponse
+	err := errors.New("mock error")
+
+	suite.Emitter.On("Emit", "mojang_textures:call", "username").Once()
+	suite.Emitter.On("Emit", "mojang_textures:usernames:before_cache", "username").Once()
+	suite.Emitter.On("Emit", "mojang_textures:usernames:after_cache", "username", "", false, nil).Once()
+	suite.Emitter.On("Emit", "mojang_textures:before_result", "username", "").Once()
+	suite.Emitter.On("Emit", "mojang_textures:usernames:before_call", "username").Once()
+	suite.Emitter.On("Emit", "mojang_textures:usernames:after_call", "username", expectedProfile, err).Once()
+	suite.Emitter.On("Emit", "mojang_textures:after_result", "username", expectedResult, err).Once()
+
+	suite.Storage.On("GetUuid", "username").Once().Return("", false, nil)
+	suite.UuidsProvider.On("GetUuid", "username").Once().Return(nil, err)
+
+	result, resErr := suite.Provider.GetForUsername("username")
+	suite.Assert().Nil(result)
+	suite.Assert().Equal(err, resErr)
+}
+
+func (suite *providerTestSuite) TestGetErrorFromTexturesProvider() {
+	expectedProfile := &mojang.ProfileInfo{Id: "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", Name: "username"}
+	var expectedResult *mojang.SignedTexturesResponse
+	err := errors.New("mock error")
+
+	suite.Emitter.On("Emit", "mojang_textures:call", "username").Once()
+	suite.Emitter.On("Emit", "mojang_textures:usernames:before_cache", "username").Once()
+	suite.Emitter.On("Emit", "mojang_textures:usernames:after_cache", "username", "", false, nil).Once()
+	suite.Emitter.On("Emit", "mojang_textures:before_result", "username", "").Once()
+	suite.Emitter.On("Emit", "mojang_textures:usernames:before_call", "username").Once()
+	suite.Emitter.On("Emit", "mojang_textures:usernames:after_call", "username", expectedProfile, nil).Once()
+	suite.Emitter.On("Emit", "mojang_textures:textures:before_call", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa").Once()
+	suite.Emitter.On("Emit", "mojang_textures:textures:after_call", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", expectedResult, err).Once()
+	suite.Emitter.On("Emit", "mojang_textures:after_result", "username", expectedResult, err).Once()
+
+	suite.Storage.On("GetUuid", "username").Return("", false, nil)
+	suite.Storage.On("StoreUuid", "username", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa").Return(nil)
+	suite.UuidsProvider.On("GetUuid", "username").Once().Return(expectedProfile, nil)
+	suite.TexturesProvider.On("GetTextures", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa").Once().Return(nil, err)
+
+	result, resErr := suite.Provider.GetForUsername("username")
+	suite.Assert().Nil(result)
+	suite.Assert().Equal(err, resErr)
+}

mojangtextures/nil_mojang_textures.go

@@ -0,0 +1,12 @@
+package mojangtextures
+
+import (
+	"github.com/elyby/chrly/api/mojang"
+)
+
+type NilProvider struct {
+}
+
+func (p *NilProvider) GetForUsername(username string) (*mojang.SignedTexturesResponse, error) {
+	return nil, nil
+}

mojangtextures/nil_mojang_textures_test.go

@@ -0,0 +1,14 @@
+package mojangtextures
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestNilProvider_GetForUsername(t *testing.T) {
+	provider := &NilProvider{}
+	result, err := provider.GetForUsername("username")
+	assert.Nil(t, result)
+	assert.Nil(t, err)
+}

mojangtextures/remote_api_uuids_provider.go

@@ -0,0 +1,67 @@
+package mojangtextures
+
+import (
+	"encoding/json"
+	"io/ioutil"
+	"net/http"
+	. "net/url"
+	"path"
+
+	"github.com/elyby/chrly/api/mojang"
+	"github.com/elyby/chrly/version"
+)
+
+var HttpClient = &http.Client{
+	Transport: &http.Transport{
+		MaxIdleConnsPerHost: 1024,
+	},
+}
+
+type RemoteApiUuidsProvider struct {
+	Emitter
+	Url URL
+}
+
+func (ctx *RemoteApiUuidsProvider) GetUuid(username string) (*mojang.ProfileInfo, error) {
+	url := ctx.Url
+	url.Path = path.Join(url.Path, username)
+	urlStr := url.String()
+
+	request, _ := http.NewRequest("GET", urlStr, nil)
+	request.Header.Add("Accept", "application/json")
+	// Change default User-Agent to allow specify "Username -> UUID at time" Mojang's api endpoint
+	request.Header.Add("User-Agent", "Chrly/"+version.Version())
+
+	ctx.Emit("mojang_textures:remote_api_uuids_provider:before_request", urlStr)
+	response, err := HttpClient.Do(request)
+	ctx.Emit("mojang_textures:remote_api_uuids_provider:after_request", response, err)
+	if err != nil {
+		return nil, err
+	}
+	defer response.Body.Close()
+
+	if response.StatusCode == 204 {
+		return nil, nil
+	}
+
+	if response.StatusCode != 200 {
+		return nil, &UnexpectedRemoteApiResponse{response}
+	}
+
+	var result *mojang.ProfileInfo
+	body, _ := ioutil.ReadAll(response.Body)
+	err = json.Unmarshal(body, &result)
+	if err != nil {
+		return nil, err
+	}
+
+	return result, nil
+}
+
+type UnexpectedRemoteApiResponse struct {
+	Response *http.Response
+}
+
+func (*UnexpectedRemoteApiResponse) Error() string {
+	return "Unexpected remote api response"
+}

mojangtextures/remote_api_uuids_provider_test.go

@@ -0,0 +1,168 @@
+package mojangtextures
+
+import (
+	"net"
+	"net/http"
+	. "net/url"
+	"testing"
+
+	"github.com/h2non/gock"
+
+	"github.com/stretchr/testify/mock"
+	"github.com/stretchr/testify/suite"
+)
+
+type remoteApiUuidsProviderTestSuite struct {
+	suite.Suite
+
+	Provider *RemoteApiUuidsProvider
+	Emitter  *mockEmitter
+}
+
+func (suite *remoteApiUuidsProviderTestSuite) SetupSuite() {
+	client := &http.Client{}
+	gock.InterceptClient(client)
+
+	HttpClient = client
+}
+
+func (suite *remoteApiUuidsProviderTestSuite) SetupTest() {
+	suite.Emitter = &mockEmitter{}
+	suite.Provider = &RemoteApiUuidsProvider{
+		Emitter: suite.Emitter,
+	}
+}
+
+func (suite *remoteApiUuidsProviderTestSuite) TearDownTest() {
+	suite.Emitter.AssertExpectations(suite.T())
+	gock.Off()
+}
+
+func TestRemoteApiUuidsProvider(t *testing.T) {
+	suite.Run(t, new(remoteApiUuidsProviderTestSuite))
+}
+
+func (suite *remoteApiUuidsProviderTestSuite) TestGetUuidForValidUsername() {
+	suite.Emitter.On("Emit", "mojang_textures:remote_api_uuids_provider:before_request", "http://example.com/subpath/username").Once()
+	suite.Emitter.On("Emit",
+		"mojang_textures:remote_api_uuids_provider:after_request",
+		mock.AnythingOfType("*http.Response"),
+		nil,
+	).Once()
+
+	gock.New("http://example.com").
+		Get("/subpath/username").
+		Reply(200).
+		JSON(map[string]interface{}{
+			"id":   "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+			"name": "username",
+		})
+
+	suite.Provider.Url = shouldParseUrl("http://example.com/subpath")
+	result, err := suite.Provider.GetUuid("username")
+
+	assert := suite.Assert()
+	if assert.NoError(err) {
+		assert.Equal("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", result.Id)
+		assert.Equal("username", result.Name)
+		assert.False(result.IsLegacy)
+		assert.False(result.IsDemo)
+	}
+}
+
+func (suite *remoteApiUuidsProviderTestSuite) TestGetUuidForNotExistsUsername() {
+	suite.Emitter.On("Emit", "mojang_textures:remote_api_uuids_provider:before_request", "http://example.com/subpath/username").Once()
+	suite.Emitter.On("Emit",
+		"mojang_textures:remote_api_uuids_provider:after_request",
+		mock.AnythingOfType("*http.Response"),
+		nil,
+	).Once()
+
+	gock.New("http://example.com").
+		Get("/subpath/username").
+		Reply(204)
+
+	suite.Provider.Url = shouldParseUrl("http://example.com/subpath")
+	result, err := suite.Provider.GetUuid("username")
+
+	assert := suite.Assert()
+	assert.Nil(result)
+	assert.Nil(err)
+}
+
+func (suite *remoteApiUuidsProviderTestSuite) TestGetUuidForNon20xResponse() {
+	suite.Emitter.On("Emit", "mojang_textures:remote_api_uuids_provider:before_request", "http://example.com/subpath/username").Once()
+	suite.Emitter.On("Emit",
+		"mojang_textures:remote_api_uuids_provider:after_request",
+		mock.AnythingOfType("*http.Response"),
+		nil,
+	).Once()
+
+	gock.New("http://example.com").
+		Get("/subpath/username").
+		Reply(504).
+		BodyString("504 Gateway Timeout")
+
+	suite.Provider.Url = shouldParseUrl("http://example.com/subpath")
+	result, err := suite.Provider.GetUuid("username")
+
+	assert := suite.Assert()
+	assert.Nil(result)
+	assert.EqualError(err, "Unexpected remote api response")
+}
+
+func (suite *remoteApiUuidsProviderTestSuite) TestGetUuidForNotSuccessRequest() {
+	suite.Emitter.On("Emit", "mojang_textures:remote_api_uuids_provider:before_request", "http://example.com/subpath/username").Once()
+	suite.Emitter.On("Emit",
+		"mojang_textures:remote_api_uuids_provider:after_request",
+		mock.AnythingOfType("*http.Response"),
+		mock.AnythingOfType("*url.Error"),
+	).Once()
+
+	expectedError := &net.OpError{Op: "dial"}
+
+	gock.New("http://example.com").
+		Get("/subpath/username").
+		ReplyError(expectedError)
+
+	suite.Provider.Url = shouldParseUrl("http://example.com/subpath")
+	result, err := suite.Provider.GetUuid("username")
+
+	assert := suite.Assert()
+	assert.Nil(result)
+	if assert.Error(err) {
+		assert.IsType(&Error{}, err)
+		casterErr, _ := err.(*Error)
+		assert.Equal(expectedError, casterErr.Err)
+	}
+}
+
+func (suite *remoteApiUuidsProviderTestSuite) TestGetUuidForInvalidSuccessResponse() {
+	suite.Emitter.On("Emit", "mojang_textures:remote_api_uuids_provider:before_request", "http://example.com/subpath/username").Once()
+	suite.Emitter.On("Emit",
+		"mojang_textures:remote_api_uuids_provider:after_request",
+		mock.AnythingOfType("*http.Response"),
+		nil,
+	).Once()
+
+	gock.New("http://example.com").
+		Get("/subpath/username").
+		Reply(200).
+		BodyString("completely not json")
+
+	suite.Provider.Url = shouldParseUrl("http://example.com/subpath")
+	result, err := suite.Provider.GetUuid("username")
+
+	assert := suite.Assert()
+	assert.Nil(result)
+	assert.Error(err)
+}
+
+func shouldParseUrl(rawUrl string) URL {
+	url, err := Parse(rawUrl)
+	if err != nil {
+		panic(err)
+	}
+
+	return *url
+}

mojangtextures/storage.go

@@ -0,0 +1,53 @@
+package mojangtextures
+
+import (
+	"github.com/elyby/chrly/api/mojang"
+)
+
+// UUIDsStorage is a key-value storage of Mojang usernames pairs to its UUIDs,
+// used to reduce the load on the account information queue
+type UUIDsStorage interface {
+	// The second argument indicates whether a record was found in the storage,
+	// since depending on it, the empty value must be interpreted as "no cached record"
+	// or "value cached and has an empty value"
+	GetUuid(username string) (uuid string, found bool, err error)
+	// An empty uuid value can be passed if the corresponding account has not been found
+	StoreUuid(username string, uuid string) error
+}
+
+// TexturesStorage is a Mojang's textures storage, used as a values cache to avoid 429 errors
+type TexturesStorage interface {
+	// Error should not have nil value only if the repository failed to determine if there are any textures
+	// for this uuid or not at all. If there is information about the absence of textures, nil nil should be returned
+	GetTextures(uuid string) (*mojang.SignedTexturesResponse, error)
+	// The nil value can be passed when there are no textures for the corresponding uuid and we know about it
+	StoreTextures(uuid string, textures *mojang.SignedTexturesResponse)
+}
+
+type Storage interface {
+	UUIDsStorage
+	TexturesStorage
+}
+
+// SeparatedStorage allows you to use separate storage engines to satisfy
+// the Storage interface
+type SeparatedStorage struct {
+	UUIDsStorage
+	TexturesStorage
+}
+
+func (s *SeparatedStorage) GetUuid(username string) (string, bool, error) {
+	return s.UUIDsStorage.GetUuid(username)
+}
+
+func (s *SeparatedStorage) StoreUuid(username string, uuid string) error {
+	return s.UUIDsStorage.StoreUuid(username, uuid)
+}
+
+func (s *SeparatedStorage) GetTextures(uuid string) (*mojang.SignedTexturesResponse, error) {
+	return s.TexturesStorage.GetTextures(uuid)
+}
+
+func (s *SeparatedStorage) StoreTextures(uuid string, textures *mojang.SignedTexturesResponse) {
+	s.TexturesStorage.StoreTextures(uuid, textures)
+}

mojangtextures/storage_test.go

@@ -0,0 +1,85 @@
+package mojangtextures
+
+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, bool, error) {
+	args := m.Called(username)
+	return args.String(0), args.Bool(1), args.Error(2)
+}
+
+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() (*SeparatedStorage, *uuidsStorageMock, *texturesStorageMock) {
+		uuidsStorage := &uuidsStorageMock{}
+		texturesStorage := &texturesStorageMock{}
+
+		return &SeparatedStorage{uuidsStorage, texturesStorage}, uuidsStorage, texturesStorage
+	}
+
+	t.Run("GetUuid", func(t *testing.T) {
+		storage, uuidsMock, _ := createMockedStorage()
+		uuidsMock.On("GetUuid", "username").Once().Return("find me", true, nil)
+		result, found, err := storage.GetUuid("username")
+		assert.Nil(t, err)
+		assert.True(t, found)
+		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)
+	})
+}

nginx.conf

@@ -1,40 +0,0 @@
-location /minecraft.php {
-    if ($arg_name = "") {
-        return 400;
-    }
-
-    if ($arg_type = "cloack") {
-        rewrite .* http://skins.minecraft.net/MinecraftCloaks/$arg_name.png? permanent;
-        break;
-    }
-
-    if ($arg_type = "skin") {
-        rewrite .* /skins/$arg_name last;
-    }
-
-    return 404;
-}
-
-location /cloaks/ {
-    try_files $uri $uri.png @cloaks;
-}
-
-location @cloaks {
-    rewrite ^/cloaks/(.+?)(\.[^.]*$|$)$ http://skins.minecraft.net/MinecraftCloaks/$1.png? permanent;
-}
-
-location ~* ^/skins/$ {
-    if ($arg_name = "") {
-        return 400;
-    }
-
-    rewrite .* /skins/$arg_name permanent;
-}
-
-location ~* ^/cloaks/$ {
-    if ($arg_name = "") {
-        return 400;
-    }
-
-    rewrite .* /cloaks/$arg_name permanent;
-}

public/.htaccess

@@ -1,7 +0,0 @@
-AddDefaultCharset UTF-8
-
-<IfModule mod_rewrite.c>
-    RewriteEngine On
-    RewriteCond %{REQUEST_FILENAME} !-f
-    RewriteRule ^(.*)$ index.php?_url=/$1 [QSA,L]
-</IfModule>

public/index.php

@@ -1,24 +0,0 @@
-<?php
-
-use Phalcon\Mvc\Micro;
-
-error_reporting(E_ALL);
-
-try {
-    /** @var \Phalcon\Config $config */
-    $config = include __DIR__ . '/../config/config.php';
-    /** @var \Phalcon\Loader $loader */
-    include __DIR__ . '/../config/loader.php';
-    /** @var Phalcon\DI\FactoryDefault $di */
-    include __DIR__ . '/../config/services.php';
-
-    $app = new Micro($di);
-    include __DIR__ . '/../app.php';
-
-    $app->handle();
-
-} catch (Phalcon\Exception $e) {
-    echo $e->getMessage();
-} catch (PDOException $e) {
-    echo $e->getMessage();
-}

signer/signer.go

@@ -0,0 +1,42 @@
+package signer
+
+import (
+	"crypto"
+	"crypto/rand"
+	"crypto/rsa"
+	"crypto/sha1"
+	"encoding/base64"
+	"errors"
+)
+
+var randomReader = rand.Reader
+
+type Signer struct {
+	Key *rsa.PrivateKey
+}
+
+func (s *Signer) SignTextures(textures string) (string, error) {
+	if s.Key == nil {
+		return "", errors.New("Key is empty")
+	}
+
+	message := []byte(textures)
+	messageHash := sha1.New()
+	_, _ = messageHash.Write(message)
+	messageHashSum := messageHash.Sum(nil)
+
+	signature, err := rsa.SignPKCS1v15(randomReader, s.Key, crypto.SHA1, messageHashSum)
+	if err != nil {
+		panic(err)
+	}
+
+	return base64.StdEncoding.EncodeToString(signature), nil
+}
+
+func (s *Signer) GetPublicKey() (*rsa.PublicKey, error) {
+	if s.Key == nil {
+		return nil, errors.New("Key is empty")
+	}
+
+	return &s.Key.PublicKey, nil
+}

signer/signer_test.go

@@ -0,0 +1,64 @@
+package signer
+
+import (
+	"crypto/rsa"
+	"crypto/x509"
+	"encoding/pem"
+
+	"testing"
+
+	assert "github.com/stretchr/testify/require"
+)
+
+type ConstantReader struct {
+}
+
+func (c *ConstantReader) Read(p []byte) (int, error) {
+	return 1, nil
+}
+
+func TestSigner_SignTextures(t *testing.T) {
+	randomReader = &ConstantReader{}
+
+	t.Run("sign textures", func(t *testing.T) {
+		rawKey, _ := pem.Decode([]byte("-----BEGIN RSA PRIVATE KEY-----\nMIIBOwIBAAJBANbUpVCZkMKpfvYZ08W3lumdAaYxLBnmUDlzHBQH3DpYef5WCO32\nTDU6feIJ58A0lAywgtZ4wwi2dGHOz/1hAvcCAwEAAQJAItaxSHTe6PKbyEU/9pxj\nONdhYRYwVLLo56gnMYhkyoEqaaMsfov8hhoepkYZBMvZFB2bDOsQ2SaJ+E2eiBO4\nAQIhAPssS0+BR9w0bOdmjGqmdE9NrN5UJQcOW13s29+6QzUBAiEA2vWOepA5Apiu\npEA3pwoGdkVCrNSnnKjDQzDXBnpd3/cCIEFNd9sY4qUG4FWdXN6RnmXL7Sj0uZfH\nDMwzu8rEM5sBAiEAhvdoDNqLmbMdq3c+FsPSOeL1d21Zp/JK8kbPtFmHNf8CIQDV\n6FSZDwvWfuxaM7BsycQONkjDBTPNu+lqctJBGnBv3A==\n-----END RSA PRIVATE KEY-----\n"))
+		key, _ := x509.ParsePKCS1PrivateKey(rawKey.Bytes)
+
+		signer := &Signer{key}
+
+		signature, err := signer.SignTextures("eyJ0aW1lc3RhbXAiOjE2MTQzMDcxMzQsInByb2ZpbGVJZCI6ImZmYzhmZGM5NTgyNDUwOWU4YTU3Yzk5Yjk0MGZiOTk2IiwicHJvZmlsZU5hbWUiOiJFcmlja1NrcmF1Y2giLCJ0ZXh0dXJlcyI6eyJTS0lOIjp7InVybCI6Imh0dHA6Ly9lbHkuYnkvc3RvcmFnZS9za2lucy82OWM2NzQwZDI5OTNlNWQ2ZjZhN2ZjOTI0MjBlZmMyOS5wbmcifX0sImVseSI6dHJ1ZX0")
+		assert.NoError(t, err)
+		assert.Equal(t, "IyHCxTP5ITquEXTHcwCtLd08jWWy16JwlQeWg8naxhoAVQecHGRdzHRscuxtdq/446kmeox7h4EfRN2A2ZLL+A==", signature)
+	})
+
+	t.Run("empty key", func(t *testing.T) {
+		signer := &Signer{}
+
+		signature, err := signer.SignTextures("hello world")
+		assert.Error(t, err, "Key is empty")
+		assert.Empty(t, signature)
+	})
+}
+
+func TestSigner_GetPublicKey(t *testing.T) {
+	randomReader = &ConstantReader{}
+
+	t.Run("get public key", func(t *testing.T) {
+		rawKey, _ := pem.Decode([]byte("-----BEGIN RSA PRIVATE KEY-----\nMIIBOwIBAAJBANbUpVCZkMKpfvYZ08W3lumdAaYxLBnmUDlzHBQH3DpYef5WCO32\nTDU6feIJ58A0lAywgtZ4wwi2dGHOz/1hAvcCAwEAAQJAItaxSHTe6PKbyEU/9pxj\nONdhYRYwVLLo56gnMYhkyoEqaaMsfov8hhoepkYZBMvZFB2bDOsQ2SaJ+E2eiBO4\nAQIhAPssS0+BR9w0bOdmjGqmdE9NrN5UJQcOW13s29+6QzUBAiEA2vWOepA5Apiu\npEA3pwoGdkVCrNSnnKjDQzDXBnpd3/cCIEFNd9sY4qUG4FWdXN6RnmXL7Sj0uZfH\nDMwzu8rEM5sBAiEAhvdoDNqLmbMdq3c+FsPSOeL1d21Zp/JK8kbPtFmHNf8CIQDV\n6FSZDwvWfuxaM7BsycQONkjDBTPNu+lqctJBGnBv3A==\n-----END RSA PRIVATE KEY-----\n"))
+		key, _ := x509.ParsePKCS1PrivateKey(rawKey.Bytes)
+
+		signer := &Signer{key}
+
+		publicKey, err := signer.GetPublicKey()
+		assert.NoError(t, err)
+		assert.IsType(t, &rsa.PublicKey{}, publicKey)
+	})
+
+	t.Run("empty key", func(t *testing.T) {
+		signer := &Signer{}
+
+		publicKey, err := signer.GetPublicKey()
+		assert.Error(t, err, "Key is empty")
+		assert.Nil(t, publicKey)
+	})
+}

utils/time.go

@@ -0,0 +1,7 @@
+package utils
+
+import "time"
+
+func UnixMillisecond(t time.Time) int64 {
+	return t.UnixNano() / int64(time.Millisecond)
+}

utils/time_test.go

@@ -0,0 +1,16 @@
+package utils
+
+import (
+	"time"
+
+	"testing"
+
+	assert "github.com/stretchr/testify/require"
+)
+
+func TestUnixMillisecond(t *testing.T) {
+	loc, _ := time.LoadLocation("CET")
+	d := time.Date(2021, 02, 26, 00, 43, 57, 987654321, loc)
+
+	assert.Equal(t, int64(1614296637987), UnixMillisecond(d))
+}

version/version.go

@@ -0,0 +1,14 @@
+package version
+
+var (
+	version = ""
+	commit  = ""
+)
+
+func Version() string {
+	return version
+}
+
+func Commit() string {
+	return commit
+}