コード例 #1
0
ファイル: client.go プロジェクト: nicholasray/sandstone
// WithHTTPClient configures a Maps API client with a http.Client to make requests over.
func WithHTTPClient(c *http.Client) ClientOption {
	return func(client *Client) error {
		if _, ok := c.Transport.(*transport); !ok {
			t := c.Transport
			if t != nil {
				c.Transport = &transport{Base: t}
			} else {
				c.Transport = &transport{Base: http.DefaultTransport}
			}
		}
		client.httpClient = c
		return nil
	}
}
コード例 #2
0
ファイル: catm.go プロジェクト: luoshuhui/catm
func fiddler2_enable(client *http.Client, proxys string) {
	transport := &http.Transport{}
	http_proxy := url.URL{}
	proxy, _ := http_proxy.Parse(proxys)
	transport.Proxy = http.ProxyURL(proxy)
	client.Transport = transport
}
コード例 #3
0
ファイル: client.go プロジェクト: odeke-em/appengine-go
// NewRemoteContext returns a context that gives access to the production
// APIs for the application at the given host. All communication will be
// performed over SSL unless the host is localhost.
func NewRemoteContext(host string, client *http.Client) (appengine.Context, error) {
	// Add an appcfg header to outgoing requests.
	t := client.Transport
	if t == nil {
		t = http.DefaultTransport
	}
	client.Transport = &headerAddingRoundTripper{t}

	url := url.URL{
		Scheme: "https",
		Host:   host,
		Path:   "/_ah/remote_api",
	}
	if host == "localhost" || strings.HasPrefix(host, "localhost:") {
		url.Scheme = "http"
	}
	u := url.String()
	appID, err := getAppID(client, u)
	if err != nil {
		return nil, fmt.Errorf("unable to contact server: %v", err)
	}
	return &context{
		client: client,
		url:    u,
		appID:  appID,
	}, nil
}
コード例 #4
0
func (c *PleskApiClient) Request(request string) (response string, err error) {
	url := fmt.Sprintf("%s://%s:%d/enterprise/control/agent.php", c.protocol, c.host, c.port)

	req, err := http.NewRequest("POST", url, strings.NewReader(request))
	if err != nil {
		return
	}
	req.Header.Add("Content-type", "text/xml")
	req.Header.Add("HTTP_PRETTY_PRINT", "TRUE")
	if c.secretKey != "" {
		req.Header.Add("KEY", c.secretKey)
	} else {
		req.Header.Add("HTTP_AUTH_LOGIN", c.login)
		req.Header.Add("HTTP_AUTH_PASSWD", c.password)
	}

	client := http.Client{}
	if c.InsecureSkipVerify {
		tr := &http.Transport{
			TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
		}
		client.Transport = tr
	}

	resp, err := client.Do(req)
	if err != nil {
		return
	}
	defer resp.Body.Close()
	bytes, err := ioutil.ReadAll(resp.Body)
	response = string(bytes)
	return
}
コード例 #5
0
ファイル: restTest2.go プロジェクト: OMGapotato/goserver
func main() {

	transport := new(http.Transport)
	transport.TLSClientConfig = &tls.Config{InsecureSkipVerify: true}

	client := new(http.Client)

	client.Transport = transport

	url := "https://10.80.65.70:9443/rest/agent/1a5dc1ef-f0e6-4aad-839a-a7880d539e8d"
	req, err := http.NewRequest("GET", url, nil)
	if err != nil {
		panic(err)
	}

	creds := convertCredentials("admin", "admin")

	req.Header.Add("Authorization", "Basic "+creds)

	resp, err := client.Do(req)
	if err != nil {
		panic(err)
	}

	fmt.Println(resp)

}
コード例 #6
0
ファイル: client.go プロジェクト: nildev/account
// NewRemoteContext returns a context that gives access to the production
// APIs for the application at the given host. All communication will be
// performed over SSL unless the host is localhost.
func NewRemoteContext(host string, client *http.Client) (context.Context, error) {
	// Add an appcfg header to outgoing requests.
	t := client.Transport
	if t == nil {
		t = http.DefaultTransport
	}
	client.Transport = &headerAddingRoundTripper{t}

	url := url.URL{
		Scheme: "https",
		Host:   host,
		Path:   "/_ah/remote_api",
	}
	if host == "localhost" || strings.HasPrefix(host, "localhost:") {
		url.Scheme = "http"
	}
	u := url.String()
	appID, err := getAppID(client, u)
	if err != nil {
		return nil, fmt.Errorf("unable to contact server: %v", err)
	}
	rc := &remoteContext{
		client: client,
		url:    u,
	}
	ctx := internal.WithCallOverride(context.Background(), rc.call)
	ctx = internal.WithLogOverride(ctx, rc.logf)
	ctx = internal.WithAppIDOverride(ctx, appID)
	return ctx, nil
}
コード例 #7
0
ファイル: client.go プロジェクト: sirnewton01/gojazz
// Create a new client for making http requests against a Jazz server with the provided credentials
// The client will execute the requests authenticating somewhat transparently when needed
func NewClient(userID string, password string) (*Client, error) {
	jClient := &Client{}

	jClient.userID = userID
	jClient.password = password

	options := cookiejar.Options{
		PublicSuffixList: publicsuffix.List,
	}
	jar, err := cookiejar.New(&options)
	if err != nil {
		return nil, err
	}
	client := http.Client{Jar: jar}

	tr := &http.Transport{
		TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
	}
	client.Transport = tr
	client.CheckRedirect = nil

	jClient.httpClient = &client

	// Provide a no-op logger as the default
	jClient.Log = log.New(ioutil.Discard, "", log.LstdFlags)

	return jClient, nil
}
コード例 #8
0
ファイル: pulp.go プロジェクト: msutter/nodetree
func NewClient(host string, User string, Passwd string, httpClient *http.Client) (client *Client, err error) {
	if httpClient == nil {
		httpClient = http.DefaultClient
	}

	transport := &httpclient.Transport{
		ConnectTimeout:        1 * time.Second,
		ResponseHeaderTimeout: 10 * time.Second,
		RequestTimeout:        30 * time.Second,
	}
	defer transport.Close()
	httpClient.Transport = transport

	client = &Client{
		client:    httpClient,
		UserAgent: userAgent,
		apiUser:   User,
		apiPasswd: Passwd,
	}

	if err := client.SetHost(host); err != nil {
		return nil, err
	}

	client.Repositories = &RepositoriesService{client: client}
	client.Tasks = &TasksService{client: client}

	return
}
コード例 #9
0
ファイル: session.go プロジェクト: AdamOssenford/docker-pi
// TODO(tiborvass): remove authConfig param once registry client v2 is vendored
func NewSession(client *http.Client, authConfig *cliconfig.AuthConfig, endpoint *Endpoint) (r *Session, err error) {
	r = &Session{
		authConfig:    authConfig,
		client:        client,
		indexEndpoint: endpoint,
	}

	var alwaysSetBasicAuth bool

	// If we're working with a standalone private registry over HTTPS, send Basic Auth headers
	// alongside all our requests.
	if endpoint.VersionString(1) != IndexServerAddress() && endpoint.URL.Scheme == "https" {
		info, err := endpoint.Ping()
		if err != nil {
			return nil, err
		}

		if info.Standalone && authConfig != nil {
			logrus.Debugf("Endpoint %s is eligible for private registry. Enabling decorator.", endpoint.String())
			alwaysSetBasicAuth = true
		}
	}

	// Annotate the transport unconditionally so that v2 can
	// properly fallback on v1 when an image is not found.
	client.Transport = AuthTransport(client.Transport, authConfig, alwaysSetBasicAuth)

	jar, err := cookiejar.New(nil)
	if err != nil {
		return nil, errors.New("cookiejar.New is not supposed to return an error")
	}
	client.Jar = jar

	return r, nil
}
コード例 #10
0
ファイル: client.go プロジェクト: vdemeester/rancher-compose
// NewClient initializes a new API client for the given host and API version.
// It uses the given http client as transport.
// It also initializes the custom http headers to add to each request.
//
// It won't send any version information if the version number is empty. It is
// highly recommended that you set a version or your client may break if the
// server is upgraded.
func NewClient(host string, version string, client *http.Client, httpHeaders map[string]string) (*Client, error) {
	proto, addr, basePath, err := ParseHost(host)
	if err != nil {
		return nil, err
	}

	if client == nil {
		client = &http.Client{}
	}

	if client.Transport == nil {
		// setup the transport, if not already present
		transport := new(http.Transport)
		sockets.ConfigureTransport(transport, proto, addr)
		client.Transport = transport
	}

	return &Client{
		host:              host,
		proto:             proto,
		addr:              addr,
		basePath:          basePath,
		client:            client,
		version:           version,
		customHTTPHeaders: httpHeaders,
	}, nil
}
コード例 #11
0
func TestTransformingTransport(t *testing.T) {
	client := new(http.Client)
	tr := &TransformingTransport{testTransport{}, client}
	client.Transport = tr

	tests := []struct {
		url         string
		code        int
		expectError bool
	}{
		{"http://good.test/png#1", http.StatusOK, false},
		{"http://good.test/error#1", http.StatusInternalServerError, true},
		// TODO: test more than just status code... verify that image
		// is actually transformed and returned properly and that
		// non-image responses are returned as-is
	}

	for _, tt := range tests {
		req, _ := http.NewRequest("GET", tt.url, nil)

		resp, err := tr.RoundTrip(req)
		if err != nil {
			if !tt.expectError {
				t.Errorf("RoundTrip(%v) returned unexpected error: %v", tt.url, err)
			}
			continue
		} else if tt.expectError {
			t.Errorf("RoundTrip(%v) did not return expected error", tt.url)
		}
		if got, want := resp.StatusCode, tt.code; got != want {
			t.Errorf("RoundTrip(%v) returned status code %d, want %d", tt.url, got, want)
		}
	}
}
コード例 #12
0
ファイル: cloud.go プロジェクト: CowLeo/distribution
// WithContext returns a new context in a similar way NewContext does,
// but initiates the new context with the specified parent.
func WithContext(parent context.Context, projID string, c *http.Client) context.Context {
	// TODO(bradfitz): delete internal.Transport. It's too wrappy for what it does.
	// Do User-Agent some other way.
	if _, ok := c.Transport.(*internal.Transport); !ok {
		c.Transport = &internal.Transport{Base: c.Transport}
	}
	return internal.WithContext(parent, projID, c)
}
コード例 #13
0
ファイル: vcr.go プロジェクト: undernewmanagement/besticon
func NewReplayerClient(r io.Reader) (http.Client, error) {
	client := http.Client{}
	transport, err := NewReplayerTransport(r)
	if err != nil {
		return client, err
	}
	client.Transport = transport
	return client, err
}
コード例 #14
0
ファイル: httprecorder.go プロジェクト: devick/flynn
func NewWithClient(client *http.Client) *Recorder {
	r := &Recorder{Client: client}
	r.originalTransport = client.Transport
	if r.originalTransport == nil {
		r.originalTransport = &http.Transport{}
	}
	client.Transport = &roundTripRecorder{RoundTripper: r.originalTransport}
	return r
}
コード例 #15
0
ファイル: client.go プロジェクト: CaptainIlu/cloud-torrent
// Returns the http.Client's TLS Config, traversing and generating any
// defaults along the way to get it.
func ClientTLSConfig(cl *http.Client) *tls.Config {
	if cl.Transport == nil {
		cl.Transport = http.DefaultTransport
	}
	tr := cl.Transport.(*http.Transport)
	if tr.TLSClientConfig == nil {
		tr.TLSClientConfig = &tls.Config{}
	}
	return tr.TLSClientConfig
}
コード例 #16
0
ファイル: transport.go プロジェクト: ChangsoonKim/delibird
// ActivateNonDefault starts the mock environment with a non-default http.Client.
// This emulates the Activate function, but allows for custom clients that do not use
// http.DefaultTransport
//
// To enable mocks for a test using a custom client, activate at the beginning of a test:
// 		client := &http.Client{Transport: &http.Transport{TLSHandshakeTimeout: 60 * time.Second}}
// 		httpmock.ActivateNonDefault(client)
func ActivateNonDefault(client *http.Client) {
	if Disabled() {
		return
	}

	// save the custom client & it's RoundTripper
	oldTransport = client.Transport
	oldClient = client
	client.Transport = DefaultTransport
}
コード例 #17
0
ファイル: client.go プロジェクト: dudymas/marathonctl
func NewClient(login *Login, insecure bool) *Client {
	c := http.Client{}
	if tr := getTransportConfig(insecure); tr != nil {
		c.Transport = tr
	}
	return &Client{
		client: c,
		login:  login,
	}
}
コード例 #18
0
ファイル: testconsumer.go プロジェクト: tehol/kafka-pixy
func SpawnMessageFetcher(addr, topic, group string) *MessageFetcher {
	useUnixDomainSocket := false
	var baseURL string
	if strings.HasPrefix(addr, "/") {
		fmt.Printf("Using UDS client for %s\n", addr)
		baseURL = "http://_"
		useUnixDomainSocket = true
	} else {
		fmt.Printf("Using net client for %s\n", addr)
		baseURL = fmt.Sprintf("http://%s", addr)
	}
	url := fmt.Sprintf("%s/topics/%s/messages?group=%s", baseURL, topic, group)

	var httpClt http.Client
	if useUnixDomainSocket {
		dial := func(proto, ignoredAddr string) (net.Conn, error) {
			return net.Dial("unix", addr)
		}
		httpClt.Transport = &http.Transport{Dial: dial}
	}

	mf := &MessageFetcher{
		url:       url,
		httpClt:   httpClt,
		messages:  make(chan []byte),
		closingCh: make(chan struct{}),
	}

	mf.wg.Add(1)
	go func() {
		defer mf.wg.Done()
		for {
			message, err := mf.fetchMessage()
			if err != nil {
				fmt.Printf("Failed to fetch a message: err=(%s)\n", err)
				select {
				case <-mf.closingCh:
					return
				case <-time.After(backOffTimeout):
				}
				continue
			}
			if message != nil {
				mf.messages <- message
			}
			select {
			case <-mf.closingCh:
				return
			default:
			}
		}
	}()

	return mf
}
コード例 #19
0
ファイル: main.go プロジェクト: CodyGuo/Go-Cody
//返回一个可设置代理的 http Client,代理在全局变量 proxy 中设定
func Proxy() *http.Client {
	var conn http.Client
	if proxy != "" {
		proxyUrl, err := url.Parse(proxy)
		if err != nil {
			fmt.Println(err)
			os.Exit(2)
		}
		conn.Transport = &http.Transport{Proxy: http.ProxyURL(proxyUrl)}
	}
	return &conn
}
コード例 #20
0
ファイル: restTest.go プロジェクト: OMGapotato/goserver
func main() {

	transport := new(http.Transport)
	transport.TLSClientConfig = &tls.Config{InsecureSkipVerify: true}

	client := new(http.Client)

	client.Transport = transport

	url := "https://10.80.65.70:9443/rest/agent/1a5dc1ef-f0e6-4aad-839a-a7880d539e8d/log/9429c03e-a07a-48ef-8a74-a4c2ace992a2"
	req, err := http.NewRequest("GET", url, nil)
	if err != nil {
		panic(err)
	}

	creds := convertCredentials("admin", "admin")

	req.Header.Add("Authorization", "Basic "+creds)

	resp, err := client.Do(req)
	if err != nil {
		panic(err)
	}

	//	bytes, err := ioutil.ReadAll(resp.Body)
	//	if err != nil {
	//		panic(err)
	//	}

	//temp := resp.Header["Content-Disposition"]
	//temp2 := string.Fields("[attachment; filename=")
	//temp2 := strings.Trim(temp, "[attachment; filename=")
	//fmt.Println(temp2)
	//fmt.Println(bytes)
	//var result map[string]interface{}
	//err = json.Unmarshal(bytes, &result)
	//if err != nil {
	//		panic(err)
	//	}
	//	fmt.Println(result)

	/*
		defer resp.Body.Close()
		out, err := os.Create("filename.tar.gz")
		if err != nil {
			panic(err)
		}
		defer out.Close()
		io.Copy(out, resp.Body)
		fmt.Println(out)
	*/
}
コード例 #21
0
ファイル: logger.go プロジェクト: h12w/getgo
// NewHTTPLogger creates an HTTPLogger by inspecting the connection's Read
// method of an http.Client.
func NewHTTPLogger(client *http.Client) *HTTPLogger {
	httpLogger := &HTTPLogger{
		client:         client,
		startTime:      time.Now(),
		avgByteCounter: newAvgCounter()}
	if client.Transport == nil {
		client.Transport = &http.Transport{}
	}
	if transport, ok := client.Transport.(*http.Transport); ok {
		transport.Dial = httpLogger.wrappedDial
	}
	return httpLogger
}
コード例 #22
0
ファイル: cloud.go プロジェクト: nildev/account
// WithContext returns a new context in a similar way NewContext does,
// but initiates the new context with the specified parent.
func WithContext(parent context.Context, projID string, c *http.Client) context.Context {
	// TODO(bradfitz): delete internal.Transport. It's too wrappy for what it does.
	// Do User-Agent some other way.
	if c == nil {
		panic("invalid nil *http.Client passed to WithContext")
	}
	if _, ok := c.Transport.(*internal.Transport); !ok {
		base := c.Transport
		if base == nil {
			base = http.DefaultTransport
		}
		c.Transport = &internal.Transport{Base: base}
	}
	return internal.WithContext(parent, projID, c)
}
コード例 #23
0
ファイル: http_client.go プロジェクト: henrypfhu/hprose-go
func newHttpTransporter() (trans *httpTransporter) {
	tr := new(http.Transport)
	tr.DisableCompression = true
	tr.DisableKeepAlives = false
	tr.MaxIdleConnsPerHost = 4
	jar := cookieJar
	if DisableGlobalCookie {
		jar, _ = cookiejar.New(nil)
	}
	client := new(http.Client)
	client.Jar = jar
	client.Transport = tr
	trans = new(httpTransporter)
	trans.Client = client
	trans.Header = new(http.Header)
	return
}
コード例 #24
0
ファイル: retry_test.go プロジェクト: peterbourgon/srvproxy
func TestRetryTimeout(t *testing.T) {
	d := time.Millisecond
	rt := &fixedRoundTripper{failUntil: time.Now().Add(d)}
	c := http.Client{}
	c.Transport = retry.Retry(retry.MaxAttempts(0), retry.Timeout(2*d), retry.Next(rt))

	resp, err := c.Get("http://bar")
	if err != nil {
		t.Fatal(err)
	}

	if want, have := http.StatusTeapot, resp.StatusCode; want != have {
		t.Fatalf("want %v, have %v", want, have)
	}

	t.Logf("just FYI, it took %d attempt(s) to succeed", rt.count)
}
コード例 #25
0
ファイル: retry_test.go プロジェクト: peterbourgon/srvproxy
func TestRetryMaxAttempts(t *testing.T) {
	rt := &fixedRoundTripper{failFor: 2}
	c := http.Client{}
	c.Transport = retry.Retry(retry.MaxAttempts(3), retry.Next(rt))

	resp, err := c.Get("http://foo")
	if err != nil {
		t.Fatal(err)
	}

	if want, have := http.StatusTeapot, resp.StatusCode; want != have {
		t.Fatalf("want %v, have %v", want, have)
	}

	if want, have := 3, rt.count; want != have {
		t.Errorf("want %v, have %v", want, have)
	}
}
コード例 #26
0
ファイル: type.go プロジェクト: wweir/goquery
// NewDocument is a Document constructor that takes a string URL as argument.
// You can also add a string proxy after this URL. If you have no proxy, add
// nothing. If you set more than two arguments, it use the second as a proxy.
// It loads the specified document, parses it, and stores the root Document
// node, ready to be manipulated.
func NewDocument(URL string, proxy ...string) (*Document, error) {
	var conn *http.Client = http.DefaultClient
	//Generate a proxy
	if len(proxy) != 0 && proxy[0] != "" {
		proxyUrl, e := url.Parse(proxy[0])
		if e != nil {
			return nil, e
		}
		conn.Transport = &http.Transport{
			Proxy: http.ProxyURL(proxyUrl),
		}
	}
	// Load the URL
	res, e := conn.Get(URL)
	if e != nil {
		return nil, e
	}
	return NewDocumentFromResponse(res)
}
コード例 #27
0
ファイル: proxy.go プロジェクト: ando-masaki/proxy
func (p *Proxy) Test(client *http.Client, URL string) error {
	transport, err := p.Transport()
	if err != nil {
		return err
	}
	client.Transport = transport
	req, err := http.NewRequest("GET", URL, nil)
	if err != nil {
		return err
	}
	req.Header.Add("User-Agent", "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_11_0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/46.0.2490.80 Safari/537.36")
	resp, err := client.Do(req)
	if err != nil {
		return err
	}
	io.Copy(os.Stdout, resp.Body)
	fmt.Println("")
	return nil
}
コード例 #28
0
ファイル: client.go プロジェクト: cilium-team/cilium
// NewClient creates and returns a client that will send requests to host, using the
// http.Client httpCli with transport and httpHeaders.
func NewClient(host string, transport *http.Transport) (*Client, error) {

	var (
		httpCli        *http.Client
		protoAddrParts = strings.SplitN(host, "://", 2)
		proto, addr    string
	)

	if len(protoAddrParts) != 2 {
		return nil, fmt.Errorf("invalid host format '%s'", host)
	} else {
		proto, addr = protoAddrParts[0], protoAddrParts[1]
	}

	switch proto {
	case "tcp":
		if _, err := url.Parse("tcp://" + addr); err != nil {
			return nil, err
		}
		addr = "http://" + addr
	case "http":
		addr = "http://" + addr
	}

	transport = configureTransport(transport, proto, addr)

	if httpCli != nil {
		httpCli.Transport = transport
	} else {
		httpCli = &http.Client{Transport: transport}
	}

	r := resty.New().SetTransport(transport).SetScheme("http").SetCloseConnection(true)
	if proto != "unix" {
		r.SetHostURL(addr)
	}

	log.Debugf("Client talking with host: %s", host)
	return &Client{
		r,
	}, nil
}
コード例 #29
0
ファイル: hue.go プロジェクト: keep94/gohue
// NewContextWithOptions creates a new Context instance.
// ipAddress is the private ip address of the hue bridge, but could be a
// DNS name.
// userId is the user Id / developer Id (See hue documentation).
// options contains optional settings for the created context.
func NewContextWithOptions(
	ipAddress, userId string, options *Options) *Context {
	if options == nil {
		options = kDefaultOptions
	}
	allUrl := &url.URL{
		Scheme: "http",
		Host:   ipAddress,
		Path:   fmt.Sprintf("/api/%s/groups/0/action", userId),
	}
	var client http.Client
	if options.Timeout > 0 {
		client.Transport = &http.Transport{Dial: timeoutDialer(options.Timeout)}
	}
	return &Context{
		ipAddress: ipAddress,
		userId:    userId,
		allUrl:    allUrl,
		client:    &client}
}
コード例 #30
0
// NewProxy constructs a new proxy.  The provided http RoundTripper will be
// used to fetch remote URLs.  If nil is provided, http.DefaultTransport will
// be used.
func NewProxy(transport http.RoundTripper, cache Cache) *Proxy {
	if transport == nil {
		transport = http.DefaultTransport
	}
	if cache == nil {
		cache = NopCache
	}

	client := new(http.Client)
	client.Transport = &httpcache.Transport{
		Transport:           &TransformingTransport{transport, client},
		Cache:               cache,
		MarkCachedResponses: true,
	}

	return &Proxy{
		Client: client,
		Cache:  cache,
	}
}