chore: merge probe-engine into probe-cli (#201)

This is how I did it:

1. `git clone https://github.com/ooni/probe-engine internal/engine`

2. ```
(cd internal/engine && git describe --tags)
v0.23.0
```

3. `nvim go.mod` (merging `go.mod` with `internal/engine/go.mod`

4. `rm -rf internal/.git internal/engine/go.{mod,sum}`

5. `git add internal/engine`

6. `find . -type f -name \*.go -exec sed -i 's@/ooni/probe-engine@/ooni/probe-cli/v3/internal/engine@g' {} \;`

7. `go build ./...` (passes)

8. `go test -race ./...` (temporary failure on RiseupVPN)

9. `go mod tidy`

10. this commit message

Once this piece of work is done, we can build a new version of `ooniprobe` that
is using `internal/engine` directly. We need to do more work to ensure all the
other functionality in `probe-engine` (e.g. making mobile packages) are still WAI.

Part of https://github.com/ooni/probe/issues/1335

internal/engine/cmd/jafar/uncensored/uncensored.go

@@ -0,0 +1,86 @@
+// Package uncensored contains code used by Jafar to evade its own
+// censorship efforts by taking alternate routes.
+package uncensored
+
+import (
+	"context"
+	"net"
+	"net/http"
+
+	"github.com/apex/log"
+	"github.com/ooni/probe-cli/v3/internal/engine/experiment/urlgetter"
+	"github.com/ooni/probe-cli/v3/internal/engine/internal/runtimex"
+	"github.com/ooni/probe-cli/v3/internal/engine/netx"
+)
+
+// Client is DNS, HTTP, and TCP client.
+type Client struct {
+	dnsClient     *netx.DNSClient
+	httpTransport netx.HTTPRoundTripper
+	dialer        netx.Dialer
+}
+
+// NewClient creates a new Client.
+func NewClient(resolverURL string) (*Client, error) {
+	configuration, err := urlgetter.Configurer{
+		Config: urlgetter.Config{
+			ResolverURL: resolverURL,
+		},
+		Logger: log.Log,
+	}.NewConfiguration()
+	if err != nil {
+		return nil, err
+	}
+	return &Client{
+		dnsClient:     &configuration.DNSClient,
+		httpTransport: netx.NewHTTPTransport(configuration.HTTPConfig),
+		dialer:        netx.NewDialer(configuration.HTTPConfig),
+	}, nil
+}
+
+// Must panics if it's not possible to create a Client. Usually you should
+// use it like `uncensored.Must(uncensored.NewClient(URL))`.
+func Must(client *Client, err error) *Client {
+	runtimex.PanicOnError(err, "cannot create uncensored client")
+	return client
+}
+
+// DefaultClient is the default client for DNS, HTTP, and TCP.
+var DefaultClient = Must(NewClient(""))
+
+var _ netx.Resolver = DefaultClient
+
+// Address implements netx.Resolver.Address
+func (c *Client) Address() string {
+	return c.dnsClient.Address()
+}
+
+// LookupHost implements netx.Resolver.LookupHost
+func (c *Client) LookupHost(ctx context.Context, domain string) ([]string, error) {
+	return c.dnsClient.LookupHost(ctx, domain)
+}
+
+// Network implements netx.Resolver.Network
+func (c *Client) Network() string {
+	return c.dnsClient.Network()
+}
+
+var _ netx.Dialer = DefaultClient
+
+// DialContext implements netx.Dialer.DialContext
+func (c *Client) DialContext(ctx context.Context, network, address string) (net.Conn, error) {
+	return c.dialer.DialContext(ctx, network, address)
+}
+
+var _ netx.HTTPRoundTripper = DefaultClient
+
+// CloseIdleConnections implement netx.HTTPRoundTripper.CloseIdleConnections
+func (c *Client) CloseIdleConnections() {
+	c.dnsClient.CloseIdleConnections()
+	c.httpTransport.CloseIdleConnections()
+}
+
+// RoundTrip implement netx.HTTPRoundTripper.RoundTrip
+func (c *Client) RoundTrip(req *http.Request) (*http.Response, error) {
+	return c.httpTransport.RoundTrip(req)
+}

internal/engine/cmd/jafar/uncensored/uncensored_test.go

@@ -0,0 +1,75 @@
+package uncensored
+
+import (
+	"bytes"
+	"context"
+	"io/ioutil"
+	"net/http"
+	"net/url"
+	"testing"
+)
+
+func TestGood(t *testing.T) {
+	client, err := NewClient("dot://1.1.1.1:853")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer client.CloseIdleConnections()
+	if client.Address() != "1.1.1.1:853" {
+		t.Fatal("invalid address")
+	}
+	if client.Network() != "dot" {
+		t.Fatal("invalid network")
+	}
+	ctx := context.Background()
+	addrs, err := client.LookupHost(ctx, "dns.google")
+	if err != nil {
+		t.Fatal(err)
+	}
+	var quad8, two8two4 bool
+	for _, addr := range addrs {
+		quad8 = quad8 || (addr == "8.8.8.8")
+		two8two4 = two8two4 || (addr == "8.8.4.4")
+	}
+	if quad8 != true && two8two4 != true {
+		t.Fatal("invalid response")
+	}
+	conn, err := client.DialContext(ctx, "tcp", "8.8.8.8:853")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer conn.Close()
+	resp, err := client.RoundTrip(&http.Request{
+		Method: "GET",
+		URL: &url.URL{
+			Scheme: "https",
+			Host:   "www.google.com",
+			Path:   "/humans.txt",
+		},
+		Header: http.Header{},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer resp.Body.Close()
+	if resp.StatusCode != 200 {
+		t.Fatal("invalid status-code")
+	}
+	data, err := ioutil.ReadAll(resp.Body)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !bytes.HasPrefix(data, []byte("Google is built by a large team")) {
+		t.Fatal("not the expected body")
+	}
+}
+
+func TestNewClientFailure(t *testing.T) {
+	clnt, err := NewClient("antani:///")
+	if err == nil {
+		t.Fatal("expected an error here")
+	}
+	if clnt != nil {
+		t.Fatal("expected nil client here")
+	}
+}