Pass auth token through headers instead of query param.

clems4ever · clems4ever · commit bd401a0d5e08 · 2021-01-28T00:45:57.000+01:00
Also make the retry behavior customizable by clients.
diff --git a/internal/client/graph_api.go b/internal/client/graph_api.go
@@ -1,15 +1,16 @@
 package client
 
 import (
+	"time"
+
 	"github.com/clems4ever/go-graphkb/internal/knowledge"
 )
 
 // GraphAPI represent the graph API from a data source point of view
 type GraphAPI struct {
 	client *GraphClient
 
-	parallelization int
-	chunkSize       int
+	options GraphAPIOptions
 }
 
 // GraphAPIOptions options to pass to build graph API
@@ -26,37 +27,63 @@ type GraphAPIOptions struct {
 
 	// The size of a chunk of updates, i.e., number of assets or relations sent in one HTTP request to the streaming API.
 	ChunkSize int
+
+	// Max number of retries before giving up (default is 10)
+	MaxRetries int
+	// The base delay between retries (default is 5 seconds). This delay is multiplied by the backoff factor.
+	RetryDelay time.Duration
+
+	// The backoff factor (default is 1.01)
+	RetryBackoffFactor float64
 }
 
 // NewGraphAPI create an emitter of graph
 func NewGraphAPI(options GraphAPIOptions) *GraphAPI {
 	return &GraphAPI{
-		client:          NewGraphClient(options.URL, options.AuthToken, options.SkipVerify),
-		parallelization: options.Parallelization,
-		chunkSize:       options.ChunkSize,
+		client:  NewGraphClient(options.URL, options.AuthToken, options.SkipVerify),
+		options: options,
 	}
 }
 
 // CreateTransaction create a full graph transaction. This kind of transaction will diff the new graph
 // with previous version of it.
 func (gapi *GraphAPI) CreateTransaction(currentGraph *knowledge.Graph) *Transaction {
-	var parallelization = gapi.parallelization
+	var parallelization = gapi.options.Parallelization
 	if parallelization == 0 {
 		parallelization = 30
 	}
 
-	var chunkSize = gapi.chunkSize
+	var chunkSize = gapi.options.ChunkSize
 	if chunkSize == 0 {
 		chunkSize = 1000
 	}
 
+	var maxRetries = gapi.options.MaxRetries
+	if maxRetries == 0 {
+		maxRetries = 10
+	}
+
+	var retryDelay = gapi.options.RetryDelay
+	if retryDelay == 0 {
+		retryDelay = 5 * time.Second
+	}
+
+	var retryBackoff = gapi.options.RetryBackoffFactor
+	if retryBackoff == 0.0 {
+		retryBackoff = 1.01
+	}
+
 	transaction := new(Transaction)
 	transaction.newGraph = knowledge.NewGraph()
 	transaction.binder = knowledge.NewGraphBinder(transaction.newGraph)
 	transaction.client = gapi.client
 	transaction.currentGraph = currentGraph
 	transaction.parallelization = parallelization
 	transaction.chunkSize = chunkSize
+
+	transaction.retryCount = maxRetries
+	transaction.retryDelay = retryDelay
+	transaction.retryBackoffFactor = retryBackoff
 	return transaction
 }
 
diff --git a/internal/client/graph_client.go b/internal/client/graph_client.go
@@ -5,11 +5,13 @@ import (
 	"crypto/tls"
 	"encoding/json"
 	"fmt"
+	"io"
 	"io/ioutil"
 	"net/http"
 
 	"github.com/clems4ever/go-graphkb/internal/knowledge"
 	"github.com/clems4ever/go-graphkb/internal/schema"
+	"github.com/clems4ever/go-graphkb/internal/utils"
 )
 
 // ErrTooManyRequests error representing too many requests to the API
@@ -37,11 +39,18 @@ func NewGraphClient(URL, authToken string, skipVerify bool) *GraphClient {
 	}
 }
 
