github.com/benorgera/go-ethereum@v1.10.18-0.20220401011646-b3f57b1a73ba/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, true) 81 defer stack.Close() 82 83 // Attach to the newly started node and create the JavaScript console. 84 client, err := stack.Attach() 85 if err != nil { 86 return fmt.Errorf("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 console, err := console.New(config) 95 if err != nil { 96 return fmt.Errorf("Failed to start the JavaScript console: %v", err) 97 } 98 defer console.Stop(false) 99 100 // If only a short execution was requested, evaluate and return. 101 if script := ctx.GlobalString(utils.ExecFlag.Name); script != "" { 102 console.Evaluate(script) 103 return nil 104 } 105 106 // Track node shutdown and stop the console when it goes down. 107 // This happens when SIGTERM is sent to the process. 108 go func() { 109 stack.Wait() 110 console.StopInteractive() 111 }() 112 113 // Print the welcome screen and enter interactive mode. 114 console.Welcome() 115 console.Interactive() 116 return nil 117 } 118 119 // remoteConsole will connect to a remote geth instance, attaching a JavaScript 120 // console to it. 121 func remoteConsole(ctx *cli.Context) error { 122 endpoint := ctx.Args().First() 123 if endpoint == "" { 124 path := node.DefaultDataDir() 125 if ctx.GlobalIsSet(utils.DataDirFlag.Name) { 126 path = ctx.GlobalString(utils.DataDirFlag.Name) 127 } 128 if path != "" { 129 if ctx.GlobalBool(utils.RopstenFlag.Name) { 130 // Maintain compatibility with older Geth configurations storing the 131 // Ropsten database in `testnet` instead of `ropsten`. 132 legacyPath := filepath.Join(path, "testnet") 133 if _, err := os.Stat(legacyPath); !os.IsNotExist(err) { 134 path = legacyPath 135 } else { 136 path = filepath.Join(path, "ropsten") 137 } 138 } else if ctx.GlobalBool(utils.RinkebyFlag.Name) { 139 path = filepath.Join(path, "rinkeby") 140 } else if ctx.GlobalBool(utils.GoerliFlag.Name) { 141 path = filepath.Join(path, "goerli") 142 } else if ctx.GlobalBool(utils.SepoliaFlag.Name) { 143 path = filepath.Join(path, "sepolia") 144 } 145 } 146 endpoint = fmt.Sprintf("%s/geth.ipc", path) 147 } 148 client, err := dialRPC(endpoint) 149 if err != nil { 150 utils.Fatalf("Unable to attach to remote geth: %v", err) 151 } 152 config := console.Config{ 153 DataDir: utils.MakeDataDir(ctx), 154 DocRoot: ctx.GlobalString(utils.JSpathFlag.Name), 155 Client: client, 156 Preload: utils.MakeConsolePreloads(ctx), 157 } 158 console, err := console.New(config) 159 if err != nil { 160 utils.Fatalf("Failed to start the JavaScript console: %v", err) 161 } 162 defer console.Stop(false) 163 164 if script := ctx.GlobalString(utils.ExecFlag.Name); script != "" { 165 console.Evaluate(script) 166 return nil 167 } 168 169 // Otherwise print the welcome screen and enter interactive mode 170 console.Welcome() 171 console.Interactive() 172 return nil 173 } 174 175 // dialRPC returns a RPC client which connects to the given endpoint. 176 // The check for empty endpoint implements the defaulting logic 177 // for "geth attach" with no argument. 178 func dialRPC(endpoint string) (*rpc.Client, error) { 179 if endpoint == "" { 180 endpoint = node.DefaultIPCEndpoint(clientIdentifier) 181 } else if strings.HasPrefix(endpoint, "rpc:") || strings.HasPrefix(endpoint, "ipc:") { 182 // Backwards compatibility with geth < 1.5 which required 183 // these prefixes. 184 endpoint = endpoint[4:] 185 } 186 return rpc.Dial(endpoint) 187 } 188 189 // ephemeralConsole starts a new geth node, attaches an ephemeral JavaScript 190 // console to it, executes each of the files specified as arguments and tears 191 // everything down. 192 func ephemeralConsole(ctx *cli.Context) error { 193 // Create and start the node based on the CLI flags 194 stack, backend := makeFullNode(ctx) 195 startNode(ctx, stack, backend, false) 196 defer stack.Close() 197 198 // Attach to the newly started node and start the JavaScript console 199 client, err := stack.Attach() 200 if err != nil { 201 return fmt.Errorf("Failed to attach to the inproc geth: %v", err) 202 } 203 config := console.Config{ 204 DataDir: utils.MakeDataDir(ctx), 205 DocRoot: ctx.GlobalString(utils.JSpathFlag.Name), 206 Client: client, 207 Preload: utils.MakeConsolePreloads(ctx), 208 } 209 210 console, err := console.New(config) 211 if err != nil { 212 return fmt.Errorf("Failed to start the JavaScript console: %v", err) 213 } 214 defer console.Stop(false) 215 216 // Interrupt the JS interpreter when node is stopped. 217 go func() { 218 stack.Wait() 219 console.Stop(false) 220 }() 221 222 // Evaluate each of the specified JavaScript files. 223 for _, file := range ctx.Args() { 224 if err = console.Execute(file); err != nil { 225 return fmt.Errorf("Failed to execute %s: %v", file, err) 226 } 227 } 228 229 // The main script is now done, but keep running timers/callbacks. 230 console.Stop(true) 231 return nil 232 }