func ImportKey(do *definitions.Do) error {
do.Name = "keys"
do.Operations.ContainerNumber = 1
if err := srv.EnsureRunning(do); err != nil {
return err
}
do.Operations.Interactive = false
dir := path.Join(ErisContainerRoot, "keys", "data", do.Address)
do.Operations.Args = []string{"mkdir", dir} //need to mkdir for import
if err := srv.ExecService(do); err != nil {
return err
}
//src on host
if do.Source == "" {
do.Source = filepath.Join(KeysPath, "data", do.Address, do.Address)
}
//dest in container
do.Destination = dir
if err := data.ImportData(do); err != nil {
return err
}
return nil
}
func MakeGenesisFile(do *def.Do) error {
//otherwise it'll start its own keys server that won't have the key needed...
do.Name = "keys"
IfExit(srv.EnsureRunning(do))
doThr := def.NowDo()
doThr.Chain.ChainType = "throwaway" //for teardown
doThr.Name = "default"
doThr.Operations.ContainerNumber = 1
doThr.Operations.PublishAllPorts = true
logger.Infof("Starting chain from MakeGenesisFile =>\t%s\n", doThr.Name)
if er := StartChain(doThr); er != nil {
return fmt.Errorf("error starting chain %v\n", er)
}
doThr.Operations.Args = []string{"mintgen", "known", do.Chain.Name, fmt.Sprintf("--pub=%s", do.Pubkey)}
doThr.Chain.Name = "default" //for teardown
// pipe this output to /chains/chainName/genesis.json
err := ExecChain(doThr)
if err != nil {
logger.Printf("exec chain err: %v\nCleaning up...\n", err)
doThr.Rm = true
doThr.RmD = true
if err := CleanUp(doThr); err != nil {
return err
}
}
doThr.Rm = true
doThr.RmD = true
return CleanUp(doThr) // doesn't clean up keys but that's ~ ok b/c it's about to be used...
}
func ensureRunning() {
doNow := definitions.NowDo()
doNow.Name = "ipfs"
err := services.EnsureRunning(doNow)
if err != nil {
fmt.Printf("Failed to ensure IPFS is running: %v", err)
return
}
logger.Infoln("IPFS is running.")
}
func ConvertKey(do *definitions.Do) error {
do.Name = "keys"
if err := srv.EnsureRunning(do); err != nil {
return err
}
do.Operations.Args = []string{"mintkey", "mint", do.Address}
if err := srv.ExecService(do); err != nil {
return err
}
return nil
}
func GenerateKey(do *definitions.Do) error {
do.Name = "keys"
do.Operations.ContainerNumber = 1
if err := srv.EnsureRunning(do); err != nil {
return err
}
do.Operations.Interactive = false
do.Operations.Args = []string{"eris-keys", "gen", "--no-pass"}
if err := srv.ExecService(do); err != nil {
return err
}
return nil
}
func GetPubKey(do *definitions.Do) error {
do.Name = "keys"
do.Operations.ContainerNumber = 1
if err := srv.EnsureRunning(do); err != nil {
return err
}
do.Operations.Interactive = false
do.Operations.Args = []string{"eris-keys", "pub", "--addr", do.Address}
if err := srv.ExecService(do); err != nil {
return err
}
return nil
}
func GetFiles(do *definitions.Do) error {
doNow := definitions.NowDo()
doNow.Name = "ipfs"
err := services.EnsureRunning(doNow)
if err != nil {
return err
}
logger.Infoln("IPFS is running.")
logger.Debugf("Gonna Import a file =>\t\t%s:%v\n", do.Name, do.Path)
err = importFile(do.Name, do.Path)
if err != nil {
return err
}
do.Result = "success"
return nil
}
func ListPinned(do *definitions.Do) error {
var hash string
doNow := definitions.NowDo()
doNow.Name = "ipfs"
err := services.EnsureRunning(doNow)
if err != nil {
return err
}
logger.Infoln("IPFS is running.")
logger.Debugf("Listing files pinned locally")
hash, err = listPinned()
if err != nil {
return err
}
do.Result = hash
return nil
}
func ListFiles(do *definitions.Do) error {
var hash string
doNow := definitions.NowDo()
doNow.Name = "ipfs"
err := services.EnsureRunning(doNow)
if err != nil {
return err
}
logger.Infoln("IPFS is running.")
logger.Debugf("Gonna List an object =>\t\t%s:%v\n", do.Name, do.Path)
hash, err = listFile(do.Name)
if err != nil {
return err
}
do.Result = hash
return nil
}
func ListKeys(do *definitions.Do) error {
if do.Host {
keysPath := filepath.Join(KeysPath, "data")
addrs, err := ioutil.ReadDir(keysPath)
if err != nil {
return err
}
hostAddrs := make([]string, len(addrs))
for i, addr := range addrs {
hostAddrs[i] = addr.Name()
}
do.Result = strings.Join(hostAddrs, ",")
log.WithField("=>", hostAddrs[0]).Warn("The keys on your host kind marmot:")
hostAddrs = append(hostAddrs[:0], hostAddrs[1:]...)
for _, addr := range hostAddrs {
log.WithField("=>", addr).Warn()
}
}
if do.Container {
keysOut := new(bytes.Buffer)
config.GlobalConfig.Writer = keysOut
do.Name = "keys"
do.Operations.ContainerNumber = 1
if err := srv.EnsureRunning(do); err != nil {
return err
}
do.Operations.Interactive = false
do.Operations.Args = []string{"ls", "/home/eris/.eris/keys/data"}
if err := srv.ExecService(do); err != nil {
return err
}
keysOutString := strings.Split(util.TrimString(string(keysOut.Bytes())), "\n")
do.Result = strings.Join(keysOutString, ",")
log.WithField("=>", keysOutString[0]).Warn("The keys in your container kind marmot:")
keysOutString = append(keysOutString[:0], keysOutString[1:]...)
for _, addr := range keysOutString {
log.WithField("=>", addr).Warn()
}
}
return nil
}
func ExportKey(do *definitions.Do) error {
do.Name = "keys"
do.Operations.ContainerNumber = 1
if err := srv.EnsureRunning(do); err != nil {
return err
}
//destination on host
if do.Destination == "" {
do.Destination = filepath.Join(KeysPath, "data")
}
//src in container
do.Source = path.Join(ErisContainerRoot, "keys", "data", do.Address)
if err := data.ExportData(do); err != nil {
return err
}
return nil
}
// export a chain definition file
func ExportChain(do *definitions.Do) error {
chain, err := loaders.LoadChainDefinition(do.Name, false, do.Operations.ContainerNumber)
if err != nil {
return err
}
if IsChainExisting(chain) {
doNow := definitions.NowDo()
doNow.Name = "ipfs"
services.EnsureRunning(doNow)
hash, err := exportFile(do.Name)
if err != nil {
return err
}
log.Warn(hash)
} else {
return fmt.Errorf(`I don't known of that chain.
Please retry with a known chain.
To find known chains use: eris chains ls --known`)
}
return nil
}
func EnsureService(cmd *cobra.Command, args []string) {
IfExit(ArgCheck(1, "ge", cmd, args))
do.Name = args[0]
IfExit(srv.EnsureRunning(do))
}