Golang tcp.CreateGoTlsConfig函數代碼示例

func (o *HttpOutput) Init(config interface{}) (err error) {
	o.HttpOutputConfig = config.(*HttpOutputConfig)
	if o.url, err = url.Parse(o.Address); err != nil {
		return fmt.Errorf("Can't parse URL '%s': %s", o.Address, err.Error())
	}
	if o.url.Scheme != "http" && o.url.Scheme != "https" {
		return errors.New("`address` must contain an absolute http or https URL.")
	}
	o.Method = strings.ToUpper(o.Method)
	if o.Method != "POST" && o.Method != "GET" && o.Method != "PUT" {
		return errors.New("HTTP Method must be POST, GET, or PUT.")
	}
	if o.Method != "GET" {
		o.sendBody = true
	}
	o.client = new(http.Client)
	if o.HttpTimeout > 0 {
		o.client.Timeout = time.Duration(o.HttpTimeout) * time.Millisecond
	}
	if o.Username != "" || o.Password != "" {
		o.useBasicAuth = true
	}
	if o.url.Scheme == "https" {
		transport := &http.Transport{}
		if transport.TLSClientConfig, err = tcp.CreateGoTlsConfig(&o.Tls); err != nil {
			return fmt.Errorf("TLS init error: %s", err.Error())
		}
		o.client.Transport = transport
	}
	return
}

func (ao *AMQPOutput) Init(config interface{}) (err error) {
	conf := config.(*AMQPOutputConfig)
	ao.config = conf
	var tlsConf *tls.Config = nil
	if strings.HasPrefix(conf.URL, "amqps://") && &ao.config.Tls != nil {
		if tlsConf, err = tcp.CreateGoTlsConfig(&ao.config.Tls); err != nil {
			return fmt.Errorf("TLS init error: %s", err)
		}
	}

	var dialer = NewAMQPDialer(tlsConf)
	if ao.amqpHub == nil {
		ao.amqpHub = GetAmqpHub()
	}
	ch, usageWg, connectionWg, err := ao.amqpHub.GetChannel(conf.URL, dialer)
	if err != nil {
		return
	}
	ao.connWg = connectionWg
	ao.usageWg = usageWg
	closeChan := make(chan *amqp.Error)
	ao.closeChan = ch.NotifyClose(closeChan)
	err = ch.ExchangeDeclare(conf.Exchange, conf.ExchangeType,
		conf.ExchangeDurability, conf.ExchangeAutoDelete, false, false,
		nil)
	if err != nil {
		usageWg.Done()
		return
	}
	ao.ch = ch
	return
}

func (output *NsqOutput) SetNsqConfig(conf *NsqOutputConfig) (err error) {
	nsqConfig := nsq.NewConfig()
	if conf.ReadTimeout != nil {
		nsqConfig.ReadTimeout = time.Duration(*conf.ReadTimeout) * time.Millisecond
	}
	if conf.WriteTimeout != nil {
		nsqConfig.WriteTimeout = time.Duration(*conf.WriteTimeout) * time.Millisecond
	}
	if conf.ClientID != nil {
		nsqConfig.ClientID = *conf.ClientID
	}
	if conf.Hostname != nil {
		nsqConfig.Hostname = *conf.Hostname
	}
	if conf.UserAgent != nil {
		nsqConfig.UserAgent = *conf.UserAgent
	}
	if conf.HeartbeatInterval != nil {
		nsqConfig.HeartbeatInterval = time.Duration(*conf.HeartbeatInterval) * time.Millisecond
	}
	if conf.Deflate != nil {
		nsqConfig.Deflate = *conf.Deflate
	}
	if conf.DeflateLevel != nil {
		nsqConfig.DeflateLevel = *conf.DeflateLevel
	}
	if conf.Snappy != nil {
		nsqConfig.Snappy = *conf.Snappy
	}
	if conf.OutputBufferSize != nil {
		nsqConfig.OutputBufferSize = *conf.OutputBufferSize
	}
	if conf.OutputBufferTimeout != nil {
		nsqConfig.OutputBufferTimeout = time.Duration(*conf.OutputBufferTimeout) * time.Millisecond
	}
	if conf.MaxInFlight != nil {
		nsqConfig.MaxInFlight = *conf.MaxInFlight
	}
	if conf.MaxBackoffDuration != nil {
		nsqConfig.MaxBackoffDuration = time.Duration(*conf.MaxBackoffDuration) * time.Millisecond
	}
	if conf.MsgTimeout != nil {
		nsqConfig.MsgTimeout = time.Duration(*conf.MsgTimeout) * time.Millisecond
	}
	if conf.AuthSecret != nil {
		nsqConfig.AuthSecret = *conf.AuthSecret
	}

	// Tls
	if conf.UseTls {
		tls, err := tcp.CreateGoTlsConfig(&conf.Tls)
		if err != nil {
			return err
		}
		output.config.TlsConfig = tls
	}
	output.config = nsqConfig

	return
}

