Method Start

node/node.go:128–232

Start creates a p2p node and begins the service

()

// Start creates a p2p node and begins the service
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
	}

	// p2p setup
	n.serverConfig = n.config.P2P
	n.serverConfig.Name = n.config.NodeName()
	n.serverConfig.Logger = n.log
	n.serverConfig.PrivateKey = n.config.NodeKey()
	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 == "" {
		// e.g., cpchain/nodes directory
		n.serverConfig.NodeDatabase = n.config.NodeDB()
	}
	p2pServer := &p2p.Server{Config: n.serverConfig}
	n.log.Info("Starting peer-to-peer node", "instance", n.serverConfig.Name)

	// create the services
	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 {
			ctx.services[kind] = s
		}
		// construct and save the service
		service, err := constructor(ctx)
		if err != nil {
			return err
		}
		kind := reflect.TypeOf(service)
		if _, ok := services[kind]; ok {
			return &DuplicateServiceError{Kind: kind}
		}
		// accumulates the constructed services.
		services[kind] = service
	}

	// gather the protocols and start the freshly assembled P2P server