Toward better context handling (#1835)

* Use the request context

The code uses context.Background() in a flow where there is a
http.Request. Use the requests context instead.

* Use a true context in the plugin example

Let AddTag/RemoveTag take a context and use that context throughout
the example.

* Avoid the use of context.Background

Prefer context.TODO over context.Background deep in the call chain.

This marks the site as something which we need to context-handle
later, and also makes it clear to the reader that the context is
sort-of temporary in the code base.

While here, be consistent in handling the `act` variable in each
branch of the if .. { .. } .. check.

* Prefer context.TODO over context.Background

For the different scraping operations here, there is a context
higher up the call chain, which we ought to use. Mark the call-sites
as TODO for now, so we can come back later on a sweep of which parts
can be context-lifted.

* Thread context upwards

Initialization requires context for transactions. Thread the context
upward the call chain.

At the intialization call, add a context.TODO since we can't break this
yet. The singleton assumption prevents us from pulling it up into main for
now.

* make tasks context-aware

Change the task interface to understand contexts.

Pass the context down in some of the branches where it is needed.

* Make QueryStashBoxScene context-aware

This call naturally sits inside the request-context. Use it.

* Introduce a context in the JS plugin code

This allows us to use a context for HTTP calls inside the system.

Mark the context with a TODO at top level for now.

* Nitpick error formatting

Use %v rather than %s for error interfaces.
Do not begin an error strong with a capital letter.

* Avoid the use of http.Get in FFMPEG download chain

Since http.Get has no context, it isn't possible to break out or have
policy induced. The call will block until the GET completes. Rewrite
to use a http Request and provide a context.

Thread the context through the call chain for now. provide
context.TODO() at the top level of the initialization chain.

* Make getRemoteCDPWSAddress aware of contexts

Eliminate a call to http.Get and replace it with a context-aware
variant.

Push the context upwards in the call chain, but plug it before the
scraper interface so we don't have to rewrite said interface yet.

Plugged with context.TODO()

* Scraper: make the getImage function context-aware

Use a context, and pass it upwards. Plug it with context.TODO()
up the chain before the rewrite gets too much out of hand for now.

Minor tweaks along the way, remove a call to context.Background()
deep in the call chain.

* Make NOTIFY request context-aware

The call sits inside a Request-handler. So it's natural to use the
requests context as the context for the outgoing HTTP request.

* Use a context in the url scraper code

We are sitting in code which has a context, so utilize it for the
request as well.

* Use a context when checking versions

When we check the version of stash on Github, use a context. Thread
the context up to the initialization routine of the HTTP/GraphQL
server and plug it with a context.TODO() for now.

This paves the way for providing a context to the HTTP server code in a
future patch.

* Make utils func ReadImage context-aware

In almost all of the cases, there is a context in the call chain which
is a natural use. This is true for all the GraphQL mutations.

The exception is in task_stash_box_tag, so plug that task with
context.TODO() for now.

* Make stash-box get context-aware

Thread a context through the call chain until we hit the Client API.
Plug it with context.TODO() there for now.

* Enable the noctx linter

The code is now free of any uncontexted HTTP request. This means we
pass the noctx linter, and we can enable it in the code base.

pkg/api/check_version.go

@@ -1,6 +1,7 @@
 package api
 
 import (
+	"context"
 	"encoding/json"
 	"errors"
 	"fmt"
@@ -107,12 +108,12 @@ type githubTagResponse struct {
 	Node_id string
 }
 
-func makeGithubRequest(url string, output interface{}) error {
+func makeGithubRequest(ctx context.Context, url string, output interface{}) error {
 	client := &http.Client{
 		Timeout: 3 * time.Second,
 	}
 
-	req, _ := http.NewRequest("GET", url, nil)
+	req, _ := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
 
 	req.Header.Add("Accept", apiAcceptHeader) // gh api recommendation , send header with api version
 	response, err := client.Do(req)
@@ -147,7 +148,7 @@ func makeGithubRequest(url string, output interface{}) error {
 // If running a build from the "master" branch, then the latest full release
 // is used, otherwise it uses the release that is tagged with "latest_develop"
 // which is the latest pre-release build.
-func GetLatestVersion(shortHash bool) (latestVersion string, latestRelease string, err error) {
+func GetLatestVersion(ctx context.Context, shortHash bool) (latestVersion string, latestRelease string, err error) {
 
 	arch := runtime.GOARCH                                                                    // https://en.wikipedia.org/wiki/Comparison_of_ARM_cores
 	isARMv7 := cpu.ARM.HasNEON || cpu.ARM.HasVFPv3 || cpu.ARM.HasVFPv3D16 || cpu.ARM.HasVFPv4 // armv6 doesn't support any of these features
@@ -180,14 +181,14 @@ func GetLatestVersion(shortHash bool) (latestVersion string, latestRelease strin
 	}
 
 	release := githubReleasesResponse{}
-	err = makeGithubRequest(url, &release)
+	err = makeGithubRequest(ctx, url, &release)
 
 	if err != nil {
 		return "", "", err
 	}
 
 	if release.Prerelease == usePreRelease {
-		latestVersion = getReleaseHash(release, shortHash, usePreRelease)
+		latestVersion = getReleaseHash(ctx, release, shortHash, usePreRelease)
 
 		if wantedRelease != "" {
 			for _, asset := range release.Assets {
@@ -205,12 +206,12 @@ func GetLatestVersion(shortHash bool) (latestVersion string, latestRelease strin
 	return latestVersion, latestRelease, nil
 }
 
-func getReleaseHash(release githubReleasesResponse, shortHash bool, usePreRelease bool) string {
+func getReleaseHash(ctx context.Context, release githubReleasesResponse, shortHash bool, usePreRelease bool) string {
 	shaLength := len(release.Target_commitish)
 	// the /latest API call doesn't return the hash in target_commitish
 	// also add sanity check in case Target_commitish is not 40 characters
 	if !usePreRelease || shaLength != 40 {
-		return getShaFromTags(shortHash, release.Tag_name)
+		return getShaFromTags(ctx, shortHash, release.Tag_name)
 	}
 
 	if shortHash {
@@ -225,9 +226,9 @@ func getReleaseHash(release githubReleasesResponse, shortHash bool, usePreReleas
 	return release.Target_commitish
 }
 
-func printLatestVersion() {
+func printLatestVersion(ctx context.Context) {
 	_, githash, _ = GetVersion()
-	latest, _, err := GetLatestVersion(true)
+	latest, _, err := GetLatestVersion(ctx, true)
 	if err != nil {
 		logger.Errorf("Couldn't find latest version: %s", err)
 	} else {
@@ -241,10 +242,10 @@ func printLatestVersion() {
 
 // get sha from the github api tags endpoint
 // returns the sha1 hash/shorthash or "" if something's wrong
-func getShaFromTags(shortHash bool, name string) string {
+func getShaFromTags(ctx context.Context, shortHash bool, name string) string {
 	url := apiTags
 	tags := []githubTagResponse{}
-	err := makeGithubRequest(url, &tags)
+	err := makeGithubRequest(ctx, url, &tags)
 
 	if err != nil {
 		logger.Errorf("Github Tags Api %v", err)