func (n *NagiosOutput) Init(config interface{}) (err error) {
	n.conf = config.(*NagiosOutputConfig)

	n.submitter = n.submitSendNsca
	if n.conf.SendNscaBin == "" {
		// HTTP is implied.
		n.submitter = n.submitHttp

		rht := time.Duration(n.conf.ResponseHeaderTimeout) * time.Second
		transport := &http.Transport{
			Proxy: http.ProxyFromEnvironment,
			ResponseHeaderTimeout: rht,
		}
		if n.conf.UseTls {
			var tlsConf *tls.Config
			if tlsConf, err = tcp.CreateGoTlsConfig(&n.conf.Tls); err != nil {
				return fmt.Errorf("TLS init error: %s", err)
			}
			transport.TLSClientConfig = tlsConf
		}
		n.client = &http.Client{
			Transport: transport,
		}
	}
	return
}

func (o *ElasticSearchOutput) Init(config interface{}) (err error) {
	o.conf = config.(*ElasticSearchOutputConfig)

	o.batchChan = make(chan ESBatch)
	o.backChan = make(chan []byte, 2)
	o.recvChan = make(chan MsgPack, 100)

	var serverUrl *url.URL
	if serverUrl, err = url.Parse(o.conf.Server); err == nil {
		var scheme string = strings.ToLower(serverUrl.Scheme)
		switch scheme {
		case "http", "https":
			var tlsConf *tls.Config = nil
			if scheme == "https" && &o.conf.Tls != nil {
				if tlsConf, err = tcp.CreateGoTlsConfig(&o.conf.Tls); err != nil {
					return fmt.Errorf("TLS init error: %s", err)
				}
			}

			o.bulkIndexer = NewHttpBulkIndexer(scheme, serverUrl.Host, serverUrl.Path,
				o.conf.FlushCount, o.conf.Username, o.conf.Password, o.conf.HTTPTimeout,
				o.conf.HTTPDisableKeepalives, o.conf.ConnectTimeout, tlsConf)
		case "udp":
			o.bulkIndexer = NewUDPBulkIndexer(serverUrl.Host, o.conf.FlushCount)
		default:
			err = errors.New("Server URL must specify one of `udp`, `http`, or `https`.")
		}
	} else {
		err = fmt.Errorf("Unable to parse ElasticSearch server URL [%s]: %s", o.conf.Server, err)
	}
	return
}

