github.com/shrimpyuk/bor@v0.2.15-0.20220224151350-fb4ec6020bae/cmd/geth/consolecmd.go (about) 1 // Copyright 2016 The go-ethereum Authors 2 // This file is part of go-ethereum. 3 // 4 // go-ethereum is free software: you can redistribute it and/or modify 5 // it under the terms of the GNU General Public License as published by 6 // the Free Software Foundation, either version 3 of the License, or 7 // (at your option) any later version. 8 // 9 // go-ethereum is distributed in the hope that it will be useful, 10 // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 // GNU General Public License for more details. 13 // 14 // You should have received a copy of the GNU General Public License 15 // along with go-ethereum. If not, see <http://www.gnu.org/licenses/>. 16 17 package main 18 19 import ( 20 "fmt" 21 "os" 22 "path/filepath" 23 "strings" 24 25 "github.com/ethereum/go-ethereum/cmd/utils" 26 "github.com/ethereum/go-ethereum/console" 27 "github.com/ethereum/go-ethereum/node" 28 "github.com/ethereum/go-ethereum/rpc" 29 "gopkg.in/urfave/cli.v1" 30 ) 31 32 var ( 33 consoleFlags = []cli.Flag{utils.JSpathFlag, utils.ExecFlag, utils.PreloadJSFlag} 34 35 consoleCommand = cli.Command{ 36 Action: utils.MigrateFlags(localConsole), 37 Name: "console", 38 Usage: "Start an interactive JavaScript environment", 39 Flags: append(append(nodeFlags, rpcFlags...), consoleFlags...), 40 Category: "CONSOLE COMMANDS", 41 Description: ` 42 The Geth console is an interactive shell for the JavaScript runtime environment 43 which exposes a node admin interface as well as the Ðapp JavaScript API. 44 See https://geth.ethereum.org/docs/interface/javascript-console.`, 45 } 46 47 attachCommand = cli.Command{ 48 Action: utils.MigrateFlags(remoteConsole), 49 Name: "attach", 50 Usage: "Start an interactive JavaScript environment (connect to node)", 51 ArgsUsage: "[endpoint]", 52 Flags: append(consoleFlags, utils.DataDirFlag), 53 Category: "CONSOLE COMMANDS", 54 Description: ` 55 The Geth console is an interactive shell for the JavaScript runtime environment 56 which exposes a node admin interface as well as the Ðapp JavaScript API. 57 See https://geth.ethereum.org/docs/interface/javascript-console. 58 This command allows to open a console on a running geth node.`, 59 } 60 61 javascriptCommand = cli.Command{ 62 Action: utils.MigrateFlags(ephemeralConsole), 63 Name: "js", 64 Usage: "Execute the specified JavaScript files", 65 ArgsUsage: "<jsfile> [jsfile...]", 66 Flags: append(nodeFlags, consoleFlags...), 67 Category: "CONSOLE COMMANDS", 68 Description: ` 69 The JavaScript VM exposes a node admin interface as well as the Ðapp 70 JavaScript API. See https://geth.ethereum.org/docs/interface/javascript-console`, 71 } 72 ) 73 74 // localConsole starts a new geth node, attaching a JavaScript console to it at the 75 // same time. 76 func localConsole(ctx *cli.Context) error { 77 // Create and start the node based on the CLI flags 78 prepare(ctx) 79 stack, backend := makeFullNode(ctx) 80 startNode(ctx, stack, backend) 81 defer stack.Close() 82 83 // Attach to the newly started node and start the JavaScript console 84 client, err := stack.Attach() 85 if err != nil { 86 utils.Fatalf("Failed to attach to the inproc geth: %v", err) 87 } 88 config := console.Config{ 89 DataDir: utils.MakeDataDir(ctx), 90 DocRoot: ctx.GlobalString(utils.JSpathFlag.Name), 91 Client: client, 92 Preload: utils.MakeConsolePreloads(ctx), 93 } 94 95 console, err := console.New(config) 96 if err != nil { 97 utils.Fatalf("Failed to start the JavaScript console: %v", err) 98 } 99 defer console.Stop(false) 100 101 // If only a short execution was requested, evaluate and return 102 if script := ctx.GlobalString(utils.ExecFlag.Name); script != "" { 103 console.Evaluate(script) 104 return nil 105 } 106 // Otherwise print the welcome screen and enter interactive mode 107 console.Welcome() 108 console.Interactive() 109 110 return nil 111 } 112 113 // remoteConsole will connect to a remote geth instance, attaching a JavaScript 114 // console to it. 115 func remoteConsole(ctx *cli.Context) error { 116 // Attach to a remotely running geth instance and start the JavaScript console 117 endpoint := ctx.Args().First() 118 if endpoint == "" { 119 path := node.DefaultDataDir() 120 if ctx.GlobalIsSet(utils.DataDirFlag.Name) { 121 path = ctx.GlobalString(utils.DataDirFlag.Name) 122 } 123 if path != "" { 124 if ctx.GlobalBool(utils.RopstenFlag.Name) { 125 // Maintain compatibility with older Geth configurations storing the 126 // Ropsten database in `testnet` instead of `ropsten`. 127 legacyPath := filepath.Join(path, "testnet") 128 if _, err := os.Stat(legacyPath); !os.IsNotExist(err) { 129 path = legacyPath 130 } else { 131 path = filepath.Join(path, "ropsten") 132 } 133 } else if ctx.GlobalBool(utils.RinkebyFlag.Name) { 134 path = filepath.Join(path, "rinkeby") 135 } else if ctx.GlobalBool(utils.GoerliFlag.Name) { 136 path = filepath.Join(path, "goerli") 137 } else if ctx.GlobalBool(utils.MumbaiFlag.Name) || ctx.GlobalBool(utils.BorMainnetFlag.Name) { 138 homeDir, _ := os.UserHomeDir() 139 path = filepath.Join(homeDir, "/.bor/data") 140 } 141 } 142 endpoint = fmt.Sprintf("%s/geth.ipc", path) 143 } 144 client, err := dialRPC(endpoint) 145 if err != nil { 146 utils.Fatalf("Unable to attach to remote geth: %v", err) 147 } 148 config := console.Config{ 149 DataDir: utils.MakeDataDir(ctx), 150 DocRoot: ctx.GlobalString(utils.JSpathFlag.Name), 151 Client: client, 152 Preload: utils.MakeConsolePreloads(ctx), 153 } 154 155 console, err := console.New(config) 156 if err != nil { 157 utils.Fatalf("Failed to start the JavaScript console: %v", err) 158 } 159 defer console.Stop(false) 160 161 if script := ctx.GlobalString(utils.ExecFlag.Name); script != "" { 162 console.Evaluate(script) 163 return nil 164 } 165 166 // Otherwise print the welcome screen and enter interactive mode 167 console.Welcome() 168 console.Interactive() 169 170 return nil 171 } 172 173 // dialRPC returns a RPC client which connects to the given endpoint. 174 // The check for empty endpoint implements the defaulting logic 175 // for "geth attach" with no argument. 176 func dialRPC(endpoint string) (*rpc.Client, error) { 177 if endpoint == "" { 178 endpoint = node.DefaultIPCEndpoint(clientIdentifier) 179 } else if strings.HasPrefix(endpoint, "rpc:") || strings.HasPrefix(endpoint, "ipc:") { 180 // Backwards compatibility with geth < 1.5 which required 181 // these prefixes. 182 endpoint = endpoint[4:] 183 } 184 return rpc.Dial(endpoint) 185 } 186 187 // ephemeralConsole starts a new geth node, attaches an ephemeral JavaScript 188 // console to it, executes each of the files specified as arguments and tears 189 // everything down. 190 func ephemeralConsole(ctx *cli.Context) error { 191 // Create and start the node based on the CLI flags 192 stack, backend := makeFullNode(ctx) 193 startNode(ctx, stack, backend) 194 defer stack.Close() 195 196 // Attach to the newly started node and start the JavaScript console 197 client, err := stack.Attach() 198 if err != nil { 199 utils.Fatalf("Failed to attach to the inproc geth: %v", err) 200 } 201 config := console.Config{ 202 DataDir: utils.MakeDataDir(ctx), 203 DocRoot: ctx.GlobalString(utils.JSpathFlag.Name), 204 Client: client, 205 Preload: utils.MakeConsolePreloads(ctx), 206 } 207 208 console, err := console.New(config) 209 if err != nil { 210 utils.Fatalf("Failed to start the JavaScript console: %v", err) 211 } 212 defer console.Stop(false) 213 214 // Evaluate each of the specified JavaScript files 215 for _, file := range ctx.Args() { 216 if err = console.Execute(file); err != nil { 217 utils.Fatalf("Failed to execute %s: %v", file, err) 218 } 219 } 220 221 go func() { 222 stack.Wait() 223 console.Stop(false) 224 }() 225 console.Stop(true) 226 227 return nil 228 }