diff --git a/.gitignore b/.gitignore
index f816a06a1721680eec355fd0f6b97559aa64ec66..de3a847ace5001c560b8164f6cdff8bf52fc441e 100644
--- a/.gitignore
+++ b/.gitignore
@@ -9,5 +9,6 @@
*un~
.DS_Store
*/**/.DS_Store
-./ethereum/ethereum
+ethereum/ethereum
+ethereal/ethereal
diff --git a/ethereal/assets/qml/wallet.qml b/ethereal/assets/qml/wallet.qml
index 454d0f3f01dd6d3dbf56a0733b1a360056f0eeb9..84f8fd5cf0d3a6da3b182fe82c293352d59cb2d3 100644
--- a/ethereal/assets/qml/wallet.qml
+++ b/ethereal/assets/qml/wallet.qml
@@ -319,7 +319,7 @@ ApplicationWindow {
Slider {
id: logLevelSlider
- value: 1
+ value: eth.getLogLevelInt()
anchors {
right: parent.right
top: parent.top
@@ -332,7 +332,7 @@ ApplicationWindow {
}
orientation: Qt.Vertical
- maximumValue: 3
+ maximumValue: 5
stepSize: 1
onValueChanged: {
diff --git a/ethereal/config.go b/ethereal/config.go
deleted file mode 100644
index 2315d14359882b687467f7063eb4ebd30aaa49cc..0000000000000000000000000000000000000000
--- 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 0db1fa4cd188aa63211d0f51803390e70fcee7f2..0000000000000000000000000000000000000000
--- 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 0000000000000000000000000000000000000000..9bed38d9fe782f395a229c0676f8b47d637266e1
--- /dev/null
+++ b/ethereal/flags.go
@@ -0,0 +1,95 @@
+package main
+
+import (
+ "bitbucket.org/kardianos/osext"
+ "flag"
+ "fmt"
+ "github.com/ethereum/eth-go/ethlog"
+ "os"
+ "os/user"
+ "path"
+ "path/filepath"
+ "runtime"
+)
+
+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, ".ethereal")
+}
+
+var defaultConfigFile = path.Join(defaultDataDir(), "conf.ini")
+
+func Init() {
+ flag.Usage = func() {
+ fmt.Fprintf(os.Stderr, "%s [options] [filename]:\noptions precedence: default < config file < environment variables < command line\n", os.Args[0])
+ flag.PrintDefaults()
+ }
+
+ 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-5: silent,error,warn,info,debug,debug detail)")
+
+ 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 0000000000000000000000000000000000000000..799b50e4b529720a8c03147e31402c83c31ff450
--- /dev/null
+++ b/ethereal/main.go
@@ -0,0 +1,61 @@
+package main
+
+import (
+ "github.com/ethereum/eth-go/ethlog"
+ "github.com/ethereum/go-ethereum/ethereal/ui"
+ "github.com/ethereum/go-ethereum/utils"
+ "github.com/go-qml/qml"
+ "os"
+ "runtime"
+)
+
+func main() {
+ runtime.GOMAXPROCS(runtime.NumCPU())
+
+ qml.Init(nil)
+
+ var interrupted = false
+ utils.RegisterInterrupt(func(os.Signal) {
+ interrupted = true
+ })
+
+ utils.HandleInterrupt()
+
+ // 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)
+ }
+
+ gui := ethui.New(ethereum, LogLevel)
+
+ utils.RegisterInterrupt(func(os.Signal) {
+ gui.Stop()
+ })
+ utils.StartEthereum(ethereum, UseSeed)
+ // gui blocks the main thread
+ gui.Start(AssetPath)
+ // we need to run the interrupt callbacks in case gui is closed
+ // this skips if we got here by actual interrupt stopping the GUI
+ if !interrupted {
+ utils.RunInterruptCallbacks(os.Interrupt)
+ }
+ // this blocks the thread
+ ethereum.WaitForShutdown()
+ ethlog.Flush()
+}
diff --git a/ethereal/ui/gui.go b/ethereal/ui/gui.go
index 7b59e2fbc69cfbfcab4008280c1b8f358e056eca..be7b395d8e284a0076a7517f1b10d7e7464f11d1 100644
--- a/ethereal/ui/gui.go
+++ b/ethereal/ui/gui.go
@@ -6,6 +6,7 @@ import (
"github.com/ethereum/eth-go"
"github.com/ethereum/eth-go/ethchain"
"github.com/ethereum/eth-go/ethdb"
+ "github.com/ethereum/eth-go/ethlog"
"github.com/ethereum/eth-go/ethpub"
"github.com/ethereum/eth-go/ethutil"
"github.com/ethereum/go-ethereum/utils"
@@ -15,6 +16,8 @@ import (
"time"
)
+var logger = ethlog.NewLogger("GUI")
+
type Gui struct {
// The main application window
win *qml.Window
@@ -32,11 +35,13 @@ type Gui struct {
addr []byte
- pub *ethpub.PEthereum
+ pub *ethpub.PEthereum
+ logLevel ethlog.LogLevel
+ open bool
}
// Create GUI, but doesn't start it
-func New(ethereum *eth.Ethereum) *Gui {
+func New(ethereum *eth.Ethereum, logLevel int) *Gui {
lib := &EthLib{stateManager: ethereum.StateManager(), blockChain: ethereum.BlockChain(), txPool: ethereum.TxPool()}
db, err := ethdb.NewLDBDatabase("tx_database")
if err != nil {
@@ -52,7 +57,7 @@ func New(ethereum *eth.Ethereum) *Gui {
pub := ethpub.NewPEthereum(ethereum)
- return &Gui{eth: ethereum, lib: lib, txDb: db, addr: addr, pub: pub}
+ return &Gui{eth: ethereum, lib: lib, txDb: db, addr: addr, pub: pub, logLevel: ethlog.LogLevel(logLevel), open: false}
}
func (gui *Gui) Start(assetPath string) {
@@ -86,25 +91,39 @@ func (gui *Gui) Start(assetPath string) {
var win *qml.Window
var err error
+ var addlog = false
if len(data) == 0 {
win, err = gui.showKeyImport(context)
} else {
win, err = gui.showWallet(context)
-
- ethutil.Config.Log.AddLogSystem(gui)
+ addlog = true
}
if err != nil {
- ethutil.Config.Log.Infoln("FATAL: asset not found: you can set an alternative asset path on on the command line using option 'asset_path'", err)
+ logger.Errorln("asset not found: you can set an alternative asset path on the command line using option 'asset_path'", err)
panic(err)
}
- ethutil.Config.Log.Infoln("[GUI] Starting GUI")
-
+ logger.Infoln("Starting GUI")
+ gui.open = true
win.Show()
+ // only add the gui logger after window is shown otherwise slider wont be shown
+ if addlog {
+ ethlog.AddLogSystem(gui)
+ }
win.Wait()
+ // need to silence gui logger after window closed otherwise logsystem hangs
+ gui.SetLogLevel(ethlog.Silence)
+ gui.open = false
+}
- gui.eth.Stop()
+func (gui *Gui) Stop() {
+ if gui.open {
+ gui.SetLogLevel(ethlog.Silence)
+ gui.open = false
+ gui.win.Hide()
+ }
+ logger.Infoln("Stopped")
}
func (gui *Gui) ToggleMining() {
@@ -311,22 +330,6 @@ func (gui *Gui) setPeerInfo() {
}
}
-// Logging functions that log directly to the GUI interface
-func (gui *Gui) Println(v ...interface{}) {
- str := strings.TrimRight(fmt.Sprintln(v...), "\n")
- lines := strings.Split(str, "\n")
- for _, line := range lines {
- gui.win.Root().Call("addLog", line)
- }
-}
-
-func (gui *Gui) Printf(format string, v ...interface{}) {
- str := strings.TrimRight(fmt.Sprintf(format, v...), "\n")
- lines := strings.Split(str, "\n")
- for _, line := range lines {
- gui.win.Root().Call("addLog", line)
- }
-}
func (gui *Gui) RegisterName(name string) {
keyPair := ethutil.GetKeyRing().Get(0)
name = fmt.Sprintf("\"%s\"\n1", name)
@@ -353,6 +356,34 @@ func (gui *Gui) ClientId() string {
return ethutil.Config.Identifier
}
-func (gui *Gui) SetLogLevel(level int) {
- ethutil.Config.Log.SetLevel(level)
+// functions that allow Gui to implement interface ethlog.LogSystem
+func (gui *Gui) SetLogLevel(level ethlog.LogLevel) {
+ gui.logLevel = level
+}
+
+func (gui *Gui) GetLogLevel() ethlog.LogLevel {
+ return gui.logLevel
+}
+
+// this extra function needed to give int typecast value to gui widget
+// that sets initial loglevel to default
+func (gui *Gui) GetLogLevelInt() int {
+ return int(gui.logLevel)
+}
+
+func (gui *Gui) Println(v ...interface{}) {
+ gui.printLog(fmt.Sprintln(v...))
+}
+
+func (gui *Gui) Printf(format string, v ...interface{}) {
+ gui.printLog(fmt.Sprintf(format, v...))
+}
+
+// Print function that logs directly to the GUI
+func (gui *Gui) printLog(s string) {
+ str := strings.TrimRight(s, "\n")
+ lines := strings.Split(str, "\n")
+ for _, line := range lines {
+ gui.win.Root().Call("addLog", line)
+ }
}
diff --git a/ethereal/ui/html_container.go b/ethereal/ui/html_container.go
index 3867c0353452f1568c3fd9fb7166a32903b1f906..d7dc80af73bf1f24bbd632b7381161127f402bc9 100644
--- a/ethereal/ui/html_container.go
+++ b/ethereal/ui/html_container.go
@@ -96,11 +96,11 @@ func (app *HtmlApplication) NewWatcher(quitChan chan bool) {
app.watcher.Close()
break out
case <-app.watcher.Event:
- //ethutil.Config.Log.Debugln("Got event:", ev)
+ //logger.Debugln("Got event:", ev)
app.webView.Call("reload")
case err := <-app.watcher.Error:
// TODO: Do something here
- ethutil.Config.Log.Infoln("Watcher error:", err)
+ logger.Infoln("Watcher error:", err)
}
}
}()
diff --git a/ethereal/ui/qml_app.go b/ethereal/ui/qml_app.go
index d47751616e05d6cbb1f8f5cdf6a6640f9ad24ad1..39ab7f922a54564ea611fff11a00a2e29b8ad82d 100644
--- a/ethereal/ui/qml_app.go
+++ b/ethereal/ui/qml_app.go
@@ -22,7 +22,7 @@ func NewQmlApplication(path string, lib *UiLib) *QmlApplication {
func (app *QmlApplication) Create() error {
component, err := app.engine.LoadFile(app.path)
if err != nil {
- ethutil.Config.Log.Debugln(err)
+ logger.Warnln(err)
}
app.win = component.CreateWindow(nil)
diff --git a/ethereal/ui/ui_lib.go b/ethereal/ui/ui_lib.go
index 908497be3ec37c18a6ce0ce14485e67d0eeac83a..ddc955176c9dbc5496d8a4bd5f77237cdf5afce5 100644
--- a/ethereal/ui/ui_lib.go
+++ b/ethereal/ui/ui_lib.go
@@ -1,14 +1,10 @@
package ethui
import (
- "bitbucket.org/kardianos/osext"
"github.com/ethereum/eth-go"
"github.com/ethereum/eth-go/ethutil"
"github.com/go-qml/qml"
- "os"
"path"
- "path/filepath"
- "runtime"
)
type memAddr struct {
@@ -29,9 +25,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}
}
@@ -52,7 +45,7 @@ func (ui *UiLib) OpenHtml(path string) {
func (ui *UiLib) Muted(content string) {
component, err := ui.engine.LoadFile(ui.AssetPath("qml/muted.qml"))
if err != nil {
- ethutil.Config.Log.Debugln(err)
+ logger.Debugln(err)
return
}
@@ -81,6 +74,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))
@@ -104,29 +98,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 0000000000000000000000000000000000000000..08147824dcb79e64ce969c26c0f56086e5a9aa85
--- /dev/null
+++ b/ethereum/cmd.go
@@ -0,0 +1,32 @@
+package main
+
+import (
+ "github.com/ethereum/eth-go"
+ "github.com/ethereum/go-ethereum/utils"
+ "io/ioutil"
+ "os"
+)
+
+func InitJsConsole(ethereum *eth.Ethereum) {
+ repl := NewJSRepl(ethereum)
+ go repl.Start()
+ utils.RegisterInterrupt(func(os.Signal) {
+ repl.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 8812e0a605935a9effbabeada710dec8364fd256..0000000000000000000000000000000000000000
--- 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 a80b47a8ef9240bec749cba79b4f01aa4875da36..8fb87cf3490d4fa0630c3aacffeab340eccff8d4 100644
--- a/ethereum/config.go
+++ b/ethereum/flags.go
@@ -3,11 +3,13 @@ package main
import (
"flag"
"fmt"
+ "github.com/ethereum/eth-go/ethlog"
"os"
+ "os/user"
+ "path"
)
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\n", 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-5: silent,error,warn,info,debug,debug detail)")
- 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/javascript_runtime.go b/ethereum/javascript_runtime.go
index a9b12629abd1b9ad085192124f856407b17c7833..0dfe07a541290410174dcf1363e702c12ba87f58 100644
--- a/ethereum/javascript_runtime.go
+++ b/ethereum/javascript_runtime.go
@@ -4,6 +4,7 @@ import (
"fmt"
"github.com/ethereum/eth-go"
"github.com/ethereum/eth-go/ethchain"
+ "github.com/ethereum/eth-go/ethlog"
"github.com/ethereum/eth-go/ethpub"
"github.com/ethereum/eth-go/ethutil"
"github.com/ethereum/go-ethereum/utils"
@@ -14,6 +15,8 @@ import (
"path/filepath"
)
+var jsrelogger = ethlog.NewLogger("JSRE")
+
type JSRE struct {
ethereum *eth.Ethereum
vm *otto.Otto
@@ -31,7 +34,7 @@ func (jsre *JSRE) LoadExtFile(path string) {
if err == nil {
jsre.vm.Run(result)
} else {
- ethutil.Config.Log.Debugln("Could not load file:", path)
+ jsrelogger.Debugln("Could not load file:", path)
}
}
@@ -65,6 +68,8 @@ func NewJSRE(ethereum *eth.Ethereum) *JSRE {
re.initStdFuncs()
+ jsrelogger.Infoln("started")
+
return re
}
@@ -99,6 +104,7 @@ func (self *JSRE) Stop() {
close(self.blockChan)
close(self.quitChan)
close(self.changeChan)
+ jsrelogger.Infoln("stopped")
}
func (self *JSRE) mainLoop() {
diff --git a/ethereum/main.go b/ethereum/main.go
new file mode 100644
index 0000000000000000000000000000000000000000..6b1995eec4a9d137d497fc49e53f5c6f2b75a08c
--- /dev/null
+++ b/ethereum/main.go
@@ -0,0 +1,53 @@
+package main
+
+import (
+ "github.com/ethereum/eth-go/ethlog"
+ "github.com/ethereum/go-ethereum/utils"
+ "runtime"
+)
+
+var logger = ethlog.NewLogger("CLI")
+
+func main() {
+ runtime.GOMAXPROCS(runtime.NumCPU())
+
+ utils.HandleInterrupt()
+
+ // 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)
+
+ // this blocks the thread
+ ethereum.WaitForShutdown()
+ ethlog.Flush()
+}
diff --git a/ethereum/repl.go b/ethereum/repl.go
index dd8d081793da1581d68050819f9276e4756f10cb..34380a06f4c774df63bcdeff5b08840b157afe19 100644
--- a/ethereum/repl.go
+++ b/ethereum/repl.go
@@ -23,6 +23,8 @@ type JSRepl struct {
prompt string
history *os.File
+
+ running bool
}
func NewJSRepl(ethereum *eth.Ethereum) *JSRepl {
@@ -35,24 +37,32 @@ func NewJSRepl(ethereum *eth.Ethereum) *JSRepl {
}
func (self *JSRepl) Start() {
- reader := bufio.NewReader(self.history)
- for {
- line, err := reader.ReadString('\n')
- if err != nil && err == io.EOF {
- break
- } else if err != nil {
- fmt.Println("error reading history", err)
- break
+ if !self.running {
+ self.running = true
+ logger.Infoln("init JS Console")
+ reader := bufio.NewReader(self.history)
+ for {
+ line, err := reader.ReadString('\n')
+ if err != nil && err == io.EOF {
+ break
+ } else if err != nil {
+ fmt.Println("error reading history", err)
+ break
+ }
+
+ addHistory(line[:len(line)-1])
}
-
- addHistory(line[:len(line)-1])
+ self.read()
}
- self.read()
}
func (self *JSRepl) Stop() {
- self.re.Stop()
- self.history.Close()
+ if self.running {
+ self.running = false
+ self.re.Stop()
+ logger.Infoln("exit JS Console")
+ self.history.Close()
+ }
}
func (self *JSRepl) parseInput(code string) {
diff --git a/utils/cmd.go b/utils/cmd.go
index 368f2381e75c4f52e8c3103c084217bd1d02758a..c084542b417891ff5efa7f41810c33f8e8e2bdba 100644
--- a/utils/cmd.go
+++ b/utils/cmd.go
@@ -3,76 +3,226 @@ package utils
import (
"fmt"
"github.com/ethereum/eth-go"
+ "github.com/ethereum/eth-go/ethlog"
"github.com/ethereum/eth-go/ethminer"
"github.com/ethereum/eth-go/ethpub"
"github.com/ethereum/eth-go/ethrpc"
"github.com/ethereum/eth-go/ethutil"
+ "io"
+ "log"
+ "os"
+ "os/signal"
+ "path"
+ "strings"
"time"
)
-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")
+var interruptCallbacks = []func(os.Signal){}
+
+// Register interrupt handlers callbacks
+func RegisterInterrupt(cb func(os.Signal)) {
+ interruptCallbacks = append(interruptCallbacks, cb)
}
-var miner ethminer.Miner
+// go routine that call interrupt handlers in order of registering
+func HandleInterrupt() {
+ c := make(chan os.Signal, 1)
+ go func() {
+ signal.Notify(c, os.Interrupt)
+ for sig := range c {
+ logger.Errorf("Shutting down (%v) ... \n", sig)
+ RunInterruptCallbacks(sig)
+ }
+ }()
+}
-func DoMining(ethereum *eth.Ethereum) {
- // Set Mining status
- ethereum.Mining = true
+func RunInterruptCallbacks(sig os.Signal) {
+ for _, cb := range interruptCallbacks {
+ cb(sig)
+ }
+}
- if ethutil.GetKeyRing().Len() == 0 {
- ethutil.Config.Log.Infoln("No address found, can't start mining")
- return
+func AbsolutePath(Datadir string, filename string) string {
+ if path.IsAbs(filename) {
+ return filename
}
- keyPair := ethutil.GetKeyRing().Get(0)
- addr := keyPair.Address()
+ return path.Join(Datadir, filename)
+}
- go func() {
- miner = ethminer.NewDefaultMiner(addr, ethereum)
+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
+}
- // Give it some time to connect with peers
- time.Sleep(3 * time.Second)
+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"
+}
- /*
- for ethereum.IsUpToDate() == false {
- time.Sleep(5 * time.Second)
- }
- */
+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)
+ }
+ }
+}
- ethutil.Config.Log.Infoln("Miner started")
+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))
+ }
+}
- miner := ethminer.NewDefaultMiner(addr, ethereum)
- miner.Start()
- }()
+func InitConfig(ConfigFile string, Datadir string, Identifier string, EnvPrefix string) {
+ InitDataDir(Datadir)
+ ethutil.ReadConfig(ConfigFile, Datadir, Identifier, EnvPrefix)
+ ethutil.Config.Set("rpcport", "700")
}
-func StopMining(ethereum *eth.Ethereum) bool {
- if ethereum.Mining {
- miner.Stop()
+func exit(status int) {
+ ethlog.Flush()
+ os.Exit(status)
+}
- ethutil.Config.Log.Infoln("Miner stopped")
+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
+}
- ethereum.Mining = false
+func StartEthereum(ethereum *eth.Ethereum, UseSeed bool) {
+ logger.Infof("Starting Ethereum v%s", ethutil.Config.Ver)
+ ethereum.Start(UseSeed)
+ RegisterInterrupt(func(sig os.Signal) {
+ ethereum.Stop()
+ ethlog.Flush()
+ })
+}
- return true
+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)
}
+}
- return 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()
+ }
}
+var miner ethminer.Miner
+
func StartMining(ethereum *eth.Ethereum) bool {
if !ethereum.Mining {
- DoMining(ethereum)
-
+ ethereum.Mining = true
+
+ 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)
+ 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()
+ logger.Infoln("Miner stopped")
+ ethereum.Mining = false
+ return true
+ }
return false
}