Merge branch 'develop'

.gitlab-ci.yml

@@ -0,0 +1,33 @@
+image: docker:latest
+
+stages:
+    - build
+    - push
+
+before_script:
+    - docker login -u gitlab-ci -p $CI_BUILD_TOKEN registry.ely.by
+
+variables:
+    CONTAINER_IMAGE: registry.ely.by/elyby/skinsystem
+
+build:
+    stage: build
+    script:
+        - export IMAGE_NAME="$CONTAINER_IMAGE:dev"
+        - docker build --pull -t $IMAGE_NAME .
+        - docker push $IMAGE_NAME
+    only:
+        - develop
+
+push_tags:
+    stage: push
+    variables:
+        GIT_STRATEGY: none
+    script:
+        - export IMAGE_NAME="$CONTAINER_IMAGE:$CI_BUILD_TAG"
+        - docker tag $CONTAINER_IMAGE:dev $CONTAINER_IMAGE:latest
+        - docker tag $CONTAINER_IMAGE:latest $IMAGE_NAME
+        - docker push $IMAGE_NAME
+        - docker push $CONTAINER_IMAGE:latest
+    only:
+        - tags

data/statsd/.gitignore

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

docker-compose.base.yml

@@ -11,3 +11,10 @@ services:
             RABBITMQ_DEFAULT_USER: "ely-skinsystem-app"
             RABBITMQ_DEFAULT_PASS: "ely-skinsystem-app-password"
             RABBITMQ_DEFAULT_VHOST: "/ely"
+
+    statsd:
+        image: hopsoft/graphite-statsd
+        volumes:
+            - ./data/statsd:/opt/graphite/storage
+            - ./data/graphite-config:/opt/graphite/conf
+            - ./data/statsd-config/config.json:/opt/statsd/config.js

docker-compose.dev.yml

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

docker-compose.prod.yml

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

lib/data/SignedTexturesResponse.go

@@ -0,0 +1,14 @@
+package data
+
+type SignedTexturesResponse struct {
+	Id    string     `json:"id"`
+	Name  string     `json:"name"`
+	IsEly bool       `json:"ely,omitempty"`
+	Props []Property `json:"properties"`
+}
+
+type Property struct {
+	Name string      `json:"name"`
+	Signature string `json:"signature,omitempty"`
+	Value string     `json:"value"`
+}

lib/data/SkinItem.go

