空标题文档

// Node is a container on which services can be registered. type Node struct { eventmux event.TypeMux // Event multiplexer used between the services of a stack config Config accman *accounts.Manager

ephemeralKeystore string         // if non-empty, the key directory that will be removed by Stop
instanceDirLock   flock.Releaser // prevents concurrent use of instance directory
serverConfig p2p.Config
server       *p2p.Server // Currently running P2P networking layer
serviceFuncs []ServiceConstructor     // Service constructors (in dependency order)
services     map[reflect.Type]Service // Currently running services
rpcAPIs       []rpc.API   // List of APIs currently provided by the node
inprocHandler *rpc.Server // In-process RPC request handler to process the API requests
ipcEndpoint string       // IPC endpoint to listen at (empty = IPC disabled)
ipcListener net.Listener // IPC RPC listener socket to serve API requests
ipcHandler  *rpc.Server  // IPC RPC request handler to process the API requests
httpEndpoint  string       // HTTP endpoint (interface + port) to listen at (empty = HTTP disabled)
httpWhitelist []string     // HTTP RPC modules to allow through this endpoint
httpListener  net.Listener // HTTP RPC listener socket to server API requests
httpHandler   *rpc.Server  // HTTP RPC request handler to process the API requests
wsEndpoint string       // Websocket endpoint (interface + port) to listen at (empty = websocket disabled)
wsListener net.Listener // Websocket RPC listener socket to server API requests
wsHandler  *rpc.Server  // Websocket RPC request handler to process the API requests
stop chan struct{} // Channel to wait for termination notifications
lock sync.RWMutex
log log.Logger

}

创建p2p node // New creates a new P2P node, ready for protocol registration. func New(conf Config) (Node, error) { // Copy config and resolve the datadir so future changes to the current // working directory don’t affect the node. confCopy := *conf conf = &confCopy if conf.DataDir != “” { absdatadir, err := filepath.Abs(conf.DataDir) if err != nil { return nil, err } conf.DataDir = absdatadir } // 排除冲突 // Ensure that the instance name doesn’t cause weird conflicts with // other files in the data directory. if strings.ContainsAny(conf.Name, /\) { return nil, errors.New(Config.Name must not contain '/' or '\') } if conf.Name == datadirDefaultKeyStore { return nil, errors.New(Config.Name cannot be " + datadirDefaultKeyStore + ") } if strings.HasSuffix(conf.Name, “.ipc”) { return nil, errors.New(Config.Name cannot end in ".ipc") } // 创建AccountManager // Ensure that the AccountManager method works before the node has started. // We rely on this in cmd/geth. am, ephemeralKeystore, err := makeAccountManager(conf) if err != nil { return nil, err } if conf.Logger == nil { conf.Logger = log.New() } // Note: any interaction with Config that would create/touch files // in the data directory or instance directory is delayed until Start. return &Node{ accman: am, ephemeralKeystore: ephemeralKeystore, config: conf, serviceFuncs: []ServiceConstructor{}, ipcEndpoint: conf.IPCEndpoint(), httpEndpoint: conf.HTTPEndpoint(), wsEndpoint: conf.WSEndpoint(), eventmux: new(event.TypeMux), log: conf.Logger, }, nil }

func makeAccountManager(conf Config) (accounts.Manager, string, error) { scryptN, scryptP, keydir, err := conf.AccountConfig() var ephemeral string if keydir == “” { // There is no datadir. keydir, err = ioutil.TempDir(“”, “go-ethereum-keystore”) ephemeral = keydir }

if err != nil {
    return nil, "", err
}
if err := os.MkdirAll(keydir, 0700); err != nil {
    return nil, "", err
}
// Assemble the account manager and supported backends
backends := []accounts.Backend{
    keystore.NewKeyStore(keydir, scryptN, scryptP),
}
if !conf.NoUSB {
    // Start a USB hub for Ledger hardware wallets
    if ledgerhub, err := usbwallet.NewLedgerHub(); err != nil {
        log.Warn(fmt.Sprintf("Failed to start Ledger hub, disabling: %v", err))
    } else {
        backends = append(backends, ledgerhub)
    }
    // Start a USB hub for Trezor hardware wallets
    if trezorhub, err := usbwallet.NewTrezorHub(); err != nil {
        log.Warn(fmt.Sprintf("Failed to start Trezor hub, disabling: %v", err))
    } else {
        backends = append(backends, trezorhub)
    }
}
return accounts.NewManager(backends...), ephemeral, nil

}

创建live p2p节点，并运行他 // Start create a live P2P node and starts running it. func (n *Node) Start() error { n.lock.Lock() defer n.lock.Unlock()

// Short circuit if the node's already running
if n.server != nil {
    return ErrNodeRunning
}
if err := n.openDataDir(); err != nil {
    return err
}
// Initialize the p2p server. This creates the node key and
// discovery databases.
n.serverConfig = n.config.P2P
n.serverConfig.PrivateKey = n.config.NodeKey()
n.serverConfig.Name = n.config.NodeName()
n.serverConfig.Logger = n.log
if n.serverConfig.StaticNodes == nil {
    n.serverConfig.StaticNodes = n.config.StaticNodes()
}
if n.serverConfig.TrustedNodes == nil {
    n.serverConfig.TrustedNodes = n.config.TrustedNodes()
}
if n.serverConfig.NodeDatabase == "" {
    n.serverConfig.NodeDatabase = n.config.NodeDB()
}
running := &p2p.Server{Config: n.serverConfig}
n.log.Info("Starting peer-to-peer node", "instance", n.serverConfig.Name)
// Otherwise copy and specialize the P2P configuration
services := make(map[reflect.Type]Service)
for _, constructor := range n.serviceFuncs {
    // Create a new context for the particular service
    ctx := &ServiceContext{
        config:         n.config,
        services:       make(map[reflect.Type]Service),
        EventMux:       n.eventmux,
        AccountManager: n.accman,
    }
    for kind, s := range services { // copy needed for threaded access
        ctx.services[kind] = s
    }
    // Construct and save the service
    service, err := constructor(ctx)
    if err != nil {
        return err
    }
    kind := reflect.TypeOf(service)
    if _, exists := services[kind]; exists {
        return &DuplicateServiceError{Kind: kind}
    }
    services[kind] = service
}
// Gather the protocols and start the freshly assembled P2P server
for _, service := range services {
    running.Protocols = append(running.Protocols, service.Protocols()...)
}
if err := running.Start(); err != nil {
    return convertFileLockError(err)
}
// Start each of the services
started := []reflect.Type{}
for kind, service := range services {
    // Start the next service, stopping all previous upon failure
    if err := service.Start(running); err != nil {
        for _, kind := range started {
            services[kind].Stop()
        }
        running.Stop()
        return err
    }
    // Mark the service started for potential cleanup
    started = append(started, kind)
}
// Lastly start the configured RPC interfaces
if err := n.startRPC(services); err != nil {
    for _, service := range services {
        service.Stop()
    }
    running.Stop()
    return err
}
// Finish initializing the startup
n.services = services
n.server = running
n.stop = make(chan struct{})
return nil

}