Allow users to specify outputs as lists

This will provide the ability to specify multiple outputs for a single
type of output.

In essence, allowing this:

[outputs]

[[outputs.influxdb]]
  urls = ["udp://localhost:8089"]
  database = "udp-telegraf"

[[outputs.influxdb]]
  urls = ["http://myhost:8086"]
  database = "telegraf"

[[outputs.kafka]]
  brokers = ["192.168.99.100:9092"]
  topic = "telegraf"

closes #335

agent.go

@@ -147,17 +147,12 @@ func (a *Agent) Close() error {
 func (a *Agent) LoadOutputs(filters []string, config *Config) ([]string, error) {
 	var names []string
 
-	for _, name := range config.OutputsDeclared() {
-		creator, ok := outputs.Outputs[name]
-		if !ok {
-			return nil, fmt.Errorf("Undefined but requested output: %s", name)
-		}
+	for name, output := range config.OutputsDeclared() {
 
 		if sliceContains(name, filters) || len(filters) == 0 {
 			if a.Debug {
 				log.Println("Output Enabled: ", name)
 			}
-			output := creator()
 
 			err := config.ApplyOutput(name, output)
 			if err != nil {

config.go

@@ -166,13 +166,8 @@ func (c *Config) PluginsDeclared() []string {
 }
 
 // OutputsDeclared returns the name of all outputs declared in the config.
-func (c *Config) OutputsDeclared() []string {
-	var names []string
-	for name := range c.outputs {
-		names = append(names, name)
-	}
-	sort.Strings(names)
-	return names
+func (c *Config) OutputsDeclared() map[string]outputs.Output {
+	return c.outputs
 }
 
 // ListTags returns a string of tags specified in the config,
@@ -394,20 +389,24 @@ func findField(fieldName string, value reflect.Value) reflect.Value {
 	return reflect.Value{}
 }
 
-// A very limited merge. Merges the fields named in the fields parameter, replacing most values, but appending to arrays.
+// A very limited merge. Merges the fields named in the fields parameter,
+// replacing most values, but appending to arrays.
 func mergeStruct(base, overlay interface{}, fields []string) error {
 	baseValue := reflect.ValueOf(base).Elem()
 	overlayValue := reflect.ValueOf(overlay).Elem()
 	if baseValue.Kind() != reflect.Struct {
-		return fmt.Errorf("Tried to merge something that wasn't a struct: type %v was %v", baseValue.Type(), baseValue.Kind())
+		return fmt.Errorf("Tried to merge something that wasn't a struct: type %v was %v",
+			baseValue.Type(), baseValue.Kind())
 	}
 	if baseValue.Type() != overlayValue.Type() {
-		return fmt.Errorf("Tried to merge two different types: %v and %v", baseValue.Type(), overlayValue.Type())
+		return fmt.Errorf("Tried to merge two different types: %v and %v",
+			baseValue.Type(), overlayValue.Type())
 	}
 	for _, field := range fields {
 		overlayFieldValue := findField(field, overlayValue)
 		if !overlayFieldValue.IsValid() {
-			return fmt.Errorf("could not find field in %v matching %v", overlayValue.Type(), field)
+			return fmt.Errorf("could not find field in %v matching %v",
+				overlayValue.Type(), field)
 		}
 		baseFieldValue := findField(field, baseValue)
 		if overlayFieldValue.Kind() == reflect.Slice {
@@ -536,13 +535,22 @@ func LoadConfig(path string) (*Config, error) {
 			}
 		case "outputs":
 			for outputName, outputVal := range subtbl.Fields {
-				outputSubtbl, ok := outputVal.(*ast.Table)
-				if !ok {
-					return nil, err
-				}
-				err = c.parseOutput(outputName, outputSubtbl)
-				if err != nil {
-					return nil, err
+				switch outputSubtbl := outputVal.(type) {
+				case *ast.Table:
+					err = c.parseOutput(outputName, outputSubtbl, 0)
+					if err != nil {
+						return nil, err
+					}
+				case []*ast.Table:
+					for id, t := range outputSubtbl {
+						err = c.parseOutput(outputName, t, id)
+						if err != nil {
+							return nil, err
+						}
+					}
+				default:
+					return nil, fmt.Errorf("Unsupported config format: %s",
+						outputName)
 				}
 			}
 		default:
@@ -579,7 +587,7 @@ func (c *Config) parseAgent(agentAst *ast.Table) error {
 }
 
 // Parse an output config out of the given *ast.Table.
-func (c *Config) parseOutput(name string, outputAst *ast.Table) error {
+func (c *Config) parseOutput(name string, outputAst *ast.Table, id int) error {
 	c.outputFieldsSet[name] = extractFieldNames(outputAst)
 	creator, ok := outputs.Outputs[name]
 	if !ok {
@@ -590,7 +598,7 @@ func (c *Config) parseOutput(name string, outputAst *ast.Table) error {
 	if err != nil {
 		return err
 	}
-	c.outputs[name] = output
+	c.outputs[fmt.Sprintf("%s-%d", name, id)] = output
 	return nil
 }