proxy

Complete, and complex demo.

client -> protected local proxy -> protected pac server - connection setup -> protected upstream proxy -> protected target.

//////
// Setup demo logger.
//////

// Only `stdout`, and `stderr`
loggingOptions := &LoggingOptions{
	FileLevel: level.None.String(),
	FilePath:  "-",

	// Change to `Trace` for debugging, and demonstration purposes.
	Level: level.None.String(),
}

l := logger.Setup(loggingOptions)

//////
// Randomness automates port allocation, ensuring no collision happens
// between tests, and examples.
//////

r, err := randomness.New(49000, 50000, 100, true)
if err != nil {
	log.Fatalln("Failed to create randomness.", err)
}

//////
// Target/end server.
//////

targetServer := createMockedHTTPServer(http.StatusOK, "body", "dXNlcjE6cGFzczE=")

defer func() { targetServer.Close() }()

targetServerURI, err := url.ParseRequestURI(targetServer.URL)
if err != nil {
	//nolint:gocritic
	log.Fatalln("Failed to parse target server URL.", err)
}

targetServerURI.User = url.UserPassword("user1", "pass1")

l.Debuglnf("Target/end server started @ %s", targetServerURI.Redacted())

//////
// PAC content.
//////

// Use `int(r.MustGenerate())` for testing purposes. Specify a port if using
// a manual - external proxy (e.g.: NGINX). Good for debugging, and demo
// purposes.
upstreamProxyPort := int(r.MustGenerate())

templateMap := map[string]int{
	"port": upstreamProxyPort,
}

var pacText strings.Builder
_ = template.Must(template.New("pacTemplate").Parse(pacTemplate)).Execute(&pacText, templateMap)

l.Debuglnf("PAC template parsed: \n%s", pacText.String())

//////
// PAC server.
//////

pacServer := createMockedHTTPServer(http.StatusOK, pacText.String(), "dXNlcjpwYXNz")

defer func() { pacServer.Close() }()

pacServerURI, err := url.ParseRequestURI(pacServer.URL)
if err != nil {
	log.Fatalln("Failed to parse PAC server URL.", err)
}

pacServerURI.User = url.UserPassword("user", "pass")

l.Debuglnf("PAC server started @ %s", pacServerURI.Redacted())

//////
// URL for both proxies, local, and upstream.
//////

// Local proxy.
localProxyURI := URIBuilder(defaultProxyHostname, r.MustGenerate(), localProxyCredentialUsername, localProxyCredentialPassword)

// Upstream proxy.
upstreamProxyURI := URIBuilder(defaultProxyHostname, int64(upstreamProxyPort), upstreamProxyCredentialUsername, upstreamProxyCredentialPassword)

//////
// Local proxy.
//
// It's protected with Basic Auth. Upstream proxy will be automatically, and
// dynamically setup via PAC, including credentials for proxies specified
// in the PAC content.
//////

localProxy, err := New(
	// Local proxy URI.
	localProxyURI.String(),

	// Upstream proxy URI.
	"",

	// PAC URI.
	pacServerURI.String(),

	// PAC proxies credentials in standard URI format.
	[]string{upstreamProxyURI.String()},

	// Logging settings.
	loggingOptions,
)
if err != nil {
	log.Fatalln("Failed to create proxy.", err)
}

go localProxy.Run()

// Give enough time to start, and be ready.
time.Sleep(1 * time.Second)

//////
// Upstream Proxy.
//////

upstreamProxy, err := New(
	// Local proxy URI.
	upstreamProxyURI.String(),

	// Upstream proxy URI.
	"",

	// PAC URI.
	"",

	// PAC proxies credentials in standard URI format.
	nil,

	// Logging settings.
	loggingOptions,
)
if err != nil {
	log.Fatalln("Failed to create upstream proxy.", err)
}

go upstreamProxy.Run()

// Give enough time to start, and be ready.
time.Sleep(1 * time.Second)

//////
// Client.
//////

l.Debuglnf("Client is using %s as proxy", localProxyURI.Redacted())

// Client's proxy settings.
tr := &http.Transport{
	Proxy: http.ProxyURL(localProxyURI),
}

client := &http.Client{
	Transport: tr,
}

statusCode, body, err := executeRequest(client, targetServerURI.String())
if err != nil {
	log.Fatalf("Failed to execute request: %v", err)
}

fmt.Println(statusCode)
fmt.Println(body)

Output:
200
body