Exemplo n.º 1
0
// Render updates the given destinationPath according to the given template and options.
// Returns true if the file was created or changed, false if nothing has changed.
func Render(templateName, destinationPath string, options interface{}, destinationFileMode os.FileMode) (bool, error) {
	asset, err := Asset(templateName)
	if err != nil {
		return false, maskAny(err)
	}

	// parse template
	var tmpl *template.Template
	tmpl = template.New(templateName)
	funcMap := template.FuncMap{
		"escape": escape,
		"quote":  strconv.Quote,
	}
	tmpl.Funcs(funcMap)
	_, err = tmpl.Parse(string(asset))
	if err != nil {
		return false, maskAny(err)
	}
	// execute template to buffer
	buf := &bytes.Buffer{}
	tmpl.Funcs(funcMap)
	err = tmpl.Execute(buf, options)
	if err != nil {
		return false, maskAny(err)
	}

	// Update file
	changed, err := util.UpdateFile(destinationPath, buf.Bytes(), destinationFileMode)
	return changed, maskAny(err)
}
Exemplo n.º 2
0
func createDockerConfig(rootConfigPath string, deps service.ServiceDependencies, flags *service.ServiceFlags) (bool, error) {
	if flags.Docker.PrivateRegistryPassword != "" && flags.Docker.PrivateRegistryUrl != "" && flags.Docker.PrivateRegistryUserName != "" {
		deps.Logger.Info("creating %s", rootConfigPath)
		// Load config file
		cf := ConfigFile{
			AuthConfigs: make(map[string]AuthConfig),
		}

		// Set authentication entries
		cf.AuthConfigs[flags.Docker.PrivateRegistryUrl] = AuthConfig{
			Auth: encodeAuth(AuthConfig{
				Username: flags.Docker.PrivateRegistryUserName,
				Password: flags.Docker.PrivateRegistryPassword,
				Email:    "",
			}),
		}

		// Save
		os.MkdirAll(filepath.Dir(rootConfigPath), 0700)
		raw, err := json.MarshalIndent(cf, "", "\t")
		if err != nil {
			return false, maskAny(err)
		}
		changed, err := util.UpdateFile(rootConfigPath, raw, 0600)
		return changed, maskAny(err)
	} else {
		deps.Logger.Warning("Skip creating .docker config")
	}

	return false, nil
}
Exemplo n.º 3
0
Arquivo: fleet.go Projeto: pulcy/gluon
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)
}
Exemplo n.º 4
0
Arquivo: proxy.go Projeto: pulcy/gluon
func updateNoProxy(path, noProxy string, deps service.ServiceDependencies, flags *service.ServiceFlags) error {
	deps.Logger.Info("updating %s", path)
	if _, err := os.Stat(path); os.IsNotExist(err) {
		return nil
	}

	origContent, err := ioutil.ReadFile(path)
	if err != nil {
		return maskAny(err)
	}
	lines := strings.Split(string(origContent), "\n")
	updatedLines := []string{}
	for _, line := range lines {
		line = strings.TrimSpace(line)
		if !strings.HasPrefix(strings.ToUpper(line), noProxyPrefix) && line != "" {
			updatedLines = append(updatedLines, line)
		}
	}
	updatedLines = append(updatedLines, noProxyPrefix+noProxy)

	newContent := strings.Join(updatedLines, "\n")
	if _, err := util.UpdateFile(path, []byte(newContent), fileMode); err != nil {
		return maskAny(err)
	}
	return nil
}
Exemplo n.º 5
0
Arquivo: etcd2.go Projeto: pulcy/gluon
func createEtcd2Conf(deps service.ServiceDependencies, cfg etcdConfig) (bool, error) {
	if cfg.ClusterIP == "" {
		return false, maskAny(fmt.Errorf("ClusterIP empty"))
	}
	deps.Logger.Info("creating %s", confPath)

	lines := []string{
		"[Service]",
		"Environment=ETCD_PEER_AUTO_TLS=true",
		"Environment=ETCD_LISTEN_PEER_URLS=" + cfg.ListenPeerURLs,
		"Environment=ETCD_LISTEN_CLIENT_URLS=" + cfg.ListenClientURLs,
		"Environment=ETCD_INITIAL_CLUSTER=" + cfg.InitialCluster,
		"Environment=ETCD_INITIAL_CLUSTER_STATE=" + cfg.ClusterState,
		"Environment=ETCD_INITIAL_ADVERTISE_PEER_URLS=" + cfg.AdvertisePeerURLs,
		"Environment=ETCD_ADVERTISE_CLIENT_URLS=" + cfg.AdvertiseClientURLs,
	}
	if cfg.Name != "" {
		lines = append(lines, "Environment=ETCD_NAME="+cfg.Name)
	}
	if cfg.IsProxy {
		lines = append(lines, "Environment=ETCD_PROXY=on")
	}

	changed, err := util.UpdateFile(confPath, []byte(strings.Join(lines, "\n")), configFileMode)
	return changed, maskAny(err)
}
Exemplo n.º 6
0
// create/update /home/core/bin/docker-cleanup.sh
func createDockerCleanup(deps service.ServiceDependencies, flags *service.ServiceFlags) (bool, error) {
	deps.Logger.Info("creating %s", cleanupPath)
	asset, err := templates.Asset(cleanupSource)
	if err != nil {
		return false, maskAny(err)
	}

	changed, err := util.UpdateFile(cleanupPath, asset, scriptFileMode)
	return changed, maskAny(err)
}
Exemplo n.º 7
0
Arquivo: rkt.go Projeto: pulcy/gluon
func createTmpFilesConf(deps service.ServiceDependencies, flags *service.ServiceFlags) (bool, error) {
	deps.Logger.Info("creating %s", tmpFilesConfPath)
	asset, err := templates.Asset(tmpFilesConfSource)
	if err != nil {
		return false, maskAny(err)
	}

	changed, err := util.UpdateFile(tmpFilesConfPath, asset, 0644)
	return changed, maskAny(err)

}
Exemplo n.º 8
0
func createJournalConf(deps service.ServiceDependencies, flags *service.ServiceFlags) (bool, error) {
	lines := []string{
		"[Unit]",
		"Description=Journal Gateway Service Socket",
		"Documentation=man:systemd-journal-gatewayd(8)",
		"",
		"[Socket]",
		"ListenStream=[::1]:19531",
		"",
		"[Install]",
		"WantedBy=sockets.target",
	}

	changed, err := util.UpdateFile(socketPath, []byte(strings.Join(lines, "\n")), configFileMode)
	return changed, maskAny(err)
}
Exemplo n.º 9
0
Arquivo: rkt.go Projeto: pulcy/gluon
func createPrivateRegistryAuthConf(deps service.ServiceDependencies, flags *service.ServiceFlags) (bool, error) {
	if flags.Docker.PrivateRegistryPassword != "" && flags.Docker.PrivateRegistryUrl != "" && flags.Docker.PrivateRegistryUserName != "" {
		deps.Logger.Info("creating %s", privateRegistryAuthConfPath)
		// Create config
		/*	{
			"rktKind": "auth",
			"rktVersion": "v1",
			"domains": ["coreos.com", "tectonic.com"],
			"type": "basic",
			"credentials": {
				"user": "******",
				"password": "******"
			}
		}*/
		cf := struct {
			Kind        string   `json:"rktKind"`
			Version     string   `json:"rktVersion"`
			Registries  []string `json:"registries"`
			Type        string   `json:"type"`
			Credentials struct {
				User     string `json:"user"`
				Password string `json:"password"`
			} `json:"credentials"`
		}{
			Kind:       "dockerAuth",
			Version:    "v1",
			Registries: []string{flags.Docker.PrivateRegistryUrl},
			Type:       "basic",
		}
		cf.Credentials.User = flags.Docker.PrivateRegistryUserName
		cf.Credentials.Password = flags.Docker.PrivateRegistryPassword

		// Save
		os.MkdirAll(filepath.Dir(privateRegistryAuthConfPath), 0700)
		raw, err := json.MarshalIndent(cf, "", "\t")
		if err != nil {
			return false, maskAny(err)
		}
		changed, err := util.UpdateFile(privateRegistryAuthConfPath, raw, 0600)
		return changed, maskAny(err)
	} else {
		deps.Logger.Warningf("Skip creating %s", privateRegistryAuthConfPath)
	}

	return false, nil
}
Exemplo n.º 10
0
func updateContent(path, content string, fileMode os.FileMode) (bool, error) {
	content = strings.TrimSpace(content)
	os.MkdirAll(filepath.Dir(path), 0755)
	changed, err := util.UpdateFile(path, []byte(content), fileMode)
	return changed, maskAny(err)
}