func (d *RawExecDriver) Fingerprint(cfg *config.Config, node *structs.Node) (bool, error) { // Check that the user has explicitly enabled this executor. enabled := cfg.ReadBoolDefault(rawExecConfigOption, false) if enabled { d.logger.Printf("[WARN] driver.raw_exec: raw exec is enabled. Only enable if needed") node.Attributes["driver.raw_exec"] = "1" return true, nil } return false, nil }
// Fingerprint fingerprints the lxc driver configuration func (d *LxcDriver) Fingerprint(cfg *config.Config, node *structs.Node) (bool, error) { enabled := cfg.ReadBoolDefault(lxcConfigOption, true) if !enabled && !cfg.DevMode { return false, nil } version := lxc.Version() if version == "" { return false, nil } node.Attributes["driver.lxc.version"] = version node.Attributes["driver.lxc"] = "1" return true, nil }
func (d *RawExecDriver) Fingerprint(cfg *config.Config, node *structs.Node) (bool, error) { // Get the current status so that we can log any debug messages only if the // state changes _, currentlyEnabled := node.Attributes[rawExecDriverAttr] // Check that the user has explicitly enabled this executor. enabled := cfg.ReadBoolDefault(rawExecConfigOption, false) if enabled { if currentlyEnabled { d.logger.Printf("[WARN] driver.raw_exec: raw exec is enabled. Only enable if needed") } node.Attributes[rawExecDriverAttr] = "1" return true, nil } delete(node.Attributes, rawExecDriverAttr) return false, nil }
func consulContext(clientConfig *config.Config, containerID string) *executor.ConsulContext { cfg := consul.ConsulConfig{ Addr: clientConfig.ReadDefault("consul.address", "127.0.0.1:8500"), Token: clientConfig.Read("consul.token"), Auth: clientConfig.Read("consul.auth"), EnableSSL: clientConfig.ReadBoolDefault("consul.ssl", false), VerifySSL: clientConfig.ReadBoolDefault("consul.verifyssl", true), CAFile: clientConfig.Read("consul.tls_ca_file"), CertFile: clientConfig.Read("consul.tls_cert_file"), KeyFile: clientConfig.Read("consul.tls_key_file"), } return &executor.ConsulContext{ ConsulConfig: &cfg, ContainerID: containerID, DockerEndpoint: clientConfig.Read("docker.endpoint"), TLSCa: clientConfig.Read("docker.tls.ca"), TLSCert: clientConfig.Read("docker.tls.cert"), TLSKey: clientConfig.Read("docker.tls.key"), } }
// templateRunner returns a consul-template runner for the given templates and a // lookup by destination to the template. If no templates are given, a nil // template runner and lookup is returned. func templateRunner(tmpls []*structs.Template, config *config.Config, vaultToken, taskDir string, taskEnv *env.TaskEnvironment) ( *manager.Runner, map[string][]*structs.Template, error) { if len(tmpls) == 0 { return nil, nil, nil } runnerConfig, err := runnerConfig(config, vaultToken) if err != nil { return nil, nil, err } // Parse the templates allowAbs := config.ReadBoolDefault(hostSrcOption, true) ctmplMapping, err := parseTemplateConfigs(tmpls, taskDir, taskEnv, allowAbs) if err != nil { return nil, nil, err } // Set the config flat := make([]*ctconf.ConfigTemplate, 0, len(ctmplMapping)) for ctmpl := range ctmplMapping { local := ctmpl flat = append(flat, &local) } runnerConfig.ConfigTemplates = flat runner, err := manager.NewRunner(runnerConfig, false, false) if err != nil { return nil, nil, err } // Build the lookup idMap := runner.ConfigTemplateMapping() lookup := make(map[string][]*structs.Template, len(idMap)) for id, ctmpls := range idMap { for _, ctmpl := range ctmpls { templates := lookup[id] templates = append(templates, ctmplMapping[ctmpl]) lookup[id] = templates } } return runner, lookup, nil }