Golang db.Conn函数代码示例

func getProviderName(host string) (*global.PredefClouds, error) {
	pdc := &global.PredefClouds{}

	conn, err := db.Conn(PREDEFCLOUDSBUCKET)

	if err != nil {
		return pdc, err
	}

	ferr := conn.FetchStruct(host, pdc)
	if ferr != nil {
		return pdc, ferr
	}

	sshkeyerr := downloadSshFiles(pdc, "key", 0600)
	if sshkeyerr != nil {
		return pdc, sshkeyerr
	}
	sshpuberr := downloadSshFiles(pdc, "pub", 0644)
	if sshpuberr != nil {
		return pdc, sshpuberr
	}

	return pdc, nil
}

func (self *Server) Checker() {
	log.Info("verifying rabbitmq")
	factor, err := amqp.Factory()
	if err != nil {
		log.Error("Error: %v\nFailed to get the queue", err)
	}

	_, connerr := factor.Dial()
	if connerr != nil {
		fmt.Fprintf(os.Stderr, "Error: %v\n Please start rabbitmq service.\n", connerr)
		os.Exit(1)
	}
	log.Info("rabbitmq connected [ok]")

	log.Info("verifying riak")

	rconn, rerr := db.Conn("connection")
	if rerr != nil {
		fmt.Fprintf(os.Stderr, "Error: %v\n Please start Riak service.\n", rerr)
		os.Exit(1)
	}

	data := "sampledata"
	ferr := rconn.StoreObject("sampleobject", data)
	if ferr != nil {
		fmt.Fprintf(os.Stderr, "Error: %v\n Please start Riak service.\n", ferr)
		os.Exit(1)
	}
	defer rconn.Close()
	log.Info("riak connected [ok]")

}

func updateIndex(ip string, pos uint) error {

	index := global.IPIndex{}
	res, err := index.Get(global.IPINDEXKEY)
	if err != nil {
		log.Error("Error: Riak didn't cooperate:\n%s.", err)
		return err
	}

	update := global.IPIndex{
		Ip:     ip,
		Subnet: res.Subnet,
		Index:  pos,
	}

	conn, connerr := db.Conn("ipindex")
	if connerr != nil {
		log.Error("Failed to riak connection : %s", connerr)
		return connerr
	}

	serr := conn.StoreStruct(global.IPINDEXKEY, &update)
	if serr != nil {
		log.Error("Failed to store the update index value : %s", serr)
		return serr
	}
	log.Info("Docker network index update was successfully.")
	return nil
}

func getProviderName(host string) (*global.PredefClouds, error) {
	pdc := &global.PredefClouds{}

	predefBucket, perr := config.GetString("riak:predefclouds")
	if perr != nil {
		return pdc, perr
	}
	conn, err := db.Conn(predefBucket)

	if err != nil {
		return pdc, err
	}

	ferr := conn.FetchStruct(host, pdc)
	if ferr != nil {
		return pdc, ferr
	}

	sshkeyerr := downloadSshFiles(pdc, "key", 0600)
	if sshkeyerr != nil {
		return pdc, sshkeyerr
	}
	sshpuberr := downloadSshFiles(pdc, "pub", 0644)
	if sshpuberr != nil {
		return pdc, sshpuberr
	}

	return pdc, nil
}

/*
*
* UpdateComponent updates the ipaddress that is bound to the container
* It talks to riakdb and updates the respective component(s)
 */
func updatecomponent(assembly *global.AssemblyWithComponents, ipaddress string, id string, port string) {
	log.Debug("Update process for component with ip and container id")
	mySlice := make([]*global.KeyValuePair, 3)
	mySlice[0] = &global.KeyValuePair{Key: "ip", Value: ipaddress}
	mySlice[1] = &global.KeyValuePair{Key: "id", Value: id}
	mySlice[2] = &global.KeyValuePair{Key: "port", Value: port}

	update := global.Component{
		Id:                assembly.Components[0].Id,
		Name:              assembly.Components[0].Name,
		ToscaType:         assembly.Components[0].ToscaType,
		Inputs:            assembly.Components[0].Inputs,
		Outputs:           mySlice,
		Artifacts:         assembly.Components[0].Artifacts,
		RelatedComponents: assembly.Components[0].RelatedComponents,
		Operations:        assembly.Components[0].Operations,
		Status:            assembly.Components[0].Status,
		CreatedAt:         assembly.Components[0].CreatedAt,
	}

	conn, connerr := db.Conn("components")
	if connerr != nil {
		log.Error("Failed to riak connection : %s", connerr)
	}

	err := conn.StoreStruct(assembly.Components[0].Id, &update)
	if err != nil {
		log.Error("Failed to store the update component data : %s", err)
	}
	log.Info("Container component update was successfully.")
}