@@ -13,12 +13,15 @@ import (
 
 type SkinItem struct {
 	UserId          int    `json:"userId"`
+	Uuid            string `json:"uuid"`
 	Username        string `json:"username"`
 	SkinId          int    `json:"skinId"`
 	Url             string `json:"url"`
 	Is1_8           bool   `json:"is1_8"`
 	IsSlim          bool   `json:"isSlim"`
 	Hash            string `json:"hash"`
+	MojangTextures  string `json:"mojangTextures"`
+	MojangSignature string `json:"mojangSignature"`
 	oldUsername     string
 }
 
@@ -62,13 +65,16 @@ func (s *SkinItem) Delete() {
 
 func FindSkinByUsername(username string) (SkinItem, error) {
 	var record SkinItem;
+	services.Logger.IncCounter("storage.query", 1)
 	response := services.RedisPool.Cmd("GET", tools.BuildKey(username));
 	if (response.IsType(redis.Nil)) {
+		services.Logger.IncCounter("storage.not_found", 1)
 		return record, SkinNotFound{username}
 	}
 
 	result, err := response.Str()
 	if (err == nil) {
+		services.Logger.IncCounter("storage.found", 1)
 		decodeErr := json.Unmarshal([]byte(result), &record)
 		if (decodeErr != nil) {
 			log.Println("Cannot decode record data")

lib/external/accounts/AccountInfo.go

@@ -0,0 +1,44 @@
+package accounts
+
+import (
+	"net/http"
+	"io/ioutil"
+	"encoding/json"
+)
+
+type AccountInfoResponse struct {
+	Id       int    `json:"id"`
+	Uuid     string `json:"uuid"`
+	Username string `json:"username"`
+	Email    string `json:"email"`
+}
+
+const internalAccountInfoUrl = domain + "/api/internal/accounts/info"
+
+func (token *Token) AccountInfo(attribute string, value string) (AccountInfoResponse, error) {
+	request, err := http.NewRequest("GET", internalAccountInfoUrl, nil)
+	request.Header.Add("Authorization", "Bearer " + token.AccessToken)
+	query := request.URL.Query()
+	query.Add(attribute, value)
+	request.URL.RawQuery = query.Encode()
+
+	response, err := Client.Do(request)
+	if err != nil {
+		panic(err)
+	}
+
+	defer response.Body.Close()
+
+	var info AccountInfoResponse
+
+	responseError := handleResponse(response)
+	if responseError != nil {
+		return info, responseError
+	}
+
+	body, _ := ioutil.ReadAll(response.Body)
+	println("Raw account info response is " + string(body))
+	json.Unmarshal(body, &info)
+
+	return info, nil
+}

lib/external/accounts/GetToken.go

@@ -0,0 +1,49 @@
+package accounts
+
+import (
+	"strings"
+	"net/url"
+	"io/ioutil"
+	"encoding/json"
+)
+
+type TokenRequest struct {
+	Id     string
+	Secret string
+	Scopes []string
+}
+
+type Token struct {
+	AccessToken string `json:"access_token"`
+	TokenType   string `json:"token_type"`
+	ExpiresIn   int    `json:"expires_in"`
+}
+
+const tokenUrl = domain + "/api/oauth2/v1/token"
+
+func GetToken(request TokenRequest) (Token, error) {
+	form := url.Values{}
+	form.Add("client_id", request.Id)
+	form.Add("client_secret", request.Secret)
+	form.Add("grant_type", "client_credentials")
+	form.Add("scope", strings.Join(request.Scopes, ","))
+
+	response, err := Client.Post(tokenUrl, "application/x-www-form-urlencoded", strings.NewReader(form.Encode()))
+	if err != nil {
+		panic(err)
+	}
+
+	defer response.Body.Close()
+
+	var result Token
+	responseError := handleResponse(response)
+	if responseError != nil {
+		return result, responseError
+	}
+
+	body, _ := ioutil.ReadAll(response.Body)
+
+	json.Unmarshal(body, &result)
+
+	return result, nil
+}

lib/external/accounts/base.go

@@ -0,0 +1,51 @@
+package accounts
+
+import (
+	"fmt"
+	"net/http"
+)
+
+const domain = "https://dev.account.ely.by"
+
+var Client = &http.Client{}
+
+type UnauthorizedResponse struct {}
+
+func (err UnauthorizedResponse) Error() string {
+	return "Unauthorized response"
+}
+
+type ForbiddenResponse struct {}
+
+func (err ForbiddenResponse) Error() string {
+	return "Forbidden response"
+}
+
+type NotFoundResponse struct {}
+
+func (err NotFoundResponse) Error() string {
+	return "Not found"
+}
+
+type NotSuccessResponse struct {
+	StatusCode int
+}
+
+func (err NotSuccessResponse) Error() string {
+	return fmt.Sprintf("Response code is \"%d\"", err.StatusCode)
+}
+
+func handleResponse(response *http.Response) error {
+	switch status := response.StatusCode; status {
+	case 200:
+		return nil
+	case 401:
+		return &UnauthorizedResponse{}
+	case 403:
+		return &ForbiddenResponse{}
+	case 404:
+		return &NotFoundResponse{}
+	default:
+		return &NotSuccessResponse{status}
+	}
+}

lib/routes/Cape.go

@@ -2,18 +2,21 @@ package routes
 
 import (
 	"io"
-	"log"
 	"net/http"
 
 	"github.com/gorilla/mux"
 
 	"elyby/minecraft-skinsystem/lib/tools"
 	"elyby/minecraft-skinsystem/lib/data"
+	"elyby/minecraft-skinsystem/lib/services"
 )
 
 func Cape(response http.ResponseWriter, request *http.Request) {
+	if (mux.Vars(request)["converted"] == "") {
+		services.Logger.IncCounter("capes.request", 1)
+	}
+
 	username := tools.ParseUsername(mux.Vars(request)["username"])
-	log.Println("request cape for username " + username)
 	rec, err := data.FindCapeByUsername(username)
 	if (err != nil) {
 		http.Redirect(response, request, "http://skins.minecraft.net/MinecraftCloaks/" + username + ".png", 301)
@@ -24,6 +27,7 @@ func Cape(response http.ResponseWriter, request *http.Request) {
 }
 
 func CapeGET(w http.ResponseWriter, r *http.Request) {
+	services.Logger.IncCounter("capes.get_request", 1)
 	username := r.URL.Query().Get("name")
 	if username == "" {
 		w.WriteHeader(http.StatusBadRequest)
@@ -31,5 +35,6 @@ func CapeGET(w http.ResponseWriter, r *http.Request) {
 	}
 
 	mux.Vars(r)["username"] = username
+	mux.Vars(r)["converted"] = "1"
 	Cape(w, r)
 }

lib/routes/Face.go

@@ -1,7 +1,6 @@
 package routes
 
 import (
-	"log"
 	"net/http"
 
 	"github.com/gorilla/mux"
@@ -14,7 +13,6 @@ const defaultHash = "default"
 
 func Face(w http.ResponseWriter, r *http.Request) {
 	username := tools.ParseUsername(mux.Vars(r)["username"])
-	log.Println("request skin for username " + username);
 	rec, err := data.FindSkinByUsername(username)
 	var hash string
 	if (err != nil || rec.SkinId == 0) {

lib/routes/MinecraftPHP.go

@@ -4,6 +4,8 @@ import (
 	"net/http"
 
 	"github.com/gorilla/mux"
+
+	"elyby/minecraft-skinsystem/lib/services"
 )
 
 // Метод-наследие от первой версии системы скинов.
@@ -18,11 +20,15 @@ func MinecraftPHP(w http.ResponseWriter, r *http.Request) {
 	}
 
 	mux.Vars(r)["username"] = username
+	mux.Vars(r)["converted"] = "1"
 	switch required {
-	case "skin": Skin(w, r)
+	case "skin":
-	case "cloack": Cape(w, r)
+		services.Logger.IncCounter("skins.minecraft-php-request", 1)
-	default: {
+		Skin(w, r)
+	case "cloack":
+		services.Logger.IncCounter("capes.minecraft-php-request", 1)
+		Cape(w, r)
+	default:
 		w.WriteHeader(http.StatusNotFound)
 	}
 }
-}

lib/routes/SetSkin.go

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

lib/routes/SignedTextures.go

@@ -0,0 +1,44 @@
+package routes
+
+import (
+	"strings"
+	"net/http"
+	"encoding/json"
+
+	"github.com/gorilla/mux"
+
+	"elyby/minecraft-skinsystem/lib/data"
+	"elyby/minecraft-skinsystem/lib/tools"
+	"elyby/minecraft-skinsystem/lib/services"
+)
+
+func SignedTextures(w http.ResponseWriter, r *http.Request) {
+	services.Logger.IncCounter("signed_textures.request", 1)
+	username := tools.ParseUsername(mux.Vars(r)["username"])
+
+	rec, err := data.FindSkinByUsername(username)
+	if (err != nil || rec.SkinId == 0 || rec.MojangTextures == "") {
+		w.WriteHeader(http.StatusNoContent)
+		return
+	}
+
+	responseData:= data.SignedTexturesResponse{
+		Id: strings.Replace(rec.Uuid, "-", "", -1),
+		Name: rec.Username,
+		Props: []data.Property{
+			{
+				Name: "textures",
+				Signature: rec.MojangSignature,
+				Value: rec.MojangTextures,
+			},
+			{
+				Name: "ely",
+				Value: "but why are you asking?",
+			},
+		},
+	}
+
+	response,_ := json.Marshal(responseData)
+	w.Header().Set("Content-Type", "application/json")
+	w.Write(response)
+}

lib/routes/Skin.go

@@ -1,18 +1,21 @@
 package routes
 
 import (
-	"log"
 	"net/http"
 
 	"github.com/gorilla/mux"
 
 	"elyby/minecraft-skinsystem/lib/tools"
 	"elyby/minecraft-skinsystem/lib/data"
+	"elyby/minecraft-skinsystem/lib/services"
 )
 
 func Skin(w http.ResponseWriter, r *http.Request) {
+	if (mux.Vars(r)["converted"] == "") {
+		services.Logger.IncCounter("skins.request", 1)
+	}
+
 	username := tools.ParseUsername(mux.Vars(r)["username"])
-	log.Println("request skin for username " + username);
 	rec, err := data.FindSkinByUsername(username)
 	if (err != nil) {
 		http.Redirect(w, r, "http://skins.minecraft.net/MinecraftSkins/" + username + ".png", 301)
@@ -23,6 +26,7 @@ func Skin(w http.ResponseWriter, r *http.Request) {
 }
 
 func SkinGET(w http.ResponseWriter, r *http.Request) {
+	services.Logger.IncCounter("skins.get_request", 1)
 	username := r.URL.Query().Get("name")
 	if username == "" {
 		w.WriteHeader(http.StatusBadRequest)
@@ -30,5 +34,6 @@ func SkinGET(w http.ResponseWriter, r *http.Request) {
 	}
 
 	mux.Vars(r)["username"] = username
+	mux.Vars(r)["converted"] = "1"
 	Skin(w, r)
 }

lib/routes/Textures.go

@@ -13,8 +13,8 @@ import (
 )
 
 func Textures(w http.ResponseWriter, r *http.Request) {
+	services.Logger.IncCounter("textures.request", 1)
 	username := tools.ParseUsername(mux.Vars(r)["username"])
-	log.Println("request textures for username " + username)
 
 	rec, err := data.FindSkinByUsername(username)
 	if (err != nil || rec.SkinId == 0) {

lib/services/services.go

@@ -4,6 +4,7 @@ import (
 	"github.com/mediocregopher/radix.v2/pool"
 	"github.com/streadway/amqp"
 	"github.com/gorilla/mux"
+	"github.com/mono83/slf/wd"
 )
 
 var Router *mux.Router
@@ -13,3 +14,5 @@ var RedisPool *pool.Pool
 var RabbitMQChannel *amqp.Channel
 
 var RootFolder string
+
+var Logger wd.Watchdog

lib/tools/tools.go

@@ -30,7 +30,12 @@ func BuildKey(username string) string {
 }
 
 func BuildElyUrl(route string) string {
-	return "http://ely.by" + route
+	prefix := "http://ely.by"
+	if !strings.HasPrefix(route, prefix) {
+		route = prefix + route
+	}
+
+	return route
 }
 
 func getCurrentHour() int64 {

lib/tools/tools_test.go

@@ -20,3 +20,13 @@ func TestBuildKey(t *testing.T) {
 		t.Error("Function shound convert string to lower case and concatenate it with usernmae:")
 	}
 }
+
+func TestBuildElyUrl(t *testing.T) {
+	if BuildElyUrl("/route") != "http://ely.by/route" {
+		t.Error("Function should add prefix to the provided relative url.")
+	}
+
+	if BuildElyUrl("http://ely.by/test/route") != "http://ely.by/test/route" {
+		t.Error("Function should do not add prefix to the provided prefixed url.")
+	}
+}

lib/worker/handlers.go

@@ -1,12 +1,14 @@
 package worker
 
 import (
+	"fmt"
 	"elyby/minecraft-skinsystem/lib/data"
-	"log"
+	"elyby/minecraft-skinsystem/lib/services"
 )
 
 func handleChangeUsername(model usernameChanged) (bool) {
 	if (model.OldUsername == "") {
+		services.Logger.IncCounter("worker.change_username.empty_old_username", 1)
 		record := data.SkinItem{
 			UserId: model.AccountId,
 			Username: model.NewUsername,
@@ -17,36 +19,64 @@ func handleChangeUsername(model usernameChanged) (bool) {
 		return true
 	}
 
-	record, err := data.FindSkinByUsername(model.OldUsername)
+	record, err := data.FindSkinById(model.AccountId)
 	if (err != nil) {
-		log.Println("Exit by not found record")
+		services.Logger.IncCounter("worker.change_username.id_not_found", 1)
-		// TODO: я не уверен, что это валидное поведение
+		fmt.Println("Cannot find user id. Trying to search.")
-		// Суть в том, что здесь может возникнуть ошибка в том случае, если записи в базе нету
+		response, err := getById(model.AccountId)
-		// а значит его нужно, как минимум, зарегистрировать
+		if err != nil {
+			services.Logger.IncCounter("worker.change_username.id_not_restored", 1)
+			fmt.Printf("Cannot restore user info. %T\n", err)
+			// TODO: логгировать в какой-нибудь Sentry, если там не 404
 			return true
 		}
 
+		services.Logger.IncCounter("worker.change_username.id_restored", 1)
+		fmt.Println("User info successfully restored.")
+		record = data.SkinItem{
+			UserId: response.Id,
+		}
+	}
+
 	record.Username = model.NewUsername
 	record.Save()
 
-	log.Println("all saved!")
+	services.Logger.IncCounter("worker.change_username.processed", 1)
 
 	return true
 }
 
-func handleSkinChanged(model skinChanged) (bool) {
+func handleSkinChanged(model skinChanged) bool {
 	record, err := data.FindSkinById(model.AccountId)
-	if (err != nil) {
+	if err != nil {
+		services.Logger.IncCounter("worker.skin_changed.id_not_found", 1)
+		fmt.Println("Cannot find user id. Trying to search.")
+		response, err := getById(model.AccountId)
+		if err != nil {
+			services.Logger.IncCounter("worker.skin_changed.id_not_restored", 1)
+			fmt.Printf("Cannot restore user info. %T\n", err)
+			// TODO: логгировать в какой-нибудь Sentry, если там не 404
 			return true
 		}
 
+		services.Logger.IncCounter("worker.skin_changed.id_restored", 1)
+		fmt.Println("User info successfully restored.")
+		record.UserId = response.Id
+		record.Username = response.Username
+	}
+
+	record.Uuid = model.Uuid
 	record.SkinId = model.SkinId
 	record.Hash = model.Hash
 	record.Is1_8 = model.Is1_8
 	record.IsSlim = model.IsSlim
 	record.Url = model.Url
+	record.MojangTextures = model.MojangTextures
+	record.MojangSignature = model.MojangSignature
 
 	record.Save()
 
+	services.Logger.IncCounter("worker.skin_changed.processed", 1)
+
 	return true
 }

lib/worker/models.go

@@ -8,10 +8,13 @@ type usernameChanged struct {
 
 type skinChanged struct {
 	AccountId       int    `json:"userId"`
+	Uuid            string `json:"uuid"`
 	SkinId          int    `json:"skinId"`
 	OldSkinId       int    `json:"oldSkinId"`
 	Hash            string `json:"hash"`
 	Is1_8           bool   `json:"is1_8"`
 	IsSlim          bool   `json:"isSlim"`
 	Url             string `json:"url"`
+	MojangTextures  string `json:"mojangTextures"`
+	MojangSignature string `json:"mojangSignature"`
 }

lib/worker/supports.go

@@ -0,0 +1,58 @@
+package worker
+
+import (
+	"strconv"
+	"elyby/minecraft-skinsystem/lib/external/accounts"
+)
+
+var AccountsTokenConfig *accounts.TokenRequest
+
+var token *accounts.Token
+
+const repeatsLimit = 3
+var repeatsCount = 0
+
+func getById(id int) (accounts.AccountInfoResponse, error) {
+	return _getByField("id", strconv.Itoa(id))
+}
+
+func _getByField(field string, value string) (accounts.AccountInfoResponse, error) {
+	defer resetRepeatsCount()
+
+	apiToken, err := getToken()
+	if err != nil {
+		return accounts.AccountInfoResponse{}, err
+	}
+
+	result, err := apiToken.AccountInfo(field, value)
+	if err != nil {
+		_, ok := err.(*accounts.UnauthorizedResponse)
+		if !ok || repeatsCount >= repeatsLimit {
+			return accounts.AccountInfoResponse{}, err
+		}
+
+		repeatsCount++
+		token = nil
+
+		return _getByField(field, value)
+	}
+
+	return result, nil
+}
+
+func getToken() (*accounts.Token, error) {
+	if token == nil {
+		tempToken, err := accounts.GetToken(*AccountsTokenConfig)
+		if err != nil {
+			return &accounts.Token{}, err
+		}
+
+		token = &tempToken
+	}
+
+	return token, nil
+}
+
+func resetRepeatsCount() {
+	repeatsCount = 0
+}

minecraft-skinsystem.go

@@ -11,10 +11,15 @@ import (
 	"github.com/gorilla/mux"
 	"github.com/streadway/amqp"
 	"github.com/mediocregopher/radix.v2/pool"
+	"github.com/mono83/slf/wd"
+	"github.com/mono83/slf/rays"
+	"github.com/mono83/slf/recievers/ansi"
+	"github.com/mono83/slf/recievers/statsd"
 
 	"elyby/minecraft-skinsystem/lib/routes"
 	"elyby/minecraft-skinsystem/lib/services"
 	"elyby/minecraft-skinsystem/lib/worker"
+	"elyby/minecraft-skinsystem/lib/external/accounts"
 )
 
 const redisPoolSize int = 10
@@ -24,6 +29,20 @@ func main() {
 
 	runtime.GOMAXPROCS(runtime.NumCPU())
 
+	accountsApiId := os.Getenv("ACCOUNTS_API_ID")
+	accountsApiSecret := os.Getenv("ACCOUNTS_API_SECRET")
+	if accountsApiId == "" || accountsApiSecret == "" {
+		log.Fatal("ACCOUNTS_API params must be provided")
+	}
+
+	worker.AccountsTokenConfig = &accounts.TokenRequest{
+		Id: accountsApiId,
+		Secret: accountsApiSecret,
+		Scopes: []string{
+			"internal_account_info",
+		},
+	}
+
 	log.Println("Connecting to redis")
 
 	var redisString = os.Getenv("REDIS_ADDR")
@@ -56,10 +75,32 @@ func main() {
 	}
 	log.Println("Connected to rabbitmq channel")
 
+	// statsd
+	var statsdString = os.Getenv("STATSD_ADDR")
+	if (statsdString != "") {
+		log.Println("Connecting to statsd")
+		hostname, _ := os.Hostname()
+		statsdReceiver, err := statsd.NewReceiver(statsd.Config{
+			Address: statsdString,
+			Prefix: "ely.skinsystem." + hostname + ".app.",
+			FlushEvery: 1,
+		})
+		if (err != nil) {
+			log.Fatal("statsd connection error")
+		}
+
+		wd.AddReceiver(statsdReceiver)
+	} else {
+		wd.AddReceiver(ansi.New(true, true, false))
+	}
+
+	logger := wd.New("", "").WithParams(rays.Host)
+
 	router := mux.NewRouter().StrictSlash(true)
 	router.HandleFunc("/skins/{username}", routes.Skin).Methods("GET").Name("skins")
 	router.HandleFunc("/cloaks/{username}", routes.Cape).Methods("GET").Name("cloaks")
 	router.HandleFunc("/textures/{username}", routes.Textures).Methods("GET").Name("textures")
+	router.HandleFunc("/textures/signed/{username}", routes.SignedTextures).Methods("GET").Name("signedTextures")
 	router.HandleFunc("/skins/{username}/face", routes.Face).Methods("GET").Name("faces")
 	router.HandleFunc("/skins/{username}/face.png", routes.Face).Methods("GET").Name("faces")
 	// Legacy
@@ -69,12 +110,10 @@ func main() {
 	// 404
 	router.NotFoundHandler = http.HandlerFunc(routes.NotFound)
 
-	apiRouter := router.PathPrefix("/api").Subrouter()
-	apiRouter.HandleFunc("/user/{username}/skin", routes.SetSkin).Methods("POST")
-
 	services.Router = router
 	services.RedisPool = redisPool
 	services.RabbitMQChannel = rabbitChannel
+	services.Logger = logger
 
 	_, file, _, _ := runtime.Caller(0)
 	services.RootFolder = filepath.Dir(file)