func (ai *AMQPInput) Init(config interface{}) (err error) {
	conf := config.(*AMQPInputConfig)
	ai.config = conf
	var tlsConf *tls.Config = nil
	if strings.HasPrefix(conf.URL, "amqps://") && &ai.config.Tls != nil {
		if tlsConf, err = tcp.CreateGoTlsConfig(&ai.config.Tls); err != nil {
			return fmt.Errorf("TLS init error: %s", err)
		}
	}

	if ai.amqpHub == nil {
		ai.amqpHub = getAmqpHub()
	}
	var dialer = AMQPDialer{tlsConf}
	ch, usageWg, connWg, err := ai.amqpHub.GetChannel(conf.URL, dialer)
	if err != nil {
		return
	}

	var args amqp.Table

	ttl := conf.QueueTTL

	if ttl != -1 {
		args = amqp.Table{"x-message-ttl": int32(ttl)}
	}

	defer func() {
		if err != nil {
			usageWg.Done()
		}
	}()
	ai.connWg = connWg
	ai.usageWg = usageWg
	err = ch.ExchangeDeclare(conf.Exchange, conf.ExchangeType,
		conf.ExchangeDurability, conf.ExchangeAutoDelete, false, false,
		nil)
	if err != nil {
		return
	}
	ai.ch = ch
	_, err = ch.QueueDeclare(conf.Queue, conf.QueueDurability,
		conf.QueueAutoDelete, conf.QueueExclusive, false, args)
	if err != nil {
		return
	}
	err = ch.QueueBind(conf.Queue, conf.RoutingKey, conf.Exchange, false, nil)
	if err != nil {
		return
	}
	err = ch.Qos(conf.PrefetchCount, 0, false)
	if err != nil {
		return
	}
	return
}

func (t *TcpInput) setupTls(tomlConf *tcp.TlsConfig) (err error) {
	if tomlConf.CertFile == "" || tomlConf.KeyFile == "" {
		return errors.New("TLS config requires both cert_file and key_file value.")
	}
	var goConf *tls.Config
	if goConf, err = tcp.CreateGoTlsConfig(tomlConf); err == nil {
		t.listener = tls.NewListener(t.listener, goConf)
	}
	return
}

func createSender(test FloodTest) (sender *client.NetworkSender, err error) {
	if test.UseTls {
		var goTlsConfig *tls.Config
		goTlsConfig, err = tcp.CreateGoTlsConfig(&test.Tls)
		if err != nil {
			return
		}
		sender, err = client.NewTlsSender(test.Sender, test.IpAddress, goTlsConfig)
	} else {
		sender, err = client.NewNetworkSender(test.Sender, test.IpAddress)
	}
	return
}

func (o *ElasticSearchOutput) Init(config interface{}) (err error) {
	o.conf = config.(*ElasticSearchOutputConfig)

	if !o.conf.UseBuffering {
		o.batchChan = make(chan ESBatch)
		o.backChan = make(chan []byte, 2)
	}

	o.outputExit = make(chan error)

	var serverUrl *url.URL
	if serverUrl, err = url.Parse(o.conf.Server); err == nil {
		var scheme string = strings.ToLower(serverUrl.Scheme)
		switch scheme {
		case "http", "https":
			var tlsConf *tls.Config = nil
			if scheme == "https" && &o.conf.Tls != nil {
				if tlsConf, err = tcp.CreateGoTlsConfig(&o.conf.Tls); err != nil {
					return fmt.Errorf("TLS init error: %s", err)
				}
			}

			o.bulkIndexer = NewHttpBulkIndexer(scheme, serverUrl.Host,
				o.conf.FlushCount, o.conf.Username, o.conf.Password, o.conf.HTTPTimeout,
				o.conf.HTTPDisableKeepalives, o.conf.ConnectTimeout, tlsConf)
		case "udp":
			o.bulkIndexer = NewUDPBulkIndexer(serverUrl.Host, o.conf.FlushCount)
		default:
			err = errors.New("Server URL must specify one of `udp`, `http`, or `https`.")
		}
	} else {
		err = fmt.Errorf("Unable to parse ElasticSearch server URL [%s]: %s", o.conf.Server, err)
	}
	switch o.conf.QueueFullAction {
	case "shutdown", "drop", "block":
	default:
		return fmt.Errorf("`queue_full_action` must be 'shutdown', 'drop', or 'block', got %s",
			o.conf.QueueFullAction)
	}
	return
}

