func (publisher *BeatPublisher) PublishTopology(params ...string) error { localAddrs := params if len(params) == 0 { addrs, err := common.LocalIPAddrsAsStrings(false) if err != nil { logp.Err("Getting local IP addresses fails with: %s", err) return err } localAddrs = addrs } if publisher.TopologyOutput != nil { debug("Add topology entry for %s: %s", publisher.name, localAddrs) err := publisher.TopologyOutput.PublishIPs(publisher.name, localAddrs) if err != nil { return err } } return nil }
func (publisher *BeatPublisher) init( beatName string, beatVersion string, configs map[string]*common.Config, shipper ShipperConfig, processors *processors.Processors, ) error { var err error publisher.Processors = processors publisher.disabled = *publishDisabled if publisher.disabled { logp.Info("Dry run mode. All output types except the file based one are disabled.") } shipper.InitShipperConfig() publisher.geoLite = common.LoadGeoIPData(shipper.Geoip) publisher.wsPublisher.Init() publisher.wsOutput.Init() if !publisher.disabled { plugins, err := outputs.InitOutputs(beatName, configs, shipper.TopologyExpire) if err != nil { return err } var outputers []*outputWorker var topoOutput outputs.TopologyOutputer for _, plugin := range plugins { output := plugin.Output config := plugin.Config debug("Create output worker") outputers = append(outputers, newOutputWorker( config, output, &publisher.wsOutput, *shipper.QueueSize, *shipper.BulkQueueSize)) if ok, _ := config.Bool("save_topology", 0); !ok { continue } topo, ok := output.(outputs.TopologyOutputer) if !ok { logp.Err("Output type %s does not support topology logging", plugin.Name) return errors.New("Topology output not supported") } if topoOutput != nil { logp.Err("Multiple outputs defined to store topology. " + "Please add save_topology = true option only for one output.") return errors.New("Multiple outputs defined to store topology") } topoOutput = topo logp.Info("Using %s to store the topology", plugin.Name) } publisher.Output = outputers publisher.TopologyOutput = topoOutput } if !publisher.disabled { if len(publisher.Output) == 0 { logp.Info("No outputs are defined. Please define one under the output section.") return errors.New("No outputs are defined. Please define one under the output section.") } if publisher.TopologyOutput == nil { logp.Debug("publish", "No output is defined to store the topology. The server fields might not be filled.") } } publisher.shipperName = shipper.Name publisher.hostname, err = os.Hostname() publisher.version = beatVersion if err != nil { return err } if len(publisher.shipperName) > 0 { publisher.name = publisher.shipperName } else { publisher.name = publisher.hostname } logp.Info("Publisher name: %s", publisher.name) publisher.globalEventMetadata = shipper.EventMetadata //Store the publisher's IP addresses publisher.IPAddrs, err = common.LocalIPAddrsAsStrings(false) if err != nil { logp.Err("Failed to get local IP addresses: %s", err) return err } if !publisher.disabled && publisher.TopologyOutput != nil { RefreshTopologyFreq := 10 * time.Second if shipper.RefreshTopologyFreq != 0 { RefreshTopologyFreq = shipper.RefreshTopologyFreq } publisher.RefreshTopologyTimer = time.Tick(RefreshTopologyFreq) logp.Info("Topology map refreshed every %s", RefreshTopologyFreq) // register shipper and its public IP addresses err = publisher.PublishTopology() if err != nil { logp.Err("Failed to publish topology: %s", err) return err } // update topology periodically go publisher.UpdateTopologyPeriodically() } publisher.pipelines.async = newAsyncPipeline(publisher, *shipper.QueueSize, *shipper.BulkQueueSize, &publisher.wsPublisher) publisher.pipelines.sync = newSyncPipeline(publisher, *shipper.QueueSize, *shipper.BulkQueueSize) return nil }