Golang service.ServiceFlags类代码示例

func createService(deps service.ServiceDependencies, flags *service.ServiceFlags) (bool, error) {
	deps.Logger.Info("creating %s", weaveServicePath)
	members, err := flags.GetClusterMembers(deps.Logger)
	if err != nil {
		return false, maskAny(err)
	}
	var peers []string
	for _, m := range members {
		peers = append(peers, m.PrivateHostIP)
	}
	name, err := getPeerName(deps, flags)
	if err != nil {
		return false, maskAny(err)
	}
	opts := struct {
		Seed     string
		Peers    string
		Name     string
		Hostname string
	}{
		Seed:     flags.Weave.Seed,
		Peers:    strings.Join(peers, " "),
		Name:     name,
		Hostname: flags.Weave.Hostname,
	}
	changed, err := templates.Render(weaveServiceTmpl, weaveServicePath, opts, serviceFileMode)
	return changed, maskAny(err)
}

func createFleetConf(deps service.ServiceDependencies, flags *service.ServiceFlags) (bool, error) {
	proxy, err := isEtcdProxy(deps, flags)
	if err != nil {
		return false, maskAny(err)
	}

	members, err := flags.GetClusterMembers(deps.Logger)
	if err != nil {
		deps.Logger.Warning("GetClusterMembers failed: %v", err)
	}
	etcdServers := []string{}
	for _, cm := range members {
		if !cm.EtcdProxy {
			etcdServers = append(etcdServers, fmt.Sprintf("http://%s:2379", cm.ClusterIP))
		}
	}

	lines := []string{
		"[Service]",
		fmt.Sprintf("Environment=FLEET_METADATA=%s", flags.Fleet.Metadata),
		fmt.Sprintf("Environment=FLEET_ETCD_SERVERS=%s", strings.Join(etcdServers, ",")),
		fmt.Sprintf("Environment=FLEET_PUBLIC_IP=%s", flags.Network.ClusterIP),
		fmt.Sprintf("Environment=FLEET_AGENT_TTL=%v", flags.Fleet.AgentTTL),
		fmt.Sprintf("Environment=FLEET_DISABLE_ENGINE=%v", proxy || flags.Fleet.DisableEngine),
		fmt.Sprintf("Environment=FLEET_DISABLE_WATCHES=%v", flags.Fleet.DisableWatches),
		fmt.Sprintf("Environment=FLEET_ENGINE_RECONCILE_INTERVAL=%d", flags.Fleet.EngineReconcileInterval),
		fmt.Sprintf("Environment=FLEET_TOKEN_LIMIT=%d", flags.Fleet.TokenLimit),
	}

	changed, err := util.UpdateFile(confPath, []byte(strings.Join(lines, "\n")), configFileMode)
	return changed, maskAny(err)
}

func (t *gluonService) Setup(deps service.ServiceDependencies, flags *service.ServiceFlags) error {
	if err := flags.SetupDefaults(deps.Logger); err != nil {
		return maskAny(err)
	}
	if flags.Docker.DockerSubnet == "" {
		return errgo.New("docker-subnet is missing")
	}

	changedFlags, err := flags.Save()
	if err != nil {
		return maskAny(err)
	}

	changedService, err := createService(deps, flags)
	if err != nil {
		return maskAny(err)
	}

	if flags.Force || changedFlags || changedService {
		if err := os.Remove(gluonPath); err != nil {
			if !os.IsNotExist(err) {
				return maskAny(err)
			}
		}

		if err := deps.Systemd.Reload(); err != nil {
			return maskAny(err)
		}
		if err := deps.Systemd.Enable(serviceName); err != nil {
			return maskAny(err)
		}
	}

	return nil
}

func createService(deps service.ServiceDependencies, flags *service.ServiceFlags) (bool, error) {
	deps.Logger.Info("creating %s", consulServicePath)
	members, err := flags.GetClusterMembers(deps.Logger)
	if err != nil {
		return false, maskAny(err)
	}
	var join []string
	bootstrapExpect := 0
	for _, m := range members {
		if !m.EtcdProxy {
			bootstrapExpect++
			if m.ClusterIP != flags.Network.ClusterIP {
				join = append(join, fmt.Sprintf("-retry-join %s", m.ClusterIP))
			}
		}
	}
	srv, err := isServer(members, flags)
	if err != nil {
		return false, maskAny(err)
	}
	args := fmt.Sprintf("-advertise=%s %s -client=0.0.0.0 -data-dir=/opt/consul/data", flags.Network.ClusterIP, strings.Join(join, " "))
	if srv {
		args = fmt.Sprintf("-server -bootstrap-expect=%d %s", bootstrapExpect, args)
	}
	opts := struct {
		Flags string
	}{
		Flags: args,
	}
	changed, err := templates.Render(consulServiceTmpl, consulServicePath, opts, serviceFileMode)
	return changed, maskAny(err)
}