// NewIrcConn creates an *irc.Connection. It handles using Heka's tcp plugin to
// create a cryto/tls config
func NewIrcConn(config *IrcOutputConfig) (IrcConnection, error) {
	conn := irc.IRC(config.Nick, config.Ident)
	if conn == nil {
		return nil, errors.New("Nick or Ident cannot be blank")
	}
	if config.Server == "" {
		return nil, errors.New("Irc server cannot be blank.")
	}
	if len(config.Channels) < 1 {
		return nil, errors.New("Need at least 1 channel to join.")
	}
	var tlsConf *tls.Config = nil
	var err error = nil
	if tlsConf, err = tcp.CreateGoTlsConfig(&config.Tls); err != nil {
		return nil, fmt.Errorf("TLS init error: %s", err)
	}
	conn.UseTLS = config.UseTLS
	conn.TLSConfig = tlsConf
	conn.Password = config.Password
	conn.Timeout = time.Duration(config.Timeout) * time.Second
	conn.VerboseCallbackHandler = config.VerboseIRCLogging
	return conn, nil
}

func main() {
	configFile := flag.String("config", "flood.toml", "Heka Flood configuration file")
	configTest := flag.String("test", "default", "Test section to load")

	flag.Parse()

	if flag.NFlag() == 0 {
		flag.PrintDefaults()
		os.Exit(0)
	}

	var config FloodConfig
	if _, err := toml.DecodeFile(*configFile, &config); err != nil {
		client.LogError.Printf("Error decoding config file: %s", err)
		return
	}
	var test FloodTest
	var ok bool
	if test, ok = config[*configTest]; !ok {
		client.LogError.Printf("Configuration test: '%s' was not found", *configTest)
		return
	}

	if test.MsgInterval != "" {
		var err error
		if test.msgInterval, err = time.ParseDuration(test.MsgInterval); err != nil {
			client.LogError.Printf("Invalid message_interval duration %s: %s", test.MsgInterval,
				err.Error())
			return
		}
	}

	if test.PprofFile != "" {
		profFile, err := os.Create(test.PprofFile)
		if err != nil {
			client.LogError.Fatalln(err)
		}
		pprof.StartCPUProfile(profFile)
		defer pprof.StopCPUProfile()
	}

	if test.MaxMessageSize > 0 {
		message.SetMaxMessageSize(test.MaxMessageSize)
	}

	var sender *client.NetworkSender
	var err error
	if test.UseTls {
		var goTlsConfig *tls.Config
		goTlsConfig, err = tcp.CreateGoTlsConfig(&test.Tls)
		if err != nil {
			client.LogError.Fatalf("Error creating TLS config: %s\n", err)
		}
		sender, err = client.NewTlsSender(test.Sender, test.IpAddress, goTlsConfig)
	} else {
		sender, err = client.NewNetworkSender(test.Sender, test.IpAddress)
	}
	if err != nil {
		client.LogError.Fatalf("Error creating sender: %s\n", err)
	}

	unsignedEncoder := client.NewProtobufEncoder(nil)
	signedEncoder := client.NewProtobufEncoder(&test.Signer)
	oversizedEncoder := &OversizedEncoder{}

	var numTestMessages = 1
	var unsignedMessages [][]byte
	var signedMessages [][]byte
	var oversizedMessages [][]byte

	rdm := &randomDataMaker{
		src:       rand.NewSource(time.Now().UnixNano()),
		asciiOnly: test.AsciiOnly,
	}

	if test.VariableSizeMessages {
		numTestMessages = 64
		unsignedMessages = makeVariableMessage(unsignedEncoder, numTestMessages, rdm, false)
		signedMessages = makeVariableMessage(signedEncoder, numTestMessages, rdm, false)
		oversizedMessages = makeVariableMessage(oversizedEncoder, 1, rdm, true)
	} else {
		if test.StaticMessageSize == 0 {
			test.StaticMessageSize = 1000
		}
		unsignedMessages = makeFixedMessage(unsignedEncoder, test.StaticMessageSize,
			rdm)
		signedMessages = makeFixedMessage(signedEncoder, test.StaticMessageSize,
			rdm)
	}
	// wait for sigint
	sigChan := make(chan os.Signal, 1)
	signal.Notify(sigChan, syscall.SIGINT)
	var msgsSent, bytesSent, msgsDelivered uint64
	var corruptPercentage, lastCorruptPercentage, signedPercentage, lastSignedPercentage, oversizedPercentage, lastOversizedPercentage float64
	var corrupt bool

	// set up counter loop
	ticker := time.NewTicker(time.Duration(time.Second))
	go timerLoop(&msgsSent, &bytesSent, ticker)

//.........這裏部分代碼省略.........

func main() {
	configFile := flag.String("config", "sbmgr.toml", "Sandbox manager configuration file")
	scriptFile := flag.String("script", "xyz.lua", "Sandbox script file")
	scriptConfig := flag.String("scriptconfig", "xyz.toml", "Sandbox script configuration file")
	filterName := flag.String("filtername", "filter", "Sandbox filter name (used on unload)")
	action := flag.String("action", "load", "Sandbox manager action")
	flag.Parse()

	var config SbmgrConfig
	if _, err := toml.DecodeFile(*configFile, &config); err != nil {
		client.LogError.Printf("Error decoding config file: %s", err)
		return
	}
	var sender *client.NetworkSender
	var err error
	if config.UseTls {
		var goTlsConfig *tls.Config
		goTlsConfig, err = tcp.CreateGoTlsConfig(&config.Tls)
		if err != nil {
			client.LogError.Fatalf("Error creating TLS config: %s\n", err)
		}
		sender, err = client.NewTlsSender("tcp", config.IpAddress, goTlsConfig)
	} else {
		sender, err = client.NewNetworkSender("tcp", config.IpAddress)
	}
	if err != nil {
		client.LogError.Fatalf("Error creating sender: %s\n", err.Error())
	}
	encoder := client.NewProtobufEncoder(&config.Signer)
	manager := client.NewClient(sender, encoder)

	hostname, _ := os.Hostname()
	msg := &message.Message{}
	msg.SetLogger(pipeline.HEKA_DAEMON) // identify the message as 'internal' for filtering purposes
	msg.SetType("heka.control.sandbox")
	msg.SetTimestamp(time.Now().UnixNano())
	msg.SetUuid(uuid.NewRandom())
	msg.SetHostname(hostname)

	switch *action {
	case "load":
		code, err := ioutil.ReadFile(*scriptFile)
		if err != nil {
			client.LogError.Printf("Error reading scriptFile: %s\n", err.Error())
			return
		}
		msg.SetPayload(string(code))
		conf, err := ioutil.ReadFile(*scriptConfig)
		if err != nil {
			client.LogError.Printf("Error reading scriptConfig: %s\n", err.Error())
			return
		}
		f, _ := message.NewField("config", string(conf), "toml")
		msg.AddField(f)
	case "unload":
		f, _ := message.NewField("name", *filterName, "")
		msg.AddField(f)
	default:
		client.LogError.Printf("Invalid action: %s", *action)
	}

	f1, _ := message.NewField("action", *action, "")
	msg.AddField(f1)
	err = manager.SendMessage(msg)
	if err != nil {
		client.LogError.Printf("Error sending message: %s\n", err.Error())
	}
}

func (input *NsqInput) SetNsqConfig(conf *NsqInputConfig) (err error) {
	nsqConfig := nsq.NewConfig()

	if conf.LookupdPollInterval != nil {
		nsqConfig.LookupdPollInterval = time.Duration(*conf.LookupdPollInterval) * time.Millisecond
	}
	if conf.LookupdPollJitter != nil {
		nsqConfig.LookupdPollJitter = *conf.LookupdPollJitter
	}
	if conf.MaxRequeueDelay != nil {
		nsqConfig.MaxRequeueDelay = time.Duration(*conf.MaxRequeueDelay) * time.Millisecond
	}
	if conf.DefaultRequeueDelay != nil {
		nsqConfig.DefaultRequeueDelay = time.Duration(*conf.DefaultRequeueDelay) * time.Millisecond
	}
	if conf.BackoffMultiplier != nil {
		nsqConfig.BackoffMultiplier = time.Duration(*conf.BackoffMultiplier) * time.Millisecond
	}
	if conf.MaxAttempts != nil {
		nsqConfig.MaxAttempts = *conf.MaxAttempts
	}
	if conf.LowRdyIdleTimeout != nil {
		nsqConfig.LowRdyIdleTimeout = time.Duration(*conf.LowRdyIdleTimeout) * time.Millisecond
	}
	if conf.SampleRate != nil {
		nsqConfig.SampleRate = *conf.SampleRate
	}

	if conf.ReadTimeout != nil {
		nsqConfig.ReadTimeout = time.Duration(*conf.ReadTimeout) * time.Millisecond
	}
	if conf.WriteTimeout != nil {
		nsqConfig.WriteTimeout = time.Duration(*conf.WriteTimeout) * time.Millisecond
	}
	if conf.ClientID != nil {
		nsqConfig.ClientID = *conf.ClientID
	}
	if conf.Hostname != nil {
		nsqConfig.Hostname = *conf.Hostname
	}
	if conf.UserAgent != nil {
		nsqConfig.UserAgent = *conf.UserAgent
	}
	if conf.HeartbeatInterval != nil {
		nsqConfig.HeartbeatInterval = time.Duration(*conf.HeartbeatInterval) * time.Millisecond
	}
	if conf.Deflate != nil {
		nsqConfig.Deflate = *conf.Deflate
	}
	if conf.DeflateLevel != nil {
		nsqConfig.DeflateLevel = *conf.DeflateLevel
	}
	if conf.Snappy != nil {
		nsqConfig.Snappy = *conf.Snappy
	}
	if conf.OutputBufferSize != nil {
		nsqConfig.OutputBufferSize = *conf.OutputBufferSize
	}
	if conf.OutputBufferTimeout != nil {
		nsqConfig.OutputBufferTimeout = time.Duration(*conf.OutputBufferTimeout) * time.Millisecond
	}
	if conf.MaxInFlight != nil {
		nsqConfig.MaxInFlight = *conf.MaxInFlight
	}
	if conf.MaxBackoffDuration != nil {
		nsqConfig.MaxBackoffDuration = time.Duration(*conf.MaxBackoffDuration) * time.Millisecond
	}
	if conf.MsgTimeout != nil {
		nsqConfig.MsgTimeout = time.Duration(*conf.MsgTimeout) * time.Millisecond
	}
	if conf.AuthSecret != nil {
		nsqConfig.AuthSecret = *conf.AuthSecret
	}

	// Tls
	if conf.UseTls {
		tls, err := tcp.CreateGoTlsConfig(&conf.Tls)
		if err != nil {
			return err
		}
		input.config.TlsConfig = tls
	}
	input.config = nsqConfig

	return
}

func main() {
	configFile := flag.String("config", "sbmgrload.toml", "Sandbox manager load configuration file")
	action := flag.String("action", "load", "load/unload")
	numItems := flag.Int("num", 1, "Number of sandboxes to load/unload")
	flag.Parse()

	code := `
require "string"
require "table"
require "os"

lastTime = os.time() * 1e9
lastCount = 0
count = 0
rate = 0.0
rates = {}

function process_message ()
    count = count + 1
    return 0
end

function timer_event(ns)
    local msgsSent = count - lastCount
    if msgsSent == 0 then return end

    local elapsedTime = ns - lastTime
    if elapsedTime == 0 then return end

    lastCount = count
    lastTime = ns
    rate = msgsSent / (elapsedTime / 1e9)
    rates[#rates+1] = rate
    output(string.format("Got %d messages. %0.2f msg/sec", count, rate))
    inject_message()

    local samples = #rates
    if samples == 10 then -- generate a summary every 10 samples
        table.sort(rates)
	     local min = rates[1]
	     local max = rates[samples]
	     local sum = 0
        for i, val in ipairs(rates) do
            sum = sum + val
	     end
        output(string.format("AGG Sum. Min: %0.2f Max: %0.2f Mean: %0.2f", min, max, sum/samples))
        inject_message()
	     rates = {}
    end
end
`
	confFmt := `
[CounterSandbox%d]
type = "SandboxFilter"
message_matcher = "Type == 'hekabench'"
ticker_interval = 1
script_type = "lua"
filename = ""
preserve_data = true
`

	var config SbmgrConfig
	if _, err := toml.DecodeFile(*configFile, &config); err != nil {
		log.Printf("Error decoding config file: %s", err)
		return
	}
	var sender *client.NetworkSender
	var err error
	if config.UseTls {
		var goTlsConfig *tls.Config
		goTlsConfig, err = tcp.CreateGoTlsConfig(&config.Tls)
		if err != nil {
			log.Fatalf("Error creating TLS config: %s\n", err)
		}
		sender, err = client.NewTlsSender("tcp", config.IpAddress, goTlsConfig)
	} else {
		sender, err = client.NewNetworkSender("tcp", config.IpAddress)
	}
	if err != nil {
		log.Fatalf("Error creating sender: %s\n", err.Error())
	}
	encoder := client.NewProtobufEncoder(&config.Signer)
	manager := client.NewClient(sender, encoder)
	hostname, _ := os.Hostname()

	switch *action {
	case "load":
		for i := 0; i < *numItems; i++ {
			conf := fmt.Sprintf(confFmt, i)
			msg := &message.Message{}
			msg.SetType("heka.control.sandbox")
			msg.SetTimestamp(time.Now().UnixNano())
			msg.SetUuid(uuid.NewRandom())
			msg.SetHostname(hostname)
			msg.SetPayload(code)
			f, _ := message.NewField("config", conf, "toml")
			msg.AddField(f)
			f1, _ := message.NewField("action", *action, "")
			msg.AddField(f1)
			err = manager.SendMessage(msg)
//.........這裏部分代碼省略.........

func (o *InfluxDBOutput) Init(config interface{}) error {
	conf := config.(*InfluxDBOutputConfig)

	serverUrl, err := url.Parse(conf.Server)
	if err != nil {
		return fmt.Errorf("Unable to parse InfluxDB server URL (%s): %s", conf.Server, err)
	}

	switch strings.ToLower(serverUrl.Scheme) {
	case "http", "https":
		serverUrl.Path = path.Join(serverUrl.Path, "db", url.QueryEscape(conf.Database), "series")

		vals := serverUrl.Query()
		vals.Set("time_precision", "u") // microseconds
		if conf.Username != "" {
			vals.Set("u", conf.Username)
		}
		if conf.Password != "" {
			vals.Set("p", conf.Password)
		}
		serverUrl.RawQuery = vals.Encode()
	default:
		return fmt.Errorf("Unable to handle server URL scheme %r", serverUrl.Scheme)
	}
	o.seriesUrl = serverUrl.String()

	transport := &http.Transport{
		Proxy: http.ProxyFromEnvironment,
		ResponseHeaderTimeout: time.Duration(conf.ResponseHeaderTimeout) * time.Second,
	}
	if serverUrl.Scheme == "https" {
		tlsConf, err := hekaTcp.CreateGoTlsConfig(&conf.Tls)
		if err != nil {
			return fmt.Errorf("Error settings TLS configuration: %s", err)
		}
		transport.TLSClientConfig = tlsConf
	}
	o.httpClient = &http.Client{Transport: transport}

	if conf.Series == "" && conf.FieldMap["series"] == "" {
		return fmt.Errorf("Must set series or field_map.series")
	}
	o.series = conf.Series

	if conf.UseHekaTimestamp {
		_, hasTime := conf.FieldMap["time"]
		if !hasTime {
			o.columns = []string{"time"}
			o.columnFields = []string{"_hekaTimestampMicro"}
		}
	}

	for column, field := range conf.FieldMap {
		if column == "series" {
			o.seriesField = field
			continue
		}
		o.columns = append(o.columns, column)
		o.columnFields = append(o.columnFields, field)
	}

	o.flushInterval = time.Duration(conf.FlushInterval) * time.Millisecond
	o.flushCount = conf.FlushCount

	return nil
}