调试huawei obs go 程序为何没有使用http_proxy?

obs go

https://github.com/huaweicloud/huaweicloud-sdk-go-obs/tree/master

// New creates a new ObsClient instance.
func New(ak, sk, endpoint string, configurers ...configurer) (*ObsClient, error) {
	conf := &config{endpoint: endpoint}
	conf.securityProviders = make([]securityProvider, 0, 3)
	conf.securityProviders = append(conf.securityProviders, NewBasicSecurityProvider(ak, sk, ""))

	conf.maxRetryCount = -1
	conf.maxRedirectCount = -1
	for _, configurer := range configurers {
		configurer(conf)
	}

	if err := conf.initConfigWithDefault(); err != nil {
		return nil, err
	}
	err := conf.getTransport()
	if err != nil {
		return nil, err
	}
    //....
}
func (conf *config) getTransport() error {
	if conf.transport == nil {
		conf.transport = &http.Transport{
			Dial: func(network, addr string) (net.Conn, error) {
				conn, err := net.DialTimeout(network, addr, time.Second*time.Duration(conf.connectTimeout))
				if err != nil {
					return nil, err
				}
				return getConnDelegate(conn, conf.socketTimeout, conf.finalTimeout), nil
			},
			MaxIdleConns:          conf.maxConnsPerHost,
			MaxIdleConnsPerHost:   conf.maxConnsPerHost,
			ResponseHeaderTimeout: time.Second * time.Duration(conf.headerTimeout),
			IdleConnTimeout:       time.Second * time.Duration(conf.idleConnTimeout),
			DisableKeepAlives:     conf.disableKeepAlive,
		}
		if conf.proxyURL != "" {
			conf.transport.Proxy = conf.customProxyFromEnvironment
		} else if conf.proxyFromEnv {
			conf.transport.Proxy = http.ProxyFromEnvironment                 //需要设置conf.proxyFromEnv
		}

		tlsConfig := &tls.Config{InsecureSkipVerify: !conf.sslVerify}
		if conf.sslVerify && conf.pemCerts != nil {
			pool := x509.NewCertPool()
			pool.AppendCertsFromPEM(conf.pemCerts)
			tlsConfig.RootCAs = pool
		}

		conf.transport.TLSClientConfig = tlsConfig
		conf.transport.DisableCompression = !conf.enableCompression
	}

	return nil
}

func newDownloadSample(ak, sk, endpoint, bucketName, objectKey, location string) *DownloadSample {
	obsClient, err := obs.New(ak, sk, endpoint)
	if err != nil {
		panic(err)
	}
	return &DownloadSample{obsClient: obsClient, bucketName: bucketName, objectKey: objectKey, location: location}
}

在 obs.New 之后可以加一个打印：

obsClient.conf.proxyURL,
obsClient.conf.noProxyURL,
obsClient.conf.proxyFromEnv

func WithProxyUrl(proxyURL string) configurer {
	return func(conf *config) {
		conf.proxyURL = proxyURL
	}
}

// WithNoProxyUrl is a configurer for ObsClient to set HTTP no_proxy.
func WithNoProxyUrl(noProxyURL string) configurer {
	return func(conf *config) {
		conf.noProxyURL = noProxyURL
	}
}

当要使用代理时，需要这样去显示的定义obsclient

obsClient, err := obs.New(ak, sk, endpoint, obs.WithProxyUrl("http://xxxx:YYYY"),obs.WithNoProxyUrl(""))

python sdk 没有问题吗？

https://github.com/huaweicloud/huaweicloud-sdk-python-obs/tree/master

我看代码，不会读取os env : http_proxy

class _BasicClient(object):
    def __init__(self, access_key_id='', secret_access_key='', is_secure=True, server=None,
                 signature='obs', region='region', path_style=False, ssl_verify=False,
                 port=None, max_retry_count=3, timeout=60, chunk_size=const.READ_ONCE_LENGTH,
                 long_conn_mode=False, proxy_host=None, proxy_port=None,
                 proxy_username=None, proxy_password=None, security_token=None,
                 custom_ciphers=None, use_http2=False, is_signature_negotiation=True, is_cname=False,
                 max_redirect_count=10, security_providers=None, security_provider_policy=None, client_mode='obs',
                 use_http_conns=False, pool_size=const.CONNECTION_POOL_SIZE, trust_env=False):
        self.securityProvider = _SecurityProvider(access_key_id, secret_access_key, security_token)
        server = server if server is not None else ''
        server = util.to_string(util.safe_encode(server))

        _server = urlparse(server)

        hostname = self._parse_server_hostname(_server)
        is_secure = self._check_server_secure(_server, is_secure)
        host_port, port = self._split_host_port(hostname, port)
        self.security_provider_policy = security_provider_policy
        self._parse_security_providers(security_providers)

        self.is_secure = is_secure
        self.server = host_port[0]

        path_style = self._check_path_style(path_style)
        self.signature = util.to_string(util.safe_encode(signature))
        self.region = region
        self.path_style = path_style
        self.ssl_verify = ssl_verify
        self.calling_format = self._parse_calling_format()
        self.port = self._parse_port(port, is_secure)

        if timeout is None:
            raise Exception('timeout can not be None')
        self.max_retry_count = max_retry_count
        self.timeout = timeout
        self.chunk_size = chunk_size
        self.log_client = NoneLogClient()
        self.use_http2 = use_http2
        self.is_signature_negotiation = is_signature_negotiation
        self.is_cname = is_cname
        self.max_redirect_count = max_redirect_count

        if client_mode == 'obs':
            if self.path_style or self.is_cname:
                self.is_signature_negotiation = False
                if self.signature == 'obs':
                    self.signature = 'v2'
        elif client_mode == 'workflow':
            self.is_signature_negotiation = False

        self.context = None
        if self.is_secure:
            if self.use_http2:
                from obs import http2
                self.context = http2._get_ssl_context(self.ssl_verify)
            else:
                self._init_ssl_context(custom_ciphers)

        self.long_conn_mode = long_conn_mode
        self.use_http_conns = use_http_conns
        self.connHolder = None
        if self.long_conn_mode and not self.use_http_conns:
            self._init_connHolder()

        self.proxy_host = proxy_host
        self.proxy_port = proxy_port
        self.proxy_username = proxy_username
        self.proxy_password = proxy_password

问题： 为何obsutils 可以读取http_proxy环境变量？

https://github.com/huaweicloud/huaweicloud-obs-obsutil.git

func createObsClient(suffix string, autoChooseSecurityProvider bool) (*obs.ObsClient, error) {
	connectTimeout := assist.StringToInt(config["connectTimeout"], defaultConnectTimeout)
	socketTimeout := assist.StringToInt(config["socketTimeout"], defaultSocketTimeout)
	maxRetryCount := assist.StringToInt(config["maxRetryCount"], defaultMaxRetryCount)
	maxConnections := assist.StringToInt(config["maxConnections"], defaultMaxConnections)

	endpoint := strings.TrimSpace(config["endpoint"+suffix])
	if endpoint == "" {
		endpoint = defaultEndpoint
	}

	proxyUrl := strings.TrimSpace(config["proxyUrl"])
	if proxyUrl == "" {
		proxyUrl = strings.TrimSpace(os.Getenv("HTTPS_PROXY"))
		if proxyUrl == "" {
			proxyUrl = strings.TrimSpace(os.Getenv("HTTP_PROXY"))
		}
	}
    //

}