func newRoundTripper(config *Config, tls *transport.TLSConfig) (*http.Transport, error) {
var proxy func(*http.Request) (*url.URL, error)
if config.ProxyURL != "" {
url, err := url.Parse(config.ProxyURL)
if err != nil {
return nil, err
}
proxy = http.ProxyURL(url)
}
dialer := transport.NetDialer(config.Timeout)
tlsDialer, err := transport.TLSDialer(dialer, tls, config.Timeout)
if err != nil {
return nil, err
}
return &http.Transport{
Proxy: proxy,
Dial: dialer.Dial,
DialTLS: tlsDialer.Dial,
DisableKeepAlives: true,
}, nil
}
func NewClient(
esURL, index string, proxyURL *url.URL, tls *tls.Config,
username, password string,
params map[string]string,
timeout time.Duration,
compression int,
onConnectCallback connectCallback,
) (*Client, error) {
proxy := http.ProxyFromEnvironment
if proxyURL != nil {
proxy = http.ProxyURL(proxyURL)
}
logp.Info("Elasticsearch url: %s", esURL)
dialer := transport.NetDialer(timeout)
dialer = transport.StatsDialer(dialer, &transport.IOStats{
Read: statReadBytes,
Write: statWriteBytes,
ReadErrors: statReadErrors,
WriteErrors: statWriteErrors,
})
bulkRequ, err := newBulkRequest(esURL, "", "", params, nil)
if err != nil {
return nil, err
}
var encoder bodyEncoder
if compression == 0 {
encoder = newJSONEncoder(nil)
} else {
encoder, err = newGzipEncoder(compression, nil)
if err != nil {
return nil, err
}
}
client := &Client{
Connection: Connection{
URL: esURL,
Username: username,
Password: password,
http: &http.Client{
Transport: &http.Transport{
Dial: dialer.Dial,
TLSClientConfig: tls,
Proxy: proxy,
},
Timeout: timeout,
},
encoder: encoder,
},
index: index,
params: params,
bulkRequ: bulkRequ,
compressionLevel: compression,
proxyURL: proxyURL,
}
client.Connection.onConnectCallback = func() error {
if onConnectCallback != nil {
return onConnectCallback(client)
}
return nil
}
return client, nil
}
func NewClient(
s ClientSettings,
onConnectCallback connectCallback,
) (*Client, error) {
proxy := http.ProxyFromEnvironment
if s.Proxy != nil {
proxy = http.ProxyURL(s.Proxy)
}
pipeline := s.Pipeline
if pipeline != nil && pipeline.IsEmpty() {
pipeline = nil
}
logp.Info("Elasticsearch url: %s", s.URL)
// TODO: add socks5 proxy support
var dialer, tlsDialer transport.Dialer
var err error
dialer = transport.NetDialer(s.Timeout)
tlsDialer, err = transport.TLSDialer(dialer, s.TLS, s.Timeout)
if err != nil {
return nil, err
}
iostats := &transport.IOStats{
Read: statReadBytes,
Write: statWriteBytes,
ReadErrors: statReadErrors,
WriteErrors: statWriteErrors,
}
dialer = transport.StatsDialer(dialer, iostats)
tlsDialer = transport.StatsDialer(tlsDialer, iostats)
params := s.Parameters
bulkRequ, err := newBulkRequest(s.URL, "", "", params, nil)
if err != nil {
return nil, err
}
var encoder bodyEncoder
compression := s.CompressionLevel
if compression == 0 {
encoder = newJSONEncoder(nil)
} else {
encoder, err = newGzipEncoder(compression, nil)
if err != nil {
return nil, err
}
}
client := &Client{
Connection: Connection{
URL: s.URL,
Username: s.Username,
Password: s.Password,
http: &http.Client{
Transport: &http.Transport{
Dial: dialer.Dial,
DialTLS: tlsDialer.Dial,
Proxy: proxy,
},
Timeout: s.Timeout,
},
encoder: encoder,
},
tlsConfig: s.TLS,
index: s.Index,
pipeline: pipeline,
params: params,
bulkRequ: bulkRequ,
compressionLevel: compression,
proxyURL: s.Proxy,
}
client.Connection.onConnectCallback = func() error {
if onConnectCallback != nil {
return onConnectCallback(client)
}
return nil
}
return client, nil
}
func UDPDialer(name string, to time.Duration) NetDialer {
return NetDialer{name, transport.NetDialer(to)}
}