func createEtcdConfig(deps service.ServiceDependencies, flags *service.ServiceFlags) (etcdConfig, error) {
	if flags.Network.ClusterIP == "" {
		return etcdConfig{}, maskAny(fmt.Errorf("ClusterIP empty"))
	}

	members, err := flags.GetClusterMembers(deps.Logger)
	if err != nil {
		deps.Logger.Warning("GetClusterMembers failed: %v", err)
	}

	result := etcdConfig{
		ClusterIP: flags.Network.ClusterIP,
	}
	initialCluster := []string{}
	endpoints := []string{}
	hosts := []string{}
	clientPort := 2379
	result.ClusterState = flags.Etcd.ClusterState
	if result.ClusterState == "" {
		result.ClusterState = "new"
	}
	memberIndex := 0
	for index, cm := range members {
		if !cm.EtcdProxy {
			initialCluster = append(initialCluster, fmt.Sprintf("%s=http://%s:2380", cm.MachineID, cm.ClusterIP))
			endpoints = append(endpoints, fmt.Sprintf("http://%s:%d", cm.ClusterIP, clientPort))
			hosts = append(hosts, cm.ClusterIP)
		}
		if cm.ClusterIP == flags.Network.ClusterIP {
			result.Name = cm.MachineID
			result.IsProxy = cm.EtcdProxy
			result.PrivateHostIP = cm.PrivateHostIP
			if cm.EtcdProxy {
				memberIndex = index
			} else {
				memberIndex = len(hosts) - 1
			}
		}
	}

	result.ListenPeerURLs = fmt.Sprintf("https://%s:2381,http://%s:2380", result.PrivateHostIP, flags.Network.ClusterIP)
	result.AdvertisePeerURLs = fmt.Sprintf("https://%s:2381,http://%s:2380", result.PrivateHostIP, flags.Network.ClusterIP)
	result.ListenClientURLs = fmt.Sprintf("http://0.0.0.0:%d,http://0.0.0.0:4001", clientPort)
	result.AdvertiseClientURLs = fmt.Sprintf("http://%s:%d,http://%s:4001", flags.Network.ClusterIP, clientPort, flags.Network.ClusterIP)

	result.InitialCluster = strings.Join(initialCluster, ",")
	result.Endpoints = strings.Join(endpoints, ",")
	result.Host = hosts[memberIndex%len(hosts)]
	result.Port = strconv.Itoa(clientPort)

	return result, nil

}

func isEtcdProxy(deps service.ServiceDependencies, flags *service.ServiceFlags) (bool, error) {
	members, err := flags.GetClusterMembers(deps.Logger)
	if err != nil {
		return false, maskAny(err)
	}
	for _, member := range members {
		if member.ClusterIP == flags.Network.ClusterIP {
			return member.EtcdProxy, nil
		}
	}

	return false, nil
}

func createConfig(deps service.ServiceDependencies, flags *service.ServiceFlags) (bool, error) {
	deps.Logger.Info("creating %s", nomadConfigPath)
	members, err := flags.GetClusterMembers(deps.Logger)
	if err != nil {
		return false, maskAny(err)
	}
	srv, err := isServer(members, flags)
	if err != nil {
		return false, maskAny(err)
	}
	vaultEnv, err := readVaultEnv()
	if err != nil {
		return false, maskAny(err)
	}
	vaultAddress := vaultEnv["VAULT_ADDR"]
	vaultCAFile := vaultEnv["VAULT_CACERT"]
	bootstrapExpect := 0
	for _, m := range members {
		if !m.EtcdProxy {
			bootstrapExpect++
		}
	}
	opts := struct {
		AdvertiseIP     string
		ConsulAddress   string
		MetaLines       []string
		IsServer        bool
		BootstrapExpect int
		HasVault        bool
		VaultAddress    string
		VaultCAFile     string
	}{
		AdvertiseIP:     flags.Network.ClusterIP,
		ConsulAddress:   fmt.Sprintf("%s:8500", flags.Network.ClusterIP),
		IsServer:        srv,
		BootstrapExpect: bootstrapExpect,
		HasVault:        false && vaultAddress != "" && vaultCAFile != "", // Vault token is also needed before we can enable
		VaultAddress:    vaultAddress,
		VaultCAFile:     vaultCAFile,
	}
	metaParts := strings.Split(flags.Fleet.Metadata, ",")
	for _, meta := range metaParts {
		kv := strings.SplitN(meta, "=", 2)
		if len(kv) == 2 {
			opts.MetaLines = append(opts.MetaLines, fmt.Sprintf("\"%s\" = \"%s\"", kv[0], kv[1]))
		}
	}

	changed, err := templates.Render(nomadConfigTmpl, nomadConfigPath, opts, configFileMode)
	return changed, maskAny(err)
}

// createNoProxy creates the value for the no_proxy environment variable.
func createNoProxy(deps service.ServiceDependencies, flags *service.ServiceFlags) (string, error) {
	members, err := flags.GetClusterMembers(deps.Logger)
	if err != nil {
		return "", maskAny(err)
	}
	list := []string{".local", ".private"}
	for _, cm := range members {
		list = append(list, cm.ClusterIP)
		if cm.ClusterIP != cm.PrivateHostIP {
			list = append(list, cm.PrivateHostIP)
		}
	}
	return strings.Join(list, ","), nil
}

func getPeerName(deps service.ServiceDependencies, flags *service.ServiceFlags) (string, error) {
	members, err := flags.GetClusterMembers(deps.Logger)
	if err != nil {
		return "", maskAny(err)
	}
	for _, member := range members {
		if member.ClusterIP == flags.Network.ClusterIP {
			name, err := util.WeaveNameFromMachineID(member.MachineID)
			if err != nil {
				return "", maskAny(err)
			}
			return name, nil
		}
	}

	return "", nil
}