cfg "github.com/bytom/config"
"github.com/bytom/env"
"github.com/bytom/errors"
- "github.com/bytom/net/http/authn"
"github.com/bytom/p2p"
"github.com/bytom/protocol"
"github.com/bytom/types"
+ "github.com/bytom/util/browser"
"github.com/bytom/version"
)
const (
- httpReadTimeout = 2 * time.Minute
- httpWriteTimeout = time.Hour
+ httpReadTimeout = 2 * time.Minute
+ httpWriteTimeout = time.Hour
+ webAddress = "http://127.0.0.1:9888"
+ expireReservationsPeriod = time.Second
)
type Node struct {
wh.h.ServeHTTP(w, req)
}
-func AuthHandler(handler http.Handler, accessTokens *accesstoken.CredentialStore) http.Handler {
-
- authenticator := authn.NewAPI(accessTokens)
-
- return http.HandlerFunc(func(rw http.ResponseWriter, req *http.Request) {
- // TODO(tessr): check that this path exists; return early if this path isn't legit
- req, err := authenticator.Authenticate(req)
- if err != nil {
- log.WithField("error", errors.Wrap(err, "Serve")).Error("Authenticate fail")
-
- return
- }
- handler.ServeHTTP(rw, req)
- })
-}
-
func rpcInit(h *bc.BlockchainReactor, config *cfg.Config, accessTokens *accesstoken.CredentialStore) {
// The waitHandler accepts incoming requests, but blocks until its underlying
// handler is set, when the second phase is complete.
mux.Handle("/", &coreHandler)
var handler http.Handler = mux
- handler = AuthHandler(handler, accessTokens)
+
+ if config.Auth.Disable == false {
+ handler = bc.AuthHandler(handler, accessTokens)
+ }
handler = RedirectHandler(handler)
secureheader.DefaultConfig.PermitClearLoopback = true
TLSNextProto: map[string]func(*http.Server, *tls.Conn, http.Handler){},
}
listenAddr := env.String("LISTEN", config.ApiAddress)
+ log.WithField("api address:", config.ApiAddress).Info("Rpc listen")
listener, err := net.Listen("tcp", *listenAddr)
if err != nil {
cmn.Exit(cmn.Fmt("Failed to register tcp port: %v", err))
cmn.Exit(cmn.Fmt("Failed to create chain structure: %v", err))
}
- if chain.Height() == 0 {
+ if chain.BestBlockHash() == nil {
if err := chain.SaveBlock(genesisBlock); err != nil {
cmn.Exit(cmn.Fmt("Failed to save genesisBlock to store: %v", err))
}
return nil
}
- if config.Wallet.Enable {
- accountsDB := dbm.NewDB("account", config.DBBackend, config.DBDir())
- assetsDB := dbm.NewDB("asset", config.DBBackend, config.DBDir())
- walletDB := dbm.NewDB("wallet", config.DBBackend, config.DBDir())
-
- accounts = account.NewManager(accountsDB, walletDB, w.GetWalletHeight, chain)
- assets = asset.NewRegistry(assetsDB, chain)
-
- wallet = w.InitWallet(walletDB, accounts, assets)
- wallet.Ind.RegisterAnnotator(accounts.AnnotateTxs)
- wallet.Ind.RegisterAnnotator(assets.AnnotateTxs)
-
- go wallet.WalletUpdate(chain)
-
- }
- //Todo HSM
- /*
- if config.HsmUrl != ""{
- // todo remoteHSM
- cmn.Exit(cmn.Fmt("not implement"))
- } else {
- hsm, err = pseudohsm.New(config.KeysDir())
- if err != nil {
- cmn.Exit(cmn.Fmt("initialize HSM failed: %v", err))
- }
- }*/
-
hsm, err := pseudohsm.New(config.KeysDir())
if err != nil {
cmn.Exit(cmn.Fmt("initialize HSM failed: %v", err))
}
- bcReactor := bc.NewBlockchainReactor(chain, txPool, accounts, assets, sw, hsm, wallet, txFeed, accessTokens)
+
+ if !config.Wallet.Disable {
+ xpubs, _ := hsm.ListKeys()
+ walletDB := dbm.NewDB("wallet", config.DBBackend, config.DBDir())
+ accounts = account.NewManager(walletDB, chain)
+ assets = asset.NewRegistry(walletDB, chain)
+ wallet, err = w.NewWallet(walletDB, accounts, assets, chain, xpubs)
+ if err != nil {
+ log.WithField("error", err).Error("init NewWallet")
+ }
+ // Clean up expired UTXO reservations periodically.
+ go accounts.ExpireReservations(ctx, expireReservationsPeriod)
+ }
+
+ bcReactor := bc.NewBlockchainReactor(chain, txPool, accounts, assets, sw, hsm, wallet, txFeed, accessTokens, config.Mining)
sw.AddReactor("BLOCKCHAIN", bcReactor)
assets: assets,
}
node.BaseService = *cmn.NewBaseService(nil, "Node", node)
+
return node
}
+// Lanch web broser or not
+func lanchWebBroser(lanch bool) {
+ if lanch {
+ log.Info("Launching System Browser with :", webAddress)
+ if err := browser.Open(webAddress); err != nil {
+ log.Error(err.Error())
+ return
+ }
+ }
+}
+
func (n *Node) OnStart() error {
// Create & add listener
- protocol, address := ProtocolAndAddress(n.config.P2P.ListenAddress)
- l := p2p.NewDefaultListener(protocol, address, n.config.P2P.SkipUPNP, nil)
+ p, address := ProtocolAndAddress(n.config.P2P.ListenAddress)
+ l := p2p.NewDefaultListener(p, address, n.config.P2P.SkipUPNP, nil)
n.sw.AddListener(l)
// Start the switch
return err
}
}
+ lanchWebBroser(!n.config.Web.Closed)
return nil
}
})
}
-// Add the event switch to reactors, mempool, etc.
-func SetEventSwitch(evsw types.EventSwitch, eventables ...types.Eventable) {
- for _, e := range eventables {
- e.SetEventSwitch(evsw)
- }
-}
-
// Add a Listener to accept inbound peer connections.
// Add listeners before starting the Node.
// The first listener is the primary listener (in NodeInfo)
// Defaults to tcp
func ProtocolAndAddress(listenAddr string) (string, string) {
- protocol, address := "tcp", listenAddr
+ p, address := "tcp", listenAddr
parts := strings.SplitN(address, "://", 2)
if len(parts) == 2 {
- protocol, address = parts[0], parts[1]
+ p, address = parts[0], parts[1]
}
- return protocol, address
+ return p, address
}
//------------------------------------------------------------------------------
OSDN Git Service