func (asm *Assembly) GetAssemblyWithComponents(asmId string) (*AssemblyWithComponents, error) {
	log.Info("Get Assembly message %v", asmId)
	var j = -1
	asmresult := &AssemblyWithComponents{}
	conn, err := db.Conn("assembly")
	if err != nil {
		return asmresult, err
	}
	//appout := &Requests{}
	ferr := conn.FetchStruct(asmId, asm)
	if ferr != nil {
		return asmresult, ferr
	}
	var arraycomponent = make([]*Component, len(asm.Components))
	for i := range asm.Components {
		t := strings.TrimSpace(asm.Components[i])
		if len(t) > 1 {
			componentID := asm.Components[i]
			component := Component{Id: componentID}
			com, err := component.Get(componentID)
			if err != nil {
				log.Error("Error: Riak didn't cooperate:\n%s.", err)
				return asmresult, err
			}
			j++
			arraycomponent[j] = com
		}
	}
	result := &AssemblyWithComponents{Id: asm.Id, Name: asm.Name, ToscaType: asm.ToscaType, Components: arraycomponent, Requirements: asm.Requirements, Policies: asm.Policies, Inputs: asm.Inputs, Outputs: asm.Outputs, Operations: asm.Operations, Status: asm.Status, CreatedAt: asm.CreatedAt}
	defer conn.Close()
	return result, nil
}

func downloadSshFiles(pdc *global.PredefClouds, keyvalue string, permission os.FileMode) error {
	sa := make([]string, 2)
	sa = strings.Split(pdc.Access.IdentityFile, "_")
	email, name := sa[0], sa[1]
	ssh := &db.SshObject{}
	sshBucket, serr := config.GetString("riak:ssh_files")
	if serr != nil {
		return serr
	}
	conn, err := db.Conn(sshBucket)
	if err != nil {
		return err
	}

	ferr := conn.FetchObject(pdc.Access.IdentityFile+"_"+keyvalue, ssh)
	if ferr != nil {
		return ferr
	}
	cloudkeysBucket, ckberr := config.GetString("riak:cloud_keys")
	if ckberr != nil {
		return ckberr
	}

	megam_home, ckberr := config.GetString("megam_home")
	if ckberr != nil {
		return ckberr
	}

	basePath := megam_home + cloudkeysBucket
	dir := path.Join(basePath, email)
	filePath := path.Join(dir, name+"."+keyvalue)
	if _, err := os.Stat(dir); os.IsNotExist(err) {
		fmt.Printf("no such file or directory: %s", dir)

		if errm := os.MkdirAll(dir, 0777); errm != nil {
			return errm
		}
		// open output file
		_, err := os.Create(filePath)
		if err != nil {
			return err
		}
	}
	errf := ioutil.WriteFile(filePath, []byte(ssh.Data), permission)
	if errf != nil {
		return errf
	}
	return nil
}

/**
**fetch the ip index data from riak and parse the json to struct
**/
func (req *IPIndex) Get(key string) (*IPIndex, error) {
	log.Info("Get IPIndex value %v", key)
	conn, err := db.Conn("ipindex")
	if err != nil {
		return req, err
	}
	ferr := conn.FetchStruct(key, req)
	if ferr != nil {
		return req, ferr
	}
	defer conn.Close()

	return req, nil

}

func GetAccessKeys(pdc *global.PredefClouds) (*AccessKeys, error) {
	keys := &AccessKeys{}

	conn, err := db.Conn(CLOUDACCESSKEYSBUCKET)
	if err != nil {
		return keys, err
	}

	ferr := conn.FetchStruct(pdc.Access.VaultLocation, keys)
	if ferr != nil {
		return keys, ferr
	}

	return keys, nil
}

func GetPredefClouds(host string) (*global.PredefClouds, error) {
	pdc := &global.PredefClouds{}

	conn, err := db.Conn(PREDEFCLOUDSBUCKET)

	if err != nil {
		return pdc, err
	}

	ferr := conn.FetchStruct(host, pdc)
	if ferr != nil {
		return pdc, ferr
	}
	return pdc, nil
}

func GetAccessKeys(pdc *global.PredefClouds) (*AccessKeys, error) {
	keys := &AccessKeys{}
	cakbBucket, cakberr := config.GetString("riak:cloud_access_keys")
	if cakberr != nil {
		return keys, cakberr
	}

	conn, err := db.Conn(cakbBucket)
	if err != nil {
		return keys, err
	}

	ferr := conn.FetchStruct(pdc.Access.VaultLocation, keys)
	if ferr != nil {
		return keys, ferr
	}

	return keys, nil
}

func GetPredefClouds(host string) (*global.PredefClouds, error) {
	pdc := &global.PredefClouds{}

	predefBucket, perr := config.GetString("riak:predefclouds")
	if perr != nil {
		return pdc, perr
	}
	conn, err := db.Conn(predefBucket)

	if err != nil {
		return pdc, err
	}

	ferr := conn.FetchStruct(host, pdc)
	if ferr != nil {
		return pdc, ferr
	}
	return pdc, nil
}

