go-sysproxy/example_test.go at main · mar0ls/go-sysproxy · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
package sysproxy_test

import (
	"context"
	"fmt"
	"log"
	"time"

	sysproxy "github.com/mar0ls/go-sysproxy"
)

func ExampleSet() {
	if err := sysproxy.Set("http://user:pass@proxy.example.com:8080", sysproxy.ScopeGlobal); err != nil {
		log.Fatal(err)
	}
	fmt.Println("proxy set")
}

func ExampleSet_noAuth() {
	if err := sysproxy.Set("http://proxy.example.com:8080", sysproxy.ScopeGlobal); err != nil {
		log.Fatal(err)
	}
	fmt.Println("proxy set")
}

func ExampleSetContext() {
	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
	err := sysproxy.SetContext(ctx, "http://proxy.example.com:8080", sysproxy.ScopeGlobal)
	cancel()
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println("proxy set")
}

func ExampleUnset() {
	if err := sysproxy.Unset(sysproxy.ScopeGlobal); err != nil {
		log.Fatal(err)
	}
	fmt.Println("proxy cleared")
}

func ExampleSetMulti() {
	if err := sysproxy.SetMulti(sysproxy.ProxyConfig{
		HTTP:    "http://http-proxy.example.com:8080",
		HTTPS:   "http://https-proxy.example.com:8080",
		SOCKS:   "socks5://socks-proxy.example.com:1080",
		NoProxy: "localhost,10.0.0.0/8",
	}, sysproxy.ScopeGlobal); err != nil {
		log.Fatal(err)
	}
	fmt.Println("per-protocol proxies set")
}

func ExampleWithProxy() {
	ctx := context.Background()

	err := sysproxy.WithProxy(ctx, "socks5://proxy.example.com:1080", sysproxy.ScopeGlobal,
		func(ctx context.Context) error {
			fmt.Println("running with proxy")
			return nil
		},
	)
	if err != nil {
		log.Fatal(err)
	}
}

func ExampleCheck() {
	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
	defer cancel()

	if err := sysproxy.Check(ctx, "http://proxy.example.com:8080"); err != nil {
		log.Printf("proxy unreachable: %v", err)
		return
	}
	fmt.Println("proxy reachable")
}

func ExampleWriteAppConfig() {
	if err := sysproxy.WriteAppConfig(sysproxy.AppGit, "http://proxy.example.com:8080"); err != nil {
		log.Fatal(err)
	}
	fmt.Println("git proxy configured")
}

func ExampleWriteAppConfigContext() {
	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
	err := sysproxy.WriteAppConfigContext(ctx, sysproxy.AppGit, "http://proxy.example.com:8080")
	cancel()
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println("git proxy configured")
}

func ExampleSetLogger() {
	// Disable logging (restores the default no-op state).
	sysproxy.SetLogger(nil)
	fmt.Println("logging disabled")
	// Output: logging disabled
}

func ExampleGet() {
	url, err := sysproxy.Get()
	if err != nil {
		log.Printf("no proxy configured: %v", err)
		return
	}
	fmt.Println("current proxy:", url)
}

func ExampleGetConfig() {
	cfg, err := sysproxy.GetConfig()
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println("HTTP:", cfg.HTTP)
	fmt.Println("HTTPS:", cfg.HTTPS)
	fmt.Println("SOCKS:", cfg.SOCKS)
	fmt.Println("NoProxy:", cfg.NoProxy)
}

func ExampleSetPAC() {
	if err := sysproxy.SetPAC("http://wpad.example.com/proxy.pac", sysproxy.ScopeGlobal); err != nil {
		log.Fatal(err)
	}
	fmt.Println("PAC configured")
}