diff --git a/ethereal/config.go b/ethereal/config.go deleted file mode 100644 index 2315d14359..0000000000 --- a/ethereal/config.go +++ /dev/null @@ -1,43 +0,0 @@ -package main - -import ( - "flag" -) - -var Identifier string - -//var StartMining bool -var StartRpc bool -var RpcPort int -var UseUPnP bool -var OutboundPort string -var ShowGenesis bool -var AddPeer string -var MaxPeer int -var GenAddr bool -var UseSeed bool -var ImportKey string -var ExportKey bool -var AssetPath string - -var Datadir string - -func Init() { - flag.StringVar(&Identifier, "id", "", "Custom client identifier") - flag.StringVar(&OutboundPort, "port", "30303", "listening port") - flag.BoolVar(&UseUPnP, "upnp", false, "enable UPnP support") - flag.IntVar(&MaxPeer, "maxpeer", 10, "maximum desired peers") - flag.IntVar(&RpcPort, "rpcport", 8080, "port to start json-rpc server on") - flag.BoolVar(&StartRpc, "rpc", false, "start rpc server") - flag.StringVar(&AssetPath, "asset_path", "", "absolute path to GUI assets directory") - - flag.BoolVar(&ShowGenesis, "genesis", false, "prints genesis header and exits") - flag.BoolVar(&UseSeed, "seed", true, "seed peers") - flag.BoolVar(&GenAddr, "genaddr", false, "create a new priv/pub key") - flag.BoolVar(&ExportKey, "export", false, "export private key") - flag.StringVar(&ImportKey, "import", "", "imports the given private key (hex)") - - flag.StringVar(&Datadir, "datadir", ".ethereal", "specifies the datadir to use. Takes precedence over config file.") - - flag.Parse() -} diff --git a/ethereal/ethereum.go b/ethereal/ethereum.go deleted file mode 100644 index 0db1fa4cd1..0000000000 --- a/ethereal/ethereum.go +++ /dev/null @@ -1,142 +0,0 @@ -package main - -import ( - "fmt" - "github.com/ethereum/eth-go" - "github.com/ethereum/eth-go/ethutil" - "github.com/ethereum/go-ethereum/ethereal/ui" - "github.com/ethereum/go-ethereum/utils" - "github.com/go-qml/qml" - "github.com/rakyll/globalconf" - "log" - "os" - "os/signal" - "path" - "runtime" -) - -const Debug = true - -// Register interrupt handlers so we can stop the ethereum -func RegisterInterupts(s *eth.Ethereum) { - // Buffered chan of one is enough - c := make(chan os.Signal, 1) - // Notify about interrupts for now - signal.Notify(c, os.Interrupt) - go func() { - for sig := range c { - fmt.Printf("Shutting down (%v) ... \n", sig) - - s.Stop() - } - }() -} - -func main() { - Init() - - qml.Init(nil) - - runtime.GOMAXPROCS(runtime.NumCPU()) - - g, err := globalconf.NewWithOptions(&globalconf.Options{ - Filename: path.Join(ethutil.ApplicationFolder(Datadir), "conf.ini"), - }) - if err != nil { - fmt.Println(err) - } else { - g.ParseAll() - } - ethutil.ReadConfig(Datadir, ethutil.LogFile|ethutil.LogStd, g, Identifier) - - // Instantiated a eth stack - ethereum, err := eth.New(eth.CapDefault, UseUPnP) - if err != nil { - log.Println("eth start err:", err) - return - } - ethereum.Port = OutboundPort - - if GenAddr { - fmt.Println("This action overwrites your old private key. Are you sure? (y/n)") - - var r string - fmt.Scanln(&r) - for ; ; fmt.Scanln(&r) { - if r == "n" || r == "y" { - break - } else { - fmt.Printf("Yes or no?", r) - } - } - - if r == "y" { - utils.CreateKeyPair(true) - } - os.Exit(0) - } else { - if len(ImportKey) > 0 { - fmt.Println("This action overwrites your old private key. Are you sure? (y/n)") - var r string - fmt.Scanln(&r) - for ; ; fmt.Scanln(&r) { - if r == "n" || r == "y" { - break - } else { - fmt.Printf("Yes or no?", r) - } - } - - if r == "y" { - utils.ImportPrivateKey(ImportKey) - os.Exit(0) - } - } - } - - if ExportKey { - keyPair := ethutil.GetKeyRing().Get(0) - fmt.Printf(` -Generating new address and keypair. -Please keep your keys somewhere save. - -++++++++++++++++ KeyRing +++++++++++++++++++ -addr: %x -prvk: %x -pubk: %x -++++++++++++++++++++++++++++++++++++++++++++ -save these words so you can restore your account later: %s -`, keyPair.Address(), keyPair.PrivateKey, keyPair.PublicKey) - - os.Exit(0) - } - - if ShowGenesis { - fmt.Println(ethereum.BlockChain().Genesis()) - os.Exit(0) - } - - /* - if StartMining { - utils.DoMining(ethereum) - } - */ - - if StartRpc { - utils.DoRpc(ethereum, RpcPort) - } - - log.Printf("Starting Ethereum GUI v%s\n", ethutil.Config.Ver) - - // Set the max peers - ethereum.MaxPeers = MaxPeer - - gui := ethui.New(ethereum) - - ethereum.Start(UseSeed) - - gui.Start(AssetPath) - - // Wait for shutdown - ethereum.WaitForShutdown() -} diff --git a/ethereal/flags.go b/ethereal/flags.go new file mode 100644 index 0000000000..18f55071a4 --- /dev/null +++ b/ethereal/flags.go @@ -0,0 +1,81 @@ +package main + +import ( + "flag" +) + +var Identifier string +var StartRpc bool +var RpcPort int +var UseUPnP bool +var OutboundPort string +var ShowGenesis bool +var AddPeer string +var MaxPeer int +var GenAddr bool +var UseSeed bool +var ImportKey string +var ExportKey bool +var NonInteractive bool +var Datadir string +var LogFile string +var ConfigFile string +var DebugFile string +var LogLevel int + +// flags specific to gui client +var AssetPath string + +func defaultAssetPath() string { + var assetPath string + // If the current working directory is the go-ethereum dir + // assume a debug build and use the source directory as + // asset directory. + pwd, _ := os.Getwd() + if pwd == path.Join(os.Getenv("GOPATH"), "src", "github.com", "ethereum", "go-ethereum", "ethereal") { + assetPath = path.Join(pwd, "assets") + } else { + switch runtime.GOOS { + case "darwin": + // Get Binary Directory + exedir, _ := osext.ExecutableFolder() + assetPath = filepath.Join(exedir, "../Resources") + case "linux": + assetPath = "/usr/share/ethereal" + case "window": + fallthrough + default: + assetPath = "." + } + } + return assetPath +} + +func defaultDataDir() string { + usr, _ := user.Current() + return path.Join(usr.HomeDir, ".ethereum") +} + +var defaultConfigFile = path.Join(defaultDataDir(), "conf.ini") + +func Init() { + flag.StringVar(&Identifier, "id", "", "Custom client identifier") + flag.StringVar(&OutboundPort, "port", "30303", "listening port") + flag.BoolVar(&UseUPnP, "upnp", false, "enable UPnP support") + flag.IntVar(&MaxPeer, "maxpeer", 10, "maximum desired peers") + flag.IntVar(&RpcPort, "rpcport", 8080, "port to start json-rpc server on") + flag.BoolVar(&StartRpc, "rpc", false, "start rpc server") + flag.BoolVar(&NonInteractive, "y", false, "non-interactive mode (say yes to confirmations)") + flag.BoolVar(&UseSeed, "seed", true, "seed peers") + flag.BoolVar(&GenAddr, "genaddr", false, "create a new priv/pub key") + flag.BoolVar(&ExportKey, "export", false, "export private key") + flag.StringVar(&LogFile, "logfile", "", "log file (defaults to standard output)") + flag.StringVar(&ImportKey, "import", "", "imports the given private key (hex)") + flag.StringVar(&Datadir, "datadir", defaultDataDir(), "specifies the datadir to use") + flag.StringVar(&ConfigFile, "conf", defaultConfigFile, "config file") + flag.StringVar(&DebugFile, "debug", "", "debug file (no debugging if not set)") + flag.IntVar(&LogLevel, "loglevel", int(ethlog.InfoLevel), "loglevel: 0-4: silent,error,warn,info,debug)") + flag.StringVar(&AssetPath, "asset_path", defaultAssetPath, "absolute path to GUI assets directory") + + flag.Parse() +} diff --git a/ethereal/main.go b/ethereal/main.go new file mode 100644 index 0000000000..4af0681976 --- /dev/null +++ b/ethereal/main.go @@ -0,0 +1,43 @@ +package main + +import ( + "fmt" + "github.com/ethereum/go-ethereum/ethereal/ui" + "github.com/ethereum/go-ethereum/utils" + "github.com/go-qml/qml" + "runtime" +) + +const Debug = true + +func main() { + qml.Init(nil) + + runtime.GOMAXPROCS(runtime.NumCPU()) + + // precedence: code-internal flag default < config file < environment variables < command line + Init() // parsing command line + utils.InitConfig(ConfigFile, Datadir, Identifier, "ETH") + + utils.InitDataDir(Datadir) + + utils.InitLogging(Datadir, LogFile, LogLevel, DebugFile) + + ethereum := utils.NewEthereum(UseUPnP, OutboundPort, MaxPeer) + + // create, import, export keys + utils.KeyTasks(GenAddr, ImportKey, ExportKey, NonInteractive) + + if ShowGenesis { + utils.ShowGenesis(ethereum) + } + + if StartRpc { + utils.StartRpc(ethereum, RpcPort) + } + + utils.StartEthereum(ethereum, UseSeed) + + gui := ethui.New(ethereum, logLevel) + gui.Start(AssetPath) +} diff --git a/ethereal/ui/ui_lib.go b/ethereal/ui/ui_lib.go index 2dd66f4fd7..156d551577 100644 --- a/ethereal/ui/ui_lib.go +++ b/ethereal/ui/ui_lib.go @@ -29,9 +29,6 @@ type UiLib struct { } func NewUiLib(engine *qml.Engine, eth *eth.Ethereum, assetPath string) *UiLib { - if assetPath == "" { - assetPath = DefaultAssetPath() - } return &UiLib{engine: engine, eth: eth, assetPath: assetPath} } @@ -88,6 +85,7 @@ func (ui *UiLib) ConnectToPeer(addr string) { func (ui *UiLib) AssetPath(p string) string { return path.Join(ui.assetPath, p) } + func (self *UiLib) StartDbWithContractAndData(contractHash, data string) { dbWindow := NewDebuggerWindow(self) object := self.eth.StateManager().CurrentState().GetStateObject(ethutil.FromHex(contractHash)) @@ -111,29 +109,3 @@ func (self *UiLib) StartDebugger() { dbWindow.Show() } - -func DefaultAssetPath() string { - var base string - // If the current working directory is the go-ethereum dir - // assume a debug build and use the source directory as - // asset directory. - pwd, _ := os.Getwd() - if pwd == path.Join(os.Getenv("GOPATH"), "src", "github.com", "ethereum", "go-ethereum", "ethereal") { - base = path.Join(pwd, "assets") - } else { - switch runtime.GOOS { - case "darwin": - // Get Binary Directory - exedir, _ := osext.ExecutableFolder() - base = filepath.Join(exedir, "../Resources") - case "linux": - base = "/usr/share/ethereal" - case "window": - fallthrough - default: - base = "." - } - } - - return base -} diff --git a/ethereum/cmd.go b/ethereum/cmd.go new file mode 100644 index 0000000000..0e9c2be8ca --- /dev/null +++ b/ethereum/cmd.go @@ -0,0 +1,33 @@ +package main + +import ( + "github.com/ethereum/eth-go" + "github.com/ethereum/go-ethereum/utils" + "os" + "io/ioutil" +) + +func InitJsConsole(ethereum *eth.Ethereum) { + repl := NewJSRepl(ethereum) + go repl.Start() + utils.RegisterInterrupt(func(os.Signal) { + repl.Stop() + ethereum.Stop() + }) +} + +func ExecJsFile (ethereum *eth.Ethereum, InputFile string) { + file, err := os.Open(InputFile) + if err != nil { + logger.Fatalln(err) + } + content, err := ioutil.ReadAll(file) + if err != nil { + logger.Fatalln(err) + } + re := NewJSRE(ethereum) + utils.RegisterInterrupt(func(os.Signal) { + re.Stop() + }) + re.Run(string(content)) +} diff --git a/ethereum/ethereum.go b/ethereum/ethereum.go deleted file mode 100644 index 8812e0a605..0000000000 --- a/ethereum/ethereum.go +++ /dev/null @@ -1,193 +0,0 @@ -package main - -import ( - "fmt" - "github.com/ethereum/eth-go" - "github.com/ethereum/eth-go/ethutil" - "github.com/ethereum/go-ethereum/utils" - "github.com/rakyll/globalconf" - "io/ioutil" - "log" - "os" - "os/signal" - "path" - "runtime" - "strings" -) - -const Debug = true - -func RegisterInterrupt(cb func(os.Signal)) { - go func() { - // Buffered chan of one is enough - c := make(chan os.Signal, 1) - // Notify about interrupts for now - signal.Notify(c, os.Interrupt) - - for sig := range c { - cb(sig) - } - }() -} - -func confirm(message string) bool { - fmt.Println(message, "Are you sure? (y/n)") - var r string - fmt.Scanln(&r) - for ; ; fmt.Scanln(&r) { - if r == "n" || r == "y" { - break - } else { - fmt.Printf("Yes or no?", r) - } - } - return r == "y" -} - -func main() { - Init() - - runtime.GOMAXPROCS(runtime.NumCPU()) - - // set logger - var logSys *log.Logger - flags := log.LstdFlags - - var lt ethutil.LoggerType - if StartJsConsole || len(InputFile) > 0 { - lt = ethutil.LogFile - } else { - lt = ethutil.LogFile | ethutil.LogStd - } - - g, err := globalconf.NewWithOptions(&globalconf.Options{ - Filename: path.Join(ethutil.ApplicationFolder(Datadir), "conf.ini"), - }) - if err != nil { - fmt.Println(err) - } else { - g.ParseAll() - } - ethutil.ReadConfig(Datadir, lt, g, Identifier) - - logger := ethutil.Config.Log - - if LogFile != "" { - logfile, err := os.OpenFile(LogFile, os.O_RDWR|os.O_CREATE|os.O_APPEND, 0666) - if err != nil { - panic(fmt.Sprintf("error opening log file '%s': %v", LogFile, err)) - } - defer logfile.Close() - log.SetOutput(logfile) - logSys = log.New(logfile, "", flags) - logger.AddLogSystem(logSys) - } else { - logSys = log.New(os.Stdout, "", flags) - } - - // Instantiated a eth stack - ethereum, err := eth.New(eth.CapDefault, UseUPnP) - if err != nil { - log.Println("eth start err:", err) - return - } - ethereum.Port = OutboundPort - - // bookkeeping tasks - switch { - case GenAddr: - if NonInteractive || confirm("This action overwrites your old private key.") { - utils.CreateKeyPair(true) - } - os.Exit(0) - case len(ImportKey) > 0: - if NonInteractive || confirm("This action overwrites your old private key.") { - mnemonic := strings.Split(ImportKey, " ") - if len(mnemonic) == 24 { - logSys.Println("Got mnemonic key, importing.") - key := ethutil.MnemonicDecode(mnemonic) - utils.ImportPrivateKey(key) - } else if len(mnemonic) == 1 { - logSys.Println("Got hex key, importing.") - utils.ImportPrivateKey(ImportKey) - } else { - logSys.Println("Did not recognise format, exiting.") - } - } - os.Exit(0) - case ExportKey: - keyPair := ethutil.GetKeyRing().Get(0) - fmt.Printf(` -Generating new address and keypair. -Please keep your keys somewhere save. - -++++++++++++++++ KeyRing +++++++++++++++++++ -addr: %x -prvk: %x -pubk: %x -++++++++++++++++++++++++++++++++++++++++++++ -save these words so you can restore your account later: %s -`, keyPair.Address(), keyPair.PrivateKey, keyPair.PublicKey) - - os.Exit(0) - case ShowGenesis: - logSys.Println(ethereum.BlockChain().Genesis()) - os.Exit(0) - default: - // Creates a keypair if non exists - utils.CreateKeyPair(false) - } - - // client - logger.Infoln(fmt.Sprintf("Starting Ethereum v%s", ethutil.Config.Ver)) - - // Set the max peers - ethereum.MaxPeers = MaxPeer - - // Set Mining status - ethereum.Mining = StartMining - - if StartMining { - utils.DoMining(ethereum) - } - - if StartJsConsole { - repl := NewJSRepl(ethereum) - - go repl.Start() - - RegisterInterrupt(func(os.Signal) { - repl.Stop() - }) - } else if len(InputFile) > 0 { - file, err := os.Open(InputFile) - if err != nil { - ethutil.Config.Log.Fatal(err) - } - - content, err := ioutil.ReadAll(file) - if err != nil { - ethutil.Config.Log.Fatal(err) - } - - re := NewJSRE(ethereum) - RegisterInterrupt(func(os.Signal) { - re.Stop() - }) - re.Run(string(content)) - } - - if StartRpc { - utils.DoRpc(ethereum, RpcPort) - } - - RegisterInterrupt(func(sig os.Signal) { - fmt.Printf("Shutting down (%v) ... \n", sig) - ethereum.Stop() - }) - - ethereum.Start(UseSeed) - - // Wait for shutdown - ethereum.WaitForShutdown() -} diff --git a/ethereum/config.go b/ethereum/flags.go similarity index 61% rename from ethereum/config.go rename to ethereum/flags.go index a80b47a8ef..513d93a6d0 100644 --- a/ethereum/config.go +++ b/ethereum/flags.go @@ -4,10 +4,12 @@ import ( "flag" "fmt" "os" + "os/user" + "path" + "github.com/ethereum/eth-go/ethlog" ) var Identifier string -var StartMining bool var StartRpc bool var RpcPort int var UseUPnP bool @@ -19,16 +21,28 @@ var GenAddr bool var UseSeed bool var ImportKey string var ExportKey bool -var LogFile string var NonInteractive bool +var Datadir string +var LogFile string +var ConfigFile string +var DebugFile string +var LogLevel int + +// flags specific to cli client +var StartMining bool var StartJsConsole bool var InputFile string -var Datadir string +func defaultDataDir() string { + usr, _ := user.Current() + return path.Join(usr.HomeDir, ".ethereum") +} + +var defaultConfigFile = path.Join(defaultDataDir(), "conf.ini") func Init() { flag.Usage = func() { - fmt.Fprintf(os.Stderr, "%s [options] [filename]:\n", os.Args[0]) + fmt.Fprintf(os.Stderr, "%s [options] [filename]:\noptions precedence: default < config file < environment variables < command line", os.Args[0]) flag.PrintDefaults() } @@ -38,17 +52,19 @@ func Init() { flag.IntVar(&MaxPeer, "maxpeer", 10, "maximum desired peers") flag.IntVar(&RpcPort, "rpcport", 8080, "port to start json-rpc server on") flag.BoolVar(&StartRpc, "rpc", false, "start rpc server") - flag.BoolVar(&StartJsConsole, "js", false, "exp") - - flag.BoolVar(&StartMining, "mine", false, "start dagger mining") flag.BoolVar(&NonInteractive, "y", false, "non-interactive mode (say yes to confirmations)") flag.BoolVar(&UseSeed, "seed", true, "seed peers") flag.BoolVar(&GenAddr, "genaddr", false, "create a new priv/pub key") flag.BoolVar(&ExportKey, "export", false, "export private key") flag.StringVar(&LogFile, "logfile", "", "log file (defaults to standard output)") flag.StringVar(&ImportKey, "import", "", "imports the given private key (hex)") + flag.StringVar(&Datadir, "datadir", defaultDataDir(), "specifies the datadir to use") + flag.StringVar(&ConfigFile, "conf", defaultConfigFile, "config file") + flag.StringVar(&DebugFile, "debug", "", "debug file (no debugging if not set)") + flag.IntVar(&LogLevel, "loglevel", int(ethlog.InfoLevel), "loglevel: 0-4: silent,error,warn,info,debug)") - flag.StringVar(&Datadir, "datadir", ".ethereum", "specifies the datadir to use. Takes precedence over config file.") + flag.BoolVar(&StartMining, "mine", false, "start dagger mining") + flag.BoolVar(&StartJsConsole, "js", false, "launches javascript console") flag.Parse() diff --git a/ethereum/main.go b/ethereum/main.go new file mode 100644 index 0000000000..bbbaf5541e --- /dev/null +++ b/ethereum/main.go @@ -0,0 +1,47 @@ +package main + +import ( + "github.com/ethereum/go-ethereum/utils" + "github.com/ethereum/eth-go/ethlog" + "runtime" +) + +var logger = ethlog.NewLogger("CLI") + +func main() { + runtime.GOMAXPROCS(runtime.NumCPU()) + + // precedence: code-internal flag default < config file < environment variables < command line + Init() // parsing command line + utils.InitConfig(ConfigFile, Datadir, Identifier, "ETH") + + utils.InitDataDir(Datadir) + + utils.InitLogging(Datadir, LogFile, LogLevel, DebugFile) + + ethereum := utils.NewEthereum(UseUPnP, OutboundPort, MaxPeer) + + // create, import, export keys + utils.KeyTasks(GenAddr, ImportKey, ExportKey, NonInteractive) + + if ShowGenesis { + utils.ShowGenesis(ethereum) + } + + if StartMining { + utils.StartMining(ethereum) + } + + // better reworked as cases + if StartJsConsole { + InitJsConsole(ethereum) + } else if len(InputFile) > 0 { + ExecJsFile(ethereum, InputFile) + } + + if StartRpc { + utils.StartRpc(ethereum, RpcPort) + } + + utils.StartEthereum(ethereum, UseSeed) +} diff --git a/utils/cmd.go b/utils/cmd.go index e1fc0fc00e..39233d5864 100644 --- a/utils/cmd.go +++ b/utils/cmd.go @@ -1,74 +1,224 @@ package utils import ( - "github.com/ethereum/eth-go" - "github.com/ethereum/eth-go/ethminer" - "github.com/ethereum/eth-go/ethpub" - "github.com/ethereum/eth-go/ethrpc" - "github.com/ethereum/eth-go/ethutil" - "time" + "github.com/ethereum/eth-go" + "github.com/ethereum/eth-go/ethminer" + "github.com/ethereum/eth-go/ethpub" + "github.com/ethereum/eth-go/ethrpc" + "github.com/ethereum/eth-go/ethutil" + "github.com/ethereum/eth-go/ethlog" + "log" + "io" + "path" + "os" + "os/signal" + "fmt" + "time" + "strings" ) -func DoRpc(ethereum *eth.Ethereum, RpcPort int) { - var err error - ethereum.RpcServer, err = ethrpc.NewJsonRpcServer(ethpub.NewPEthereum(ethereum), RpcPort) - if err != nil { - ethutil.Config.Log.Infoln("Could not start RPC interface:", err) - } else { - go ethereum.RpcServer.Start() - } +var logger = ethlog.NewLogger("CLI") + +// Register interrupt handlers +func RegisterInterrupt(cb func(os.Signal)) { + go func() { + // Buffered chan of one is enough + c := make(chan os.Signal, 1) + // Notify about interrupts for now + signal.Notify(c, os.Interrupt) + for sig := range c { + cb(sig) + } + }() +} + +func AbsolutePath(Datadir string, filename string) string { + if path.IsAbs(filename) { + return filename + } + return path.Join(Datadir, filename) +} + +func openLogFile (Datadir string, filename string) *os.File { + path := AbsolutePath(Datadir, filename) + file, err := os.OpenFile(path, os.O_RDWR|os.O_CREATE|os.O_APPEND, 0666) + if err != nil { + panic(fmt.Sprintf("error opening log file '%s': %v", filename, err)) + } + return file +} + +func confirm (message string) bool { + fmt.Println(message, "Are you sure? (y/n)") + var r string + fmt.Scanln(&r) + for ; ; fmt.Scanln(&r) { + if r == "n" || r == "y" { + break + } else { + fmt.Printf("Yes or no?", r) + } + } + return r == "y" +} + +func InitDataDir(Datadir string) { + _, err := os.Stat(Datadir) + if err != nil { + if os.IsNotExist(err) { + fmt.Printf("Debug logging directory '%s' doesn't exist, creating it\n", Datadir) + os.Mkdir(Datadir, 0777) + } + } +} + +func InitLogging (Datadir string, LogFile string, LogLevel int, DebugFile string) { + var writer io.Writer + if LogFile == "" { + writer = os.Stdout + } else { + writer = openLogFile(Datadir, LogFile) + } + ethlog.AddLogSystem(ethlog.NewStdLogSystem(writer, log.LstdFlags, ethlog.LogLevel(LogLevel))) + if DebugFile != "" { + writer = openLogFile(Datadir, DebugFile) + ethlog.AddLogSystem(ethlog.NewStdLogSystem(writer, log.LstdFlags, ethlog.DebugLevel)) + } +} + +func InitConfig(ConfigFile string, Datadir string, Identifier string, EnvPrefix string) { + ethutil.ReadConfig(ConfigFile, Datadir, Identifier, EnvPrefix) + ethutil.Config.Set("rpcport", "700") +} + +func exit(status int) { + ethlog.Flush() + os.Exit(status) +} + +func NewEthereum(UseUPnP bool, OutboundPort string, MaxPeer int) *eth.Ethereum { + ethereum, err := eth.New(eth.CapDefault, UseUPnP) + if err != nil { + logger.Fatalln("eth start err:", err) + } + ethereum.Port = OutboundPort + ethereum.MaxPeers = MaxPeer + return ethereum +} + +func StartEthereum(ethereum *eth.Ethereum, UseSeed bool) { + logger.Infof("Starting Ethereum v%s", ethutil.Config.Ver) + ethereum.Start(UseSeed) + // Wait for shutdown + ethereum.WaitForShutdown() + RegisterInterrupt(func(sig os.Signal) { + logger.Errorf("Shutting down (%v) ... \n", sig) + ethereum.Stop() + ethlog.Flush() + }) +} + +func ShowGenesis(ethereum *eth.Ethereum) { + logger.Infoln(ethereum.BlockChain().Genesis()) + exit(0) +} + +func KeyTasks(GenAddr bool, ImportKey string, ExportKey bool, NonInteractive bool) { + switch { + case GenAddr: + if NonInteractive || confirm("This action overwrites your old private key.") { + CreateKeyPair(true) + } + exit(0) + case len(ImportKey) > 0: + if NonInteractive || confirm("This action overwrites your old private key.") { + // import should be from file + mnemonic := strings.Split(ImportKey, " ") + if len(mnemonic) == 24 { + logger.Infoln("Got mnemonic key, importing.") + key := ethutil.MnemonicDecode(mnemonic) + ImportPrivateKey(key) + } else if len(mnemonic) == 1 { + logger.Infoln("Got hex key, importing.") + ImportPrivateKey(ImportKey) + } else { + logger.Errorln("Did not recognise format, exiting.") + } + } + exit(0) + case ExportKey: // this should be exporting to a filename + keyPair := ethutil.GetKeyRing().Get(0) + fmt.Printf(` +Generating new address and keypair. +Please keep your keys somewhere save. + +++++++++++++++++ KeyRing +++++++++++++++++++ +addr: %x +prvk: %x +pubk: %x +++++++++++++++++++++++++++++++++++++++++++++ +save these words so you can restore your account later: %s +`, keyPair.Address(), keyPair.PrivateKey, keyPair.PublicKey) + + exit(0) + default: + // Creates a keypair if none exists + CreateKeyPair(false) + } +} + +func StartRpc(ethereum *eth.Ethereum, RpcPort int) { + var err error + ethereum.RpcServer, err = ethrpc.NewJsonRpcServer(ethpub.NewPEthereum(ethereum), RpcPort) + if err != nil { + logger.Errorf("Could not start RPC interface (port %v): %v", RpcPort, err) + } else { + go ethereum.RpcServer.Start() + RegisterInterrupt(func(os.Signal) { + ethereum.RpcServer.Stop() + }) + } } var miner ethminer.Miner -func DoMining(ethereum *eth.Ethereum) { - // Set Mining status - ethereum.Mining = true +func StartMining(ethereum *eth.Ethereum) bool { + if !ethereum.Mining { + ethereum.Mining = true - if ethutil.GetKeyRing().Len() == 0 { - ethutil.Config.Log.Infoln("No address found, can't start mining") - return - } - keyPair := ethutil.GetKeyRing().Get(0) - addr := keyPair.Address() + if ethutil.GetKeyRing().Len() == 0 { + logger.Errorln("No address found, can't start mining") + ethereum.Mining = false + return true //???? + } + keyPair := ethutil.GetKeyRing().Get(0) + addr := keyPair.Address() - go func() { - miner = ethminer.NewDefaultMiner(addr, ethereum) - - // Give it some time to connect with peers - time.Sleep(3 * time.Second) - - for ethereum.IsUpToDate() == false { - time.Sleep(5 * time.Second) - } - - ethutil.Config.Log.Infoln("Miner started") - - miner := ethminer.NewDefaultMiner(addr, ethereum) - miner.Start() - }() + go func() { + miner = ethminer.NewDefaultMiner(addr, ethereum) + // Give it some time to connect with peers + time.Sleep(3 * time.Second) + for ethereum.IsUpToDate() == false { + time.Sleep(5 * time.Second) + } + logger.Infoln("Miner started") + miner := ethminer.NewDefaultMiner(addr, ethereum) + miner.Start() + }() + RegisterInterrupt(func(os.Signal) { + StopMining(ethereum) + }) + return true + } + return false } func StopMining(ethereum *eth.Ethereum) bool { - if ethereum.Mining { - miner.Stop() - - ethutil.Config.Log.Infoln("Miner stopped") - - ethereum.Mining = false - - return true - } - - return false -} - -func StartMining(ethereum *eth.Ethereum) bool { - if !ethereum.Mining { - DoMining(ethereum) - - return true - } - - return false + if ethereum.Mining { + miner.Stop() + logger.Infoln("Miner stopped") + ethereum.Mining = false + return true + } + return false }