func (self *Server) IPInit() {

	rconn, rerr := db.Conn("ipindex")
	if rerr != nil {
		fmt.Fprintf(os.Stderr, "Error: %v\n Please start Riak service.\n", rerr)
		os.Exit(1)
	}

	index := global.IPIndex{}
	subnet, _ := config.GetString("swarm:subnet")
	_, err := index.Get(global.IPINDEXKEY)
	if err != nil {
		data := &global.IPIndex{Ip: subnet, Subnet: subnet, Index: 1}
		res2B, _ := json.Marshal(data)
		ferr := rconn.StoreObject(global.IPINDEXKEY, string(res2B))
		if ferr != nil {
			fmt.Fprintf(os.Stderr, "Error: %v\n Please start Riak service.\n", ferr)
			os.Exit(1)
		}
	}

	defer rconn.Close()
}

}

var updateStatus = action.Action{
	Name: "updatestatus",
	Forward: func(ctx action.FWContext) (action.Result, error) {
		var app global.AssemblyWithComponents
		switch ctx.Params[0].(type) {
		case global.AssemblyWithComponents:
			app = ctx.Params[0].(global.AssemblyWithComponents)
		case *global.AssemblyWithComponents:
			app = *ctx.Params[0].(*global.AssemblyWithComponents)
		default:
			return nil, errors.New("First parameter must be App or *global.AssemblyWithComponents.")
		}
		asm := &global.Assembly{}
		conn, err := db.Conn("assembly")
		if err != nil {
			return nil, err
		}

		ferr := conn.FetchStruct(app.Id, asm)
		if ferr != nil {
			return nil, ferr
		}

		update := global.Assembly{
			Id:           asm.Id,
			JsonClaz:     asm.JsonClaz,
			Name:         asm.Name,
			Components:   asm.Components,
			ToscaType:    asm.ToscaType,

func uploadENVVariables(asm *global.AssemblyWithComponents, com *global.Component) error {
	megam_home, ckberr := config.GetString("megam_home")
	if ckberr != nil {
		return ckberr
	}

	conn, err := db.Conn("assemblies")
	if err != nil {
		return err
	}

	act_id, actberr := config.GetString("account_id")
	if actberr != nil {
		return actberr
	}

	arr, ferr := conn.FetchObjectByIndex("assemblies", ASSEMBLIESINDEX, act_id, "", "")
	if ferr != nil {
		return ferr
	}

	for i := range arr {
		s := global.BytesToString(arr[i])
		rassemblies := &global.Assemblies{}
		rams, ramserr := rassemblies.Get(s)
		if ramserr != nil {
			return ramserr
		}
		for l := range rams.Assemblies {
			if len(rams.Assemblies[l]) > 0 {
				assembly := global.Assembly{Id: rams.Assemblies[l]}
				rasm, rasmerr := assembly.GetAssemblyWithComponents(rams.Assemblies[l])
				if rasmerr != nil {
					log.Error("Error: Riak didn't cooperate:\n%s.", rasmerr)
					return rasmerr
				}

				for j := range com.RelatedComponents {
					if len(com.RelatedComponents[j]) > 0 {
						rasmname := strings.Split(com.RelatedComponents[j], "/")
						assemblyname := strings.Split(rasmname[0], ".")[0]
						if rasm.Name == assemblyname {
							for rc := range rasm.Components {
								if rasm.Components[rc] != nil {
									if rasmname[1] == rasm.Components[rc].Name {
										basePath := megam_home
										dir := path.Join(basePath, com.Name)
										filePath := path.Join(dir, "env.sh")
										if _, err := os.Stat(dir); os.IsNotExist(err) {
											fmt.Printf("no such file or directory: %s", dir)

											if errm := os.MkdirAll(dir, 0777); errm != nil {
												return errm
											}
											// open output file
											_, err := os.Create(filePath)
											if err != nil {
												return err
											}
										}

										str := "BINDED_HOST_NAME=" + rasm.Components[rc].Name + "\n" + "HOST=" + rasm.Name + "." + GetParsedValue(rasm.Inputs, "domain") + "\n" + "\nDBNAME=" + com.Name + "\n" + "PORT=" + GetParsedValue(rasm.Components[rc].Inputs, "port") + "\nUSERNAME=" + GetParsedValue(rasm.Components[rc].Inputs, "username") + "\nPASSWORD=" + GetParsedValue(rasm.Components[rc].Inputs, "password") + "\nDBUSER=" + GetParsedValue(rasm.Components[rc].Inputs, "username") + "\nDBPASSWORD=" + GetParsedValue(rasm.Components[rc].Inputs, "dbpassword") + "\n"
										errf := ioutil.WriteFile(filePath, []byte(str), 0644)
										if errf != nil {
											return errf
										}
										//return nil
									}
								}
							}
						}
					}
				}
			}
		}
	}

	return nil
}