+func (gc *GraphClient) newRequest(method, path string, body io.Reader) (*http.Request, error) {
+	req, err := http.NewRequest(method, fmt.Sprintf("%s%s", gc.url, path), body)
+	if err != nil {
+		return nil, err
+	}
+	req.Header.Add(utils.XAuthTokenHeader, gc.authToken)
+	return req, nil
+}
+
 // ReadCurrentGraph read the current graph stored in graph kb
 func (gc *GraphClient) ReadCurrentGraph() (*knowledge.Graph, error) {
-	url := fmt.Sprintf("%s/api/graph/read?token=%s", gc.url, gc.authToken)
-
-	req, err := http.NewRequest("GET", url, nil)
+	req, err := gc.newRequest("GET", "/api/graph/read", nil)
 	if err != nil {
 		return nil, err
 	}
@@ -81,8 +90,7 @@ func (gc *GraphClient) UpdateSchema(sg schema.SchemaGraph) error {
 		return fmt.Errorf("Unable to marshall request body")
 	}
 
-	url := fmt.Sprintf("%s/api/graph/schema?token=%s", gc.url, gc.authToken)
-	req, err := http.NewRequest("PUT", url, bytes.NewBuffer(b))
+	req, err := gc.newRequest("PUT", "/api/graph/schema", bytes.NewBuffer(b))
 	if err != nil {
 		return err
 	}
@@ -113,8 +121,7 @@ func (gc *GraphClient) InsertAssets(assets []knowledge.Asset) error {
 		return fmt.Errorf("Unable to marshall request body")
 	}
 
-	url := fmt.Sprintf("%s/api/graph/asset?token=%s", gc.url, gc.authToken)
-	req, err := http.NewRequest("PUT", url, bytes.NewBuffer(b))
+	req, err := gc.newRequest("PUT", "/api/graph/assets", bytes.NewBuffer(b))
 	if err != nil {
 		return err
 	}
@@ -145,8 +152,7 @@ func (gc *GraphClient) DeleteAssets(assets []knowledge.Asset) error {
 		return fmt.Errorf("Unable to marshall request body")
 	}
 
-	url := fmt.Sprintf("%s/api/graph/asset?token=%s", gc.url, gc.authToken)
-	req, err := http.NewRequest("DELETE", url, bytes.NewBuffer(b))
+	req, err := gc.newRequest("DELETE", "/api/graph/assets", bytes.NewBuffer(b))
 	if err != nil {
 		return err
 	}
@@ -177,8 +183,7 @@ func (gc *GraphClient) InsertRelations(relations []knowledge.Relation) error {
 		return fmt.Errorf("Unable to marshall request body")
 	}
 
-	url := fmt.Sprintf("%s/api/graph/relation?token=%s", gc.url, gc.authToken)
-	req, err := http.NewRequest("PUT", url, bytes.NewBuffer(b))
+	req, err := gc.newRequest("PUT", "/api/graph/relations", bytes.NewBuffer(b))
 	if err != nil {
 		return err
 	}
@@ -209,8 +214,7 @@ func (gc *GraphClient) DeleteRelations(relations []knowledge.Relation) error {
 		return fmt.Errorf("Unable to marshall request body")
 	}
 
-	url := fmt.Sprintf("%s/api/graph/relation?token=%s", gc.url, gc.authToken)
-	req, err := http.NewRequest("DELETE", url, bytes.NewBuffer(b))
+	req, err := gc.newRequest("DELETE", "/api/graph/relations", bytes.NewBuffer(b))
 	if err != nil {
 		return err
 	}
diff --git a/internal/client/transaction.go b/internal/client/transaction.go
@@ -32,6 +32,10 @@ type Transaction struct {
 
 	// The number of items to send to the streaming API in one request
 	chunkSize int
+
+	retryCount         int
+	retryDelay         time.Duration
+	retryBackoffFactor float64
 }
 
 // Relate create a relation between two assets
@@ -49,12 +53,12 @@ func (cgt *Transaction) Bind(asset string, assetType schema.AssetType) {
 }
 
 // withRetryOnTooManyRequests helper retrying the function when too many request error has been received
-func withRetryOnTooManyRequests(fn func() error, maxRetries int) error {
+func withRetryOnTooManyRequests(fn func() error, backoffFactor float64, maxRetries int, delay time.Duration) error {
 	trials := 0
 	for {
 		err := fn()
 		if err != nil {
-			backoffTime := time.Duration(int(math.Pow(1.01, float64(trials)))*15) * time.Second
+			backoffTime := time.Duration(int(math.Pow(backoffFactor, float64(trials)))) * delay
 			fmt.Printf("Sleeping for %d seconds\n", backoffTime/time.Second)
 			time.Sleep(backoffTime)
 		} else {
@@ -104,7 +108,7 @@ func (cgt *Transaction) Commit() (*knowledge.Graph, error) {
 			relations = append(relations, r.(knowledge.Relation))
 		}
 		f := p.Exec(func() error {
-			if err := withRetryOnTooManyRequests(func() error { return cgt.client.DeleteRelations(relations) }, 10); err != nil {
+			if err := withRetryOnTooManyRequests(func() error { return cgt.client.DeleteRelations(relations) }, cgt.retryBackoffFactor, cgt.retryCount, cgt.retryDelay); err != nil {
 				return fmt.Errorf("Unable to remove the relations %v: %v", relations, err)
 			}
 			progress.Add(len(relations))
@@ -119,7 +123,7 @@ func (cgt *Transaction) Commit() (*knowledge.Graph, error) {
 			assets = append(assets, a.(knowledge.Asset))
 		}
 		f := p.Exec(func() error {
-			if err := withRetryOnTooManyRequests(func() error { return cgt.client.InsertAssets(assets) }, 10); err != nil {
+			if err := withRetryOnTooManyRequests(func() error { return cgt.client.InsertAssets(assets) }, cgt.retryBackoffFactor, cgt.retryCount, cgt.retryDelay); err != nil {
 				return fmt.Errorf("Unable to upsert the asset %v: %v", assets, err)
 			}
 			progress.Add(len(assets))
@@ -144,7 +148,7 @@ func (cgt *Transaction) Commit() (*knowledge.Graph, error) {
 			assets = append(assets, a.(knowledge.Asset))
 		}
 		f := p.Exec(func() error {
-			if err := withRetryOnTooManyRequests(func() error { return cgt.client.DeleteAssets(assets) }, 10); err != nil {
+			if err := withRetryOnTooManyRequests(func() error { return cgt.client.DeleteAssets(assets) }, cgt.retryBackoffFactor, cgt.retryCount, cgt.retryDelay); err != nil {
 				return fmt.Errorf("Unable to remove the asset %v: %v", assets, err)
 			}
 			progress.Add(len(assets))
@@ -159,7 +163,7 @@ func (cgt *Transaction) Commit() (*knowledge.Graph, error) {
 			relations = append(relations, r.(knowledge.Relation))
 		}
 		f := p.Exec(func() error {
-			if err := withRetryOnTooManyRequests(func() error { return cgt.client.InsertRelations(relations) }, 10); err != nil {
+			if err := withRetryOnTooManyRequests(func() error { return cgt.client.InsertRelations(relations) }, cgt.retryBackoffFactor, cgt.retryCount, cgt.retryDelay); err != nil {
 				return fmt.Errorf("Unable to upsert the relation %v: %v", relations, err)
 			}
 			progress.Add(len(relations))
diff --git a/internal/handlers/token.go b/internal/handlers/token.go
@@ -5,24 +5,25 @@ import (
 	"net/http"
 
 	"github.com/clems4ever/go-graphkb/internal/sources"
+	"github.com/clems4ever/go-graphkb/internal/utils"
 )
 
 // IsTokenValid is the token valid
 func IsTokenValid(registry sources.Registry, r *http.Request) (bool, string, error) {
-	token, ok := r.URL.Query()["token"]
+	token := r.Header.Get(utils.XAuthTokenHeader)
 
-	if !ok || len(token) != 1 {
-		return false, "", fmt.Errorf("Unable to detect token query parameter")
+	if token == "" {
+		return false, "", fmt.Errorf("No auth token provided")
 	}
 
 	sourceToToken, err := registry.ListSources(r.Context())
 
 	if err != nil {
-		return false, "", err
+		return false, "", fmt.Errorf("Unable to list the sources: %v", err)
 	}
 
 	for sn, t := range sourceToToken {
-		if t == token[0] {
+		if t == token {
 			return true, sn, nil
 		}
 	}
diff --git a/internal/server/server.go b/internal/server/server.go
@@ -320,10 +320,10 @@ func StartServer(listenInterface string,
 	sem := semaphore.NewWeighted(concurrency)
 
 	r.HandleFunc("/api/graph/schema", handlers.PutSchema(sourcesRegistry, graphUpdater, sem)).Methods("PUT")
-	r.HandleFunc("/api/graph/asset", handlers.PutAsset(sourcesRegistry, graphUpdater, sem)).Methods("PUT")
-	r.HandleFunc("/api/graph/relation", handlers.PutRelation(sourcesRegistry, graphUpdater, sem)).Methods("PUT")
-	r.HandleFunc("/api/graph/asset", handlers.DeleteAsset(sourcesRegistry, graphUpdater, sem)).Methods("DELETE")
-	r.HandleFunc("/api/graph/relation", handlers.DeleteRelation(sourcesRegistry, graphUpdater, sem)).Methods("DELETE")
+	r.HandleFunc("/api/graph/assets", handlers.PutAsset(sourcesRegistry, graphUpdater, sem)).Methods("PUT")
+	r.HandleFunc("/api/graph/assets", handlers.DeleteAsset(sourcesRegistry, graphUpdater, sem)).Methods("DELETE")
+	r.HandleFunc("/api/graph/relations", handlers.PutRelation(sourcesRegistry, graphUpdater, sem)).Methods("PUT")
+	r.HandleFunc("/api/graph/relations", handlers.DeleteRelation(sourcesRegistry, graphUpdater, sem)).Methods("DELETE")
 
 	r.HandleFunc("/api/query", postQueryHandler).Methods("POST")
 	r.PathPrefix("/").Handler(http.FileServer(http.Dir("./web/build/")))
diff --git a/internal/utils/constant.go b/internal/utils/constant.go
@@ -0,0 +1,6 @@
+package utils
+
+var (
+	// XAuthTokenHeader is the name of the header supposed to contain the auth token
+	XAuthTokenHeader = "X-Auth-Token"
+)

Original file line number	Diff line number	Diff line change
`@@ -5,11 +5,13 @@ import (`
`5`	`5`	`"crypto/tls"`
`6`	`6`	`"encoding/json"`
`7`	`7`	`"fmt"`
	`8`	`+ "io"`
`8`	`9`	`"io/ioutil"`
`9`	`10`	`"net/http"`
`10`	`11`
`11`	`12`	`"github.com/clems4ever/go-graphkb/internal/knowledge"`
`12`	`13`	`"github.com/clems4ever/go-graphkb/internal/schema"`
	`14`	`+ "github.com/clems4ever/go-graphkb/internal/utils"`
`13`	`15`	`)`
`14`	`16`
`15`	`17`	`// ErrTooManyRequests error representing too many requests to the API`
`@@ -37,11 +39,18 @@ func NewGraphClient(URL, authToken string, skipVerify bool) *GraphClient {`
`37`	`39`	`}`
`38`	`40`	`}`
`39`	`41`
	`42`	`+func (gc GraphClient) newRequest(method, path string, body io.Reader) (http.Request, error) {`
	`43`	`+ req, err := http.NewRequest(method, fmt.Sprintf("%s%s", gc.url, path), body)`
	`44`	`+ if err != nil {`
	`45`	`+ return nil, err`
	`46`	`+ }`
	`47`	`+ req.Header.Add(utils.XAuthTokenHeader, gc.authToken)`
	`48`	`+ return req, nil`
	`49`	`+}`
	`50`	`+`
`40`	`51`	`// ReadCurrentGraph read the current graph stored in graph kb`
`41`	`52`	`func (gc GraphClient) ReadCurrentGraph() (knowledge.Graph, error) {`
`42`		`- url := fmt.Sprintf("%s/api/graph/read?token=%s", gc.url, gc.authToken)`
`43`		`-`
`44`		`- req, err := http.NewRequest("GET", url, nil)`
	`53`	`+ req, err := gc.newRequest("GET", "/api/graph/read", nil)`
`45`	`54`	`if err != nil {`
`46`	`55`	`return nil, err`
`47`	`56`	`}`
`@@ -81,8 +90,7 @@ func (gc *GraphClient) UpdateSchema(sg schema.SchemaGraph) error {`
`81`	`90`	`return fmt.Errorf("Unable to marshall request body")`
`82`	`91`	`}`
`83`	`92`
`84`		`- url := fmt.Sprintf("%s/api/graph/schema?token=%s", gc.url, gc.authToken)`
`85`		`- req, err := http.NewRequest("PUT", url, bytes.NewBuffer(b))`
	`93`	`+ req, err := gc.newRequest("PUT", "/api/graph/schema", bytes.NewBuffer(b))`
`86`	`94`	`if err != nil {`
`87`	`95`	`return err`
`88`	`96`	`}`
`@@ -113,8 +121,7 @@ func (gc *GraphClient) InsertAssets(assets []knowledge.Asset) error {`
`113`	`121`	`return fmt.Errorf("Unable to marshall request body")`
`114`	`122`	`}`
`115`	`123`
`116`		`- url := fmt.Sprintf("%s/api/graph/asset?token=%s", gc.url, gc.authToken)`
`117`		`- req, err := http.NewRequest("PUT", url, bytes.NewBuffer(b))`
	`124`	`+ req, err := gc.newRequest("PUT", "/api/graph/assets", bytes.NewBuffer(b))`
`118`	`125`	`if err != nil {`
`119`	`126`	`return err`
`120`	`127`	`}`
`@@ -145,8 +152,7 @@ func (gc *GraphClient) DeleteAssets(assets []knowledge.Asset) error {`
`145`	`152`	`return fmt.Errorf("Unable to marshall request body")`
`146`	`153`	`}`
`147`	`154`
`148`		`- url := fmt.Sprintf("%s/api/graph/asset?token=%s", gc.url, gc.authToken)`
`149`		`- req, err := http.NewRequest("DELETE", url, bytes.NewBuffer(b))`
	`155`	`+ req, err := gc.newRequest("DELETE", "/api/graph/assets", bytes.NewBuffer(b))`
`150`	`156`	`if err != nil {`
`151`	`157`	`return err`
`152`	`158`	`}`
`@@ -177,8 +183,7 @@ func (gc *GraphClient) InsertRelations(relations []knowledge.Relation) error {`
`177`	`183`	`return fmt.Errorf("Unable to marshall request body")`
`178`	`184`	`}`
`179`	`185`
`180`		`- url := fmt.Sprintf("%s/api/graph/relation?token=%s", gc.url, gc.authToken)`
`181`		`- req, err := http.NewRequest("PUT", url, bytes.NewBuffer(b))`
	`186`	`+ req, err := gc.newRequest("PUT", "/api/graph/relations", bytes.NewBuffer(b))`
`182`	`187`	`if err != nil {`
`183`	`188`	`return err`
`184`	`189`	`}`
`@@ -209,8 +214,7 @@ func (gc *GraphClient) DeleteRelations(relations []knowledge.Relation) error {`
`209`	`214`	`return fmt.Errorf("Unable to marshall request body")`
`210`	`215`	`}`
`211`	`216`
`212`		`- url := fmt.Sprintf("%s/api/graph/relation?token=%s", gc.url, gc.authToken)`
`213`		`- req, err := http.NewRequest("DELETE", url, bytes.NewBuffer(b))`
	`217`	`+ req, err := gc.newRequest("DELETE", "/api/graph/relations", bytes.NewBuffer(b))`
`214`	`218`	`if err != nil {`
`215`	`219`	`return err`
`216`	`220`	`}`
Original file line number	Diff line number	Diff line change
`@@ -32,6 +32,10 @@ type Transaction struct {`
`32`	`32`
`33`	`33`	`// The number of items to send to the streaming API in one request`
`34`	`34`	`chunkSize int`
	`35`	`+`
	`36`	`+ retryCount int`
	`37`	`+ retryDelay time.Duration`
	`38`	`+ retryBackoffFactor float64`
`35`	`39`	`}`
`36`	`40`
`37`	`41`	`// Relate create a relation between two assets`
`@@ -49,12 +53,12 @@ func (cgt *Transaction) Bind(asset string, assetType schema.AssetType) {`
`49`	`53`	`}`
`50`	`54`
`51`	`55`	`// withRetryOnTooManyRequests helper retrying the function when too many request error has been received`
`52`		`-func withRetryOnTooManyRequests(fn func() error, maxRetries int) error {`
	`56`	`+func withRetryOnTooManyRequests(fn func() error, backoffFactor float64, maxRetries int, delay time.Duration) error {`
`53`	`57`	`trials := 0`
`54`	`58`	`for {`
`55`	`59`	`err := fn()`
`56`	`60`	`if err != nil {`
`57`		`- backoffTime := time.Duration(int(math.Pow(1.01, float64(trials)))15) time.Second`
	`61`	`+ backoffTime := time.Duration(int(math.Pow(backoffFactor, float64(trials)))) * delay`
`58`	`62`	`fmt.Printf("Sleeping for %d seconds\n", backoffTime/time.Second)`
`59`	`63`	`time.Sleep(backoffTime)`
`60`	`64`	`} else {`
`@@ -104,7 +108,7 @@ func (cgt Transaction) Commit() (knowledge.Graph, error) {`
`104`	`108`	`relations = append(relations, r.(knowledge.Relation))`
`105`	`109`	`}`
`106`	`110`	`f := p.Exec(func() error {`
`107`		`- if err := withRetryOnTooManyRequests(func() error { return cgt.client.DeleteRelations(relations) }, 10); err != nil {`
	`111`	`+ if err := withRetryOnTooManyRequests(func() error { return cgt.client.DeleteRelations(relations) }, cgt.retryBackoffFactor, cgt.retryCount, cgt.retryDelay); err != nil {`
`108`	`112`	`return fmt.Errorf("Unable to remove the relations %v: %v", relations, err)`
`109`	`113`	`}`
`110`	`114`	`progress.Add(len(relations))`
`@@ -119,7 +123,7 @@ func (cgt Transaction) Commit() (knowledge.Graph, error) {`
`119`	`123`	`assets = append(assets, a.(knowledge.Asset))`
`120`	`124`	`}`
`121`	`125`	`f := p.Exec(func() error {`
`122`		`- if err := withRetryOnTooManyRequests(func() error { return cgt.client.InsertAssets(assets) }, 10); err != nil {`
	`126`	`+ if err := withRetryOnTooManyRequests(func() error { return cgt.client.InsertAssets(assets) }, cgt.retryBackoffFactor, cgt.retryCount, cgt.retryDelay); err != nil {`
`123`	`127`	`return fmt.Errorf("Unable to upsert the asset %v: %v", assets, err)`
`124`	`128`	`}`
`125`	`129`	`progress.Add(len(assets))`
`@@ -144,7 +148,7 @@ func (cgt Transaction) Commit() (knowledge.Graph, error) {`
`144`	`148`	`assets = append(assets, a.(knowledge.Asset))`
`145`	`149`	`}`
`146`	`150`	`f := p.Exec(func() error {`
`147`		`- if err := withRetryOnTooManyRequests(func() error { return cgt.client.DeleteAssets(assets) }, 10); err != nil {`
	`151`	`+ if err := withRetryOnTooManyRequests(func() error { return cgt.client.DeleteAssets(assets) }, cgt.retryBackoffFactor, cgt.retryCount, cgt.retryDelay); err != nil {`
`148`	`152`	`return fmt.Errorf("Unable to remove the asset %v: %v", assets, err)`
`149`	`153`	`}`
`150`	`154`	`progress.Add(len(assets))`
`@@ -159,7 +163,7 @@ func (cgt Transaction) Commit() (knowledge.Graph, error) {`
`159`	`163`	`relations = append(relations, r.(knowledge.Relation))`
`160`	`164`	`}`
`161`	`165`	`f := p.Exec(func() error {`
`162`		`- if err := withRetryOnTooManyRequests(func() error { return cgt.client.InsertRelations(relations) }, 10); err != nil {`
	`166`	`+ if err := withRetryOnTooManyRequests(func() error { return cgt.client.InsertRelations(relations) }, cgt.retryBackoffFactor, cgt.retryCount, cgt.retryDelay); err != nil {`
`163`	`167`	`return fmt.Errorf("Unable to upsert the relation %v: %v", relations, err)`
`164`	`168`	`}`
`165`	`169`	`progress.Add(len(relations))`
Original file line number	Diff line number	Diff line change
`@@ -5,24 +5,25 @@ import (`
`5`	`5`	`"net/http"`
`6`	`6`
`7`	`7`	`"github.com/clems4ever/go-graphkb/internal/sources"`
	`8`	`+ "github.com/clems4ever/go-graphkb/internal/utils"`
`8`	`9`	`)`
`9`	`10`
`10`	`11`	`// IsTokenValid is the token valid`
`11`	`12`	`func IsTokenValid(registry sources.Registry, r *http.Request) (bool, string, error) {`
`12`		`- token, ok := r.URL.Query()["token"]`
	`13`	`+ token := r.Header.Get(utils.XAuthTokenHeader)`
`13`	`14`
`14`		`- if !ok \|\| len(token) != 1 {`
`15`		`- return false, "", fmt.Errorf("Unable to detect token query parameter")`
	`15`	`+ if token == "" {`
	`16`	`+ return false, "", fmt.Errorf("No auth token provided")`
`16`	`17`	`}`
`17`	`18`
`18`	`19`	`sourceToToken, err := registry.ListSources(r.Context())`
`19`	`20`
`20`	`21`	`if err != nil {`
`21`		`- return false, "", err`
	`22`	`+ return false, "", fmt.Errorf("Unable to list the sources: %v", err)`
`22`	`23`	`}`
`23`	`24`
`24`	`25`	`for sn, t := range sourceToToken {`
`25`		`- if t == token[0] {`
	`26`	`+ if t == token {`
`26`	`27`	`return true, sn, nil`
`27`	`28`	`}`
`28`	`29`	`}`