mirror
/
go-ethereum
mirror of https://github.com/ethereum/go-ethereum
2
0
Fork 1
Code Issues Releases Wiki Activity

a

Browse Source
pull/29330/head
a 6 months ago
parent 15e5e6176b
commit 63a060d8ed
No known key found for this signature in database
GPG Key ID: 374BC539FE795AF0
11 changed files with 65 additions and 40 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 2
      cmd/clef/main.go
  2. 1
      cmd/geth/main.go
  3. 18
      cmd/utils/flags.go
  4. 12
      node/api.go
  5. 20
      node/api_test.go
  6. 4
      node/config.go
  7. 1
      node/defaults.go
  8. 4
      node/endpoints.go
  9. 8
      node/node.go
  10. 9
      node/rpcstack.go
  11. 2
      node/rpcstack_test.go

2
cmd/clef/main.go
Unescape View File

@ -743,7 +743,7 @@ func signer(c *cli.Context) error {
// start http server
httpEndpoint := fmt.Sprintf("%s:%d", c.String(utils.HTTPListenAddrFlag.Name), port)
httpServer, addr, err := node.StartHTTPEndpoint(httpEndpoint, rpc.DefaultHTTPTimeouts, handler)
httpServer, addr, err := node.StartHTTPEndpoint(httpEndpoint, c.String(utils.HTTPListenProtocolFlag.Name), rpc.DefaultHTTPTimeouts, handler)
if err != nil {
utils.Fatalf("Could not start RPC api: %v", err)
}

1
cmd/geth/main.go
Unescape View File

@ -155,6 +155,7 @@ var (
rpcFlags = []cli.Flag{
utils.HTTPEnabledFlag,
utils.HTTPListenAddrFlag,
utils.HTTPListenProtocolFlag,
utils.HTTPPortFlag,
utils.HTTPCORSDomainFlag,
utils.AuthListenFlag,

18
cmd/utils/flags.go
Unescape View File

@ -28,6 +28,7 @@ import (
"math/big"
"net/http"
"os"
"path"
"path/filepath"
godebug "runtime/debug"
"strconv"
@ -689,6 +690,12 @@ var (
Value: node.DefaultHTTPHost,
Category: flags.APICategory,
}
HTTPListenProtocolFlag = &cli.StringFlag{
Name: "http.proto",
Usage: "HTTP-RPC server listening protocol (tcp,unix)",
Value: node.DefaultHTTPProtocol,
Category: flags.APICategory,
}
HTTPPortFlag = &cli.IntFlag{
Name: "http.port",
Usage: "HTTP-RPC server listening port",
@ -1169,11 +1176,22 @@ func SplitAndTrim(input string) (ret []string) {
// command line flags, returning empty if the HTTP endpoint is disabled.
func setHTTP(ctx *cli.Context, cfg *node.Config) {
if ctx.Bool(HTTPEnabledFlag.Name) && cfg.HTTPHost == "" {
if HTTPListenProtocolFlag.Name == "unix" {
cfg.HTTPHost = path.Join(os.TempDir(), "geth.http.sock")
} else {
cfg.HTTPHost = "127.0.0.1"
if ctx.IsSet(HTTPListenAddrFlag.Name) {
cfg.HTTPHost = ctx.String(HTTPListenAddrFlag.Name)
}
}
}
if ctx.IsSet(HTTPListenProtocolFlag.Name) {
cfg.HTTPProto = ctx.String(HTTPListenProtocolFlag.Name)
} else {
cfg.HTTPProto = "tcp"
}
if ctx.IsSet(HTTPPortFlag.Name) {
cfg.HTTPPort = ctx.Int(HTTPPortFlag.Name)

12
node/api.go
Unescape View File

@ -155,7 +155,7 @@ func (api *adminAPI) PeerEvents(ctx context.Context) (*rpc.Subscription, error)
}
// StartHTTP starts the HTTP RPC API server.
func (api *adminAPI) StartHTTP(host *string, port *int, cors *string, apis *string, vhosts *string) (bool, error) {
func (api *adminAPI) StartHTTP(proto *string, host *string, port *int, cors *string, apis *string, vhosts *string) (bool, error) {
api.node.lock.Lock()
defer api.node.lock.Unlock()
@ -196,7 +196,7 @@ func (api *adminAPI) StartHTTP(host *string, port *int, cors *string, apis *stri
}
}
if err := api.node.http.setListenAddr(*host, *port); err != nil {
if err := api.node.http.setListenAddr(*proto, *host, *port); err != nil {
return false, err
}
if err := api.node.http.enableRPC(api.node.rpcAPIs, config); err != nil {
@ -210,9 +210,9 @@ func (api *adminAPI) StartHTTP(host *string, port *int, cors *string, apis *stri
// StartRPC starts the HTTP RPC API server.
// Deprecated: use StartHTTP instead.
func (api *adminAPI) StartRPC(host *string, port *int, cors *string, apis *string, vhosts *string) (bool, error) {
func (api *adminAPI) StartRPC(proto *string, host *string, port *int, cors *string, apis *string, vhosts *string) (bool, error) {
log.Warn("Deprecation warning", "method", "admin.StartRPC", "use-instead", "admin.StartHTTP")
return api.StartHTTP(host, port, cors, apis, vhosts)
return api.StartHTTP(proto, host, port, cors, apis, vhosts)
}
// StopHTTP shuts down the HTTP server.
@ -229,7 +229,7 @@ func (api *adminAPI) StopRPC() (bool, error) {
}
// StartWS starts the websocket RPC API server.
func (api *adminAPI) StartWS(host *string, port *int, allowedOrigins *string, apis *string) (bool, error) {
func (api *adminAPI) StartWS(proto *string, host *string, port *int, allowedOrigins *string, apis *string) (bool, error) {
api.node.lock.Lock()
defer api.node.lock.Unlock()
@ -266,7 +266,7 @@ func (api *adminAPI) StartWS(host *string, port *int, allowedOrigins *string, ap
// Enable WebSocket on the server.
server := api.node.wsServerForPort(*port, false)
if err := server.setListenAddr(*host, *port); err != nil {
if err := server.setListenAddr(*proto, *host, *port); err != nil {
return false, err
}
openApis, _ := api.node.getAPIs()

20
node/api_test.go
Unescape View File

@ -69,7 +69,7 @@ func TestStartRPC(t *testing.T) {
name: "rpc enabled through API",
cfg: Config{},
fn: func(t *testing.T, n *Node, api *adminAPI) {
_, err := api.StartHTTP(sp("127.0.0.1"), ip(0), nil, nil, nil)
_, err := api.StartHTTP(sp("tcp"), sp("127.0.0.1"), ip(0), nil, nil, nil)
assert.NoError(t, err)
},
wantReachable: true,
@ -90,14 +90,14 @@ func TestStartRPC(t *testing.T) {
port := listener.Addr().(*net.TCPAddr).Port
// Now try to start RPC on that port. This should fail.
_, err = api.StartHTTP(sp("127.0.0.1"), ip(port), nil, nil, nil)
_, err = api.StartHTTP(sp("tcp"), sp("127.0.0.1"), ip(port), nil, nil, nil)
if err == nil {
t.Fatal("StartHTTP should have failed on port", port)
}
// Try again after unblocking the port. It should work this time.
listener.Close()
_, err = api.StartHTTP(sp("127.0.0.1"), ip(port), nil, nil, nil)
_, err = api.StartHTTP(sp("tcp"), sp("127.0.0.1"), ip(port), nil, nil, nil)
assert.NoError(t, err)
},
wantReachable: true,
@ -144,7 +144,7 @@ func TestStartRPC(t *testing.T) {
name: "ws enabled through API",
cfg: Config{},
fn: func(t *testing.T, n *Node, api *adminAPI) {
_, err := api.StartWS(sp("127.0.0.1"), ip(0), nil, nil)
_, err := api.StartWS(sp("tcp"), sp("127.0.0.1"), ip(0), nil, nil)
assert.NoError(t, err)
},
wantReachable: true,
@ -184,7 +184,7 @@ func TestStartRPC(t *testing.T) {
cfg: Config{HTTPHost: "127.0.0.1"},
fn: func(t *testing.T, n *Node, api *adminAPI) {
wsport := n.http.port
_, err := api.StartWS(sp("127.0.0.1"), ip(wsport), nil, nil)
_, err := api.StartWS(sp("tcp"), sp("127.0.0.1"), ip(wsport), nil, nil)
assert.NoError(t, err)
},
wantReachable: true,
@ -197,7 +197,7 @@ func TestStartRPC(t *testing.T) {
cfg: Config{HTTPHost: "127.0.0.1"},
fn: func(t *testing.T, n *Node, api *adminAPI) {
wsport := n.http.port
_, err := api.StartWS(sp("127.0.0.1"), ip(wsport), nil, nil)
_, err := api.StartWS(sp("tcp"), sp("127.0.0.1"), ip(wsport), nil, nil)
assert.NoError(t, err)
_, err = api.StopWS()
@ -211,11 +211,11 @@ func TestStartRPC(t *testing.T) {
{
name: "rpc stopped with ws enabled",
fn: func(t *testing.T, n *Node, api *adminAPI) {
_, err := api.StartHTTP(sp("127.0.0.1"), ip(0), nil, nil, nil)
_, err := api.StartHTTP(sp("tcp"), sp("127.0.0.1"), ip(0), nil, nil, nil)
assert.NoError(t, err)
wsport := n.http.port
_, err = api.StartWS(sp("127.0.0.1"), ip(wsport), nil, nil)
_, err = api.StartWS(sp("tcp"), sp("127.0.0.1"), ip(wsport), nil, nil)
assert.NoError(t, err)
_, err = api.StopHTTP()
@ -229,11 +229,11 @@ func TestStartRPC(t *testing.T) {
{
name: "rpc enabled after ws",
fn: func(t *testing.T, n *Node, api *adminAPI) {
_, err := api.StartWS(sp("127.0.0.1"), ip(0), nil, nil)
_, err := api.StartWS(sp("tcp"), sp("127.0.0.1"), ip(0), nil, nil)
assert.NoError(t, err)
wsport := n.http.port
_, err = api.StartHTTP(sp("127.0.0.1"), ip(wsport), nil, nil, nil)
_, err = api.StartHTTP(sp("tcp"), sp("127.0.0.1"), ip(wsport), nil, nil, nil)
assert.NoError(t, err)
},
wantReachable: true,

4
node/config.go
Unescape View File

@ -105,6 +105,10 @@ type Config struct {
// field is empty, no HTTP API endpoint will be started.
HTTPHost string
// HTTPProto is the protocol on which the HTTP RPC server will bind.
// Supported values are tcp, unix. HTTPPort is ignored if HTTPProto == unix
HTTPProto string
// HTTPPort is the TCP port number on which to start the HTTP RPC server. The
// default zero value is/ valid and will pick a port number randomly (useful
// for ephemeral nodes).

1
node/defaults.go
Unescape View File

@ -28,6 +28,7 @@ import (
)
const (
DefaultHTTPProtocol = "tcp" // Default protocol for the HTTP RPC SERVER
DefaultHTTPHost = "localhost" // Default host interface for the HTTP RPC server
DefaultHTTPPort = 8545 // Default TCP port for the HTTP RPC server
DefaultWSHost = "localhost" // Default host interface for the websocket RPC server

4
node/endpoints.go
Unescape View File

@ -26,13 +26,13 @@ import (
)
// StartHTTPEndpoint starts the HTTP RPC endpoint.
func StartHTTPEndpoint(endpoint string, timeouts rpc.HTTPTimeouts, handler http.Handler) (*http.Server, net.Addr, error) {
func StartHTTPEndpoint(endpoint string, protocol string, timeouts rpc.HTTPTimeouts, handler http.Handler) (*http.Server, net.Addr, error) {
// start the HTTP listener
var (
listener net.Listener
err error
)
if listener, err = net.Listen("tcp", endpoint); err != nil {
if listener, err = net.Listen(protocol, endpoint); err != nil {
return nil, nil, err
}
// make sure timeout values are meaningful

8
node/node.go
Unescape View File

@ -404,7 +404,7 @@ func (n *Node) startRPC() error {
)
initHttp := func(server *httpServer, port int) error {
if err := server.setListenAddr(n.config.HTTPHost, port); err != nil {
if err := server.setListenAddr(n.config.HTTPProto, n.config.HTTPHost, port); err != nil {
return err
}
if err := server.enableRPC(openAPIs, httpConfig{
@ -421,7 +421,7 @@ func (n *Node) startRPC() error {
initWS := func(port int) error {
server := n.wsServerForPort(port, false)
if err := server.setListenAddr(n.config.WSHost, port); err != nil {
if err := server.setListenAddr(n.config.HTTPProto, n.config.WSHost, port); err != nil {
return err
}
if err := server.enableWS(openAPIs, wsConfig{
@ -438,7 +438,7 @@ func (n *Node) startRPC() error {
initAuth := func(port int, secret []byte) error {
// Enable auth via HTTP
server := n.httpAuth
if err := server.setListenAddr(n.config.AuthAddr, port); err != nil {
if err := server.setListenAddr(n.config.HTTPProto, n.config.AuthAddr, port); err != nil {
return err
}
if err := server.enableRPC(allAPIs, httpConfig{
@ -453,7 +453,7 @@ func (n *Node) startRPC() error {
servers = append(servers, server)
// Enable auth via WS
server = n.wsServerForPort(port, true)
if err := server.setListenAddr(n.config.AuthAddr, port); err != nil {
if err := server.setListenAddr(n.config.HTTPProto, n.config.AuthAddr, port); err != nil {
return err
}
if err := server.enableWS(allAPIs, wsConfig{

9
node/rpcstack.go
Unescape View File

@ -77,6 +77,7 @@ type httpServer struct {
// These are set by setListenAddr.
endpoint string
proto string
host string
port int
@ -97,15 +98,15 @@ func newHTTPServer(log log.Logger, timeouts rpc.HTTPTimeouts) *httpServer {
// setListenAddr configures the listening address of the server.
// The address can only be set while the server isn't running.
func (h *httpServer) setListenAddr(host string, port int) error {
func (h *httpServer) setListenAddr(proto string, host string, port int) error {
h.mu.Lock()
defer h.mu.Unlock()
if h.listener != nil && (host != h.host || port != h.port) {
if h.listener != nil && (host != h.host || port != h.port || proto != h.proto) {
return fmt.Errorf("HTTP server already running on %s", h.endpoint)
}
h.host, h.port = host, port
h.proto, h.host, h.port = proto, host, port
h.endpoint = fmt.Sprintf("%s:%d", host, port)
return nil
}
@ -141,7 +142,7 @@ func (h *httpServer) start() error {
}
// Start the server.
listener, err := net.Listen("tcp", h.endpoint)
listener, err := net.Listen(h.proto, h.endpoint)
if err != nil {
// If the server fails to start, we need to clear out the RPC and WS
// configuration so they can be configured another time.

2
node/rpcstack_test.go
Unescape View File

@ -246,7 +246,7 @@ func createAndStartServer(t *testing.T, conf *httpConfig, ws bool, wsConf *wsCon
if ws {
assert.NoError(t, srv.enableWS(nil, *wsConf))
}
assert.NoError(t, srv.setListenAddr("localhost", 0))
assert.NoError(t, srv.setListenAddr("tcp", "localhost", 0))
assert.NoError(t, srv.start())
return srv
}

Write Preview
Loading…
Cancel
Save