github.com/bigzoro/my_simplechain@v0.0.0-20240315012955-8ad0a2a29bb9/permission/service.go (about) 1 package permission 2 3 import ( 4 "crypto/ecdsa" 5 "errors" 6 "fmt" 7 "math/big" 8 "strings" 9 "time" 10 11 "github.com/bigzoro/my_simplechain/accounts" 12 "github.com/bigzoro/my_simplechain/accounts/abi/bind" 13 "github.com/bigzoro/my_simplechain/accounts/keystore" 14 "github.com/bigzoro/my_simplechain/common" 15 "github.com/bigzoro/my_simplechain/consensus/raft/backend" 16 "github.com/bigzoro/my_simplechain/crypto" 17 "github.com/bigzoro/my_simplechain/eth" 18 "github.com/bigzoro/my_simplechain/ethclient" 19 "github.com/bigzoro/my_simplechain/ethdb" 20 "github.com/bigzoro/my_simplechain/event" 21 "github.com/bigzoro/my_simplechain/log" 22 "github.com/bigzoro/my_simplechain/node" 23 "github.com/bigzoro/my_simplechain/p2p" 24 "github.com/bigzoro/my_simplechain/p2p/enode" 25 "github.com/bigzoro/my_simplechain/rpc" 26 ) 27 28 var ( 29 Join = 0 30 Remove = 1 31 Normal = 0 //normal node 32 Isolated = 1 33 Admin = 2 34 35 permissionContractNotSet = errors.New("the permission contract address has not been set") 36 ) 37 38 type Service struct { 39 node *node.Node 40 ethClient bind.ContractBackend 41 eth *eth.SimpleService 42 permissionContract *Permission 43 storeAbiContract *StoreAbi 44 RaftProtocolManager *backend.ProtocolManager 45 46 stopFeed event.Feed // broadcasting stopEvent when service is being stopped 47 48 permissionAddr common.Address 49 storeAbiAddr common.Address 50 stop chan struct{} 51 watching bool 52 } 53 54 func (s *Service) Start(server *p2p.Server) error { 55 s.stop = make(chan struct{}) 56 log.Debug("permission service: starting") 57 return nil 58 } 59 60 // SetContractAddress 设置权限合约地址 61 func (s *Service) SetContractAddress(addr common.Address) (bool, error) { 62 if s.watching && addr != s.permissionAddr { 63 close(s.stop) 64 //更换合约地址 65 s.permissionAddr = addr 66 permission, err := NewPermission(s.permissionAddr, s.ethClient) 67 if err != nil { 68 return false, err 69 } 70 s.permissionContract = permission 71 s.stop = make(chan struct{}) 72 go s.runPermissionVerifyNotify() 73 go s.WatchNetworkInitComplete() 74 time.Sleep(time.Second) 75 } 76 if !s.watching { 77 s.permissionAddr = addr 78 permission, err := NewPermission(s.permissionAddr, s.ethClient) 79 if err != nil { 80 return false, err 81 } 82 s.permissionContract = permission 83 s.stop = make(chan struct{}) 84 go s.runPermissionVerifyNotify() 85 go s.WatchNetworkInitComplete() 86 time.Sleep(time.Second) 87 } 88 //将权限合约地址写入数据库中 89 err := storeContractAddress(permissionKey, addr, s.GetCommonDb()) 90 if err != nil { 91 return false, err 92 } 93 log.Info("show syncNodeId in SetContractAddress") 94 s.syncNodeId() 95 return true, nil 96 } 97 func (s *Service) APIs() []rpc.API { 98 return []rpc.API{ 99 { 100 Namespace: "permission", 101 Version: "1.0", 102 Service: NewQuorumControlsAPI(s), 103 Public: true, 104 }, 105 } 106 } 107 108 // GetPermissionContract 获取权限合约实例 109 func (s *Service) GetPermissionContract() (*Permission, error) { 110 if s.permissionContract == nil && s.permissionAddr != (common.Address{}) && s.ethClient != nil { 111 permission, err := NewPermission(s.permissionAddr, s.ethClient) 112 if err != nil { 113 return nil, err 114 } 115 s.permissionContract = permission 116 } 117 if s.permissionContract == nil { 118 return nil, errors.New("no permission contract") 119 } 120 return s.permissionContract, nil 121 } 122 123 func (s *Service) Protocols() []p2p.Protocol { 124 return []p2p.Protocol{} 125 } 126 127 func (s *Service) Stop() error { 128 log.Info("permission service: stopping") 129 close(s.stop) 130 log.Info("permission service: stopped") 131 return nil 132 } 133 134 func NewQuorumControlsAPI(s *Service) *QuorumControlsAPI { 135 return &QuorumControlsAPI{s} 136 } 137 func NewPermissionService(stack *node.Node, ethereum *eth.SimpleService) (*Service, error) { 138 s := &Service{ 139 node: stack, 140 eth: ethereum, 141 } 142 return s, nil 143 } 144 func (s *Service) getAuth(from common.Address) (*bind.TransactOpts, error) { 145 privateKey, err := s.getPrivateKey(from) 146 if err != nil { 147 return nil, err 148 } 149 auth, err := bind.NewKeyedTransactorWithChainID(privateKey, s.eth.ChainConfig().ChainID) 150 if err != nil { 151 return nil, err 152 } 153 auth.From = from 154 return auth, nil 155 } 156 157 func (s *Service) GetAccountManager() *accounts.Manager { 158 return s.eth.AccountManager() 159 } 160 161 func (s *Service) GetCommonDb() ethdb.Database { 162 return s.eth.CommonDb() 163 } 164 func (s *Service) getPrivateKey(addr common.Address) (*ecdsa.PrivateKey, error) { 165 account := accounts.Account{Address: addr} 166 am := s.GetAccountManager() 167 keyStore, err := fetchKeystore(am, account) 168 if err != nil { 169 return nil, err 170 } 171 privateKey, err := keyStore.GetPrivateKey(account) 172 if err != nil { 173 return nil, err 174 } 175 return privateKey, nil 176 } 177 func (s *Service) getPublicKey(addr common.Address) (string, error) { 178 account := accounts.Account{Address: addr} 179 am := s.GetAccountManager() 180 ks, err := fetchKeystore(am, account) 181 if err != nil { 182 return "", err 183 } 184 publicKey, err := ks.GetPublicKey(account) 185 if err != nil { 186 return "", err 187 } 188 return publicKey, nil 189 } 190 191 // Exit 自己退出网络 192 // leave from network by self 193 func (s *Service) Exit(from common.Address) (string, error) { 194 result := "" 195 if s.permissionContract == nil { 196 return result, permissionContractNotSet 197 } 198 fullNodeId := s.node.Server().NodeInfo().Enode 199 auth, err := s.getAuth(from) 200 if err != nil { 201 return result, err 202 } 203 tx, err := s.permissionContract.Exit(auth, fullNodeId) 204 if err != nil { 205 return result, err 206 } 207 result = tx.Hash().String() 208 return result, err 209 } 210 211 func (s *Service) Prepare() error { 212 log.Debug("permission service: binding contracts") 213 client, err := s.node.Attach() 214 if err != nil { 215 log.Error("Service Prepare", "err", err) 216 return err 217 } 218 s.ethClient = ethclient.NewClient(client) 219 //read from common db 220 addr, err := loadContractAddress(permissionKey, s.GetCommonDb()) 221 if err != nil { 222 log.Error("load permission contract address", "err", err) 223 return err 224 } 225 //if contract address exist ,then use it as permission contract address. 226 if addr != (common.Address{}) { 227 log.Info("use permission contract", "contract address", addr.String()) 228 s.permissionAddr = addr 229 permission, err := NewPermission(s.permissionAddr, s.ethClient) 230 if err != nil { 231 return err 232 } 233 s.permissionContract = permission 234 go s.runPermissionVerifyNotify() 235 go s.WatchNetworkInitComplete() 236 237 // add peer if node is in network 238 if s.eth != nil && s.eth.ChainConfig().Clique != nil { 239 go s.tryConnectNode() 240 } 241 log.Info("call syncNodeId in Prepare") 242 s.syncNodeId() 243 log.Info("permission service is now ready") 244 } 245 addr, err = loadContractAddress(storeAbiKey, s.GetCommonDb()) 246 if err != nil { 247 log.Error("load store contract address", "err", err) 248 return err 249 } 250 if addr != (common.Address{}) { 251 s.storeAbiAddr = addr 252 storeAbi, err := NewStoreAbi(s.storeAbiAddr, s.ethClient) 253 if err != nil { 254 return err 255 } 256 s.storeAbiContract = storeAbi 257 log.Info("storeAbi service is now ready") 258 } 259 return nil 260 } 261 262 func (s *Service) unlockFirstAccount() { 263 am := s.GetAccountManager() 264 ks := am.Backends(keystore.KeyStoreType)[0].(*keystore.KeyStore) 265 if len(am.Accounts()) == 0 { 266 return 267 } 268 if err := ks.TimedUnlock(accounts.Account{Address: am.Accounts()[0]}, "", 0); err != nil { 269 log.Warn("when start sipe, use empty passwd to unlock first account but fail", "error", err) 270 return 271 } 272 log.Info("unlock first account success!") 273 } 274 func (s *Service) tryConnectNode() { 275 if !s.isInitFinished() { 276 //网络初始化还没有完成,不需要 277 return 278 } 279 //本节点 280 localNode := strings.Split(s.node.Server().NodeInfo().Enode, "@")[0] 281 callOpts := &bind.CallOpts{ 282 Pending: true, 283 } 284 //从合约上查询一下自己 285 nodeId, _, _, _, _, role, _, _, err := s.permissionContract.GetNodeMap(callOpts, localNode) 286 if err != nil { 287 log.Error("query contract failed", "err", err) 288 return 289 } 290 //自己不在联盟中 291 if nodeId == "" { 292 log.Info("local node is not in network") 293 return 294 } 295 //自己是管理节点或普通节点就可以主动去连接其他节点 296 if role.Cmp(big.NewInt(int64(Normal))) == 0 || role.Cmp(big.NewInt(int64(Admin))) == 0 { 297 log.Info("try connect with others") 298 //query normal node and admin node in contract to connect 299 nodes := s.getAvailableNodes() 300 s.connectNode(nodes) 301 } 302 } 303 304 // 连接节点 305 func (s *Service) connectNode(nodes string) { 306 nodeArray := strings.Split(nodes, ",") 307 callOpts := &bind.CallOpts{ 308 Pending: true, 309 } 310 for _, v := range nodeArray { 311 if v == "" { 312 continue 313 } 314 nodeId, ip, port, _, _, _, _, _, err := s.permissionContract.GetNodeMap(callOpts, v) 315 if err != nil { 316 log.Error("connect with node failed", "err", err, "nodeId", nodeId, "ip", ip, "port", port) 317 continue 318 } 319 if nodeId == "" { 320 continue 321 } 322 url := fmt.Sprintf("%s@%s:%s", nodeId, ip, port) 323 chainNode, err := enode.Parse(enode.ValidSchemes, url) 324 if err != nil { 325 log.Error("enode.Parse failed", "error", err, "url", url) 326 continue 327 } 328 s.node.Server().AddPeer(chainNode) 329 } 330 } 331 332 // 获取可以连接的节点(包括普通节点和管理员节点) 333 func (s *Service) getAvailableNodes() string { 334 var ret string 335 callOpts := &bind.CallOpts{ 336 Pending: true, 337 } 338 //获取普通节点 339 normalNodes, err := s.permissionContract.GetNodeByRole(callOpts, big.NewInt(int64(Normal))) 340 if err != nil { 341 log.Error("get normal node from contract failed", "error", err) 342 } 343 ret += normalNodes 344 //获取管理节点 345 adminNodes, err := s.permissionContract.GetNodeByRole(callOpts, big.NewInt(int64(Admin))) 346 if err != nil { 347 log.Error("get admin node from contract failed", "error", err) 348 } 349 ret += adminNodes 350 return ret 351 } 352 353 func (s *Service) runPermissionVerifyNotify() { 354 sink := make(chan *PermissionVerifyNotify, 1) 355 var start uint64 = 1 356 opts := &bind.WatchOpts{ 357 Start: &start, 358 } 359 filter, err := s.permissionContract.WatchVerifyNotify(opts, sink) 360 if err != nil { 361 log.Error(err.Error()) 362 return 363 } 364 s.watching = true 365 go s.isAdminRoleEvent() 366 go s.isVotedEvent() 367 defer func() { 368 s.watching = false 369 }() 370 defer filter.Unsubscribe() 371 for { 372 select { 373 case eventObject := <-sink: 374 log.Info("call syncNodeId in runPermissionVerifyNotify") 375 s.syncNodeId() 376 log.Info("eventObject", "nodeId", eventObject.EnodeId, "opCode", eventObject.OpCode) 377 result, err := s.onPermissionNotify(eventObject) 378 if err != nil || !result { 379 log.Error("operate failed.", "result", result, "err", err) 380 } 381 case <-s.stop: 382 log.Info("quit permission contract watch") 383 return 384 case err := <-filter.Err(): 385 if err != nil { 386 log.Info("permission contract watch exits") 387 return 388 } 389 } 390 } 391 } 392 393 func (s *Service) opAllNodeOnChain(server *p2p.Server, opType int) { 394 log.Info("opAllNodeOnChain", "opType", opType) 395 ret1, err := s.permissionContract.GetNodeByRole(&bind.CallOpts{ 396 Pending: true, 397 }, big.NewInt(int64(Admin))) 398 if err != nil { 399 log.Error("query failed", "err", err) 400 } 401 tmp := strings.Split(ret1, ",") 402 ret2, err := s.permissionContract.GetNodeByRole(&bind.CallOpts{ 403 Pending: true, 404 }, big.NewInt(int64(Normal))) 405 if err != nil { 406 log.Error("query failed", "err", err) 407 } 408 tmp1 := strings.Split(ret2, ",") 409 tmp = append(tmp, tmp1...) 410 for _, nodeId := range tmp { 411 returnNodeId, ip, port, _, _, _, _, _, err := s.permissionContract.GetNodeMap(&bind.CallOpts{ 412 Pending: true, 413 }, nodeId) 414 if err != nil || returnNodeId == "" { 415 log.Error("query failed", "err", err, "nodeId response", returnNodeId) 416 continue 417 } 418 remoteNodeURL := fmt.Sprintf("%v@%v:%v", returnNodeId, ip, port) 419 nodeObject, err := enode.Parse(enode.ValidSchemes, remoteNodeURL) 420 if err != nil { 421 log.Error("eNode.Parse failed", "error", err) 422 return 423 } 424 if opType == Join { 425 server.AddPeer(nodeObject) 426 } 427 if opType == Remove { 428 server.RemovePeer(nodeObject) 429 } 430 } 431 } 432 433 func (s *Service) onPermissionNotify(verifyNotify *PermissionVerifyNotify) (bool, error) { 434 defer func() { 435 if err := recover(); err != nil { 436 log.Error("onPermissionNotify", "err", err) 437 } 438 }() 439 // Make sure the server is running, fail otherwise 440 server := s.node.Server() 441 if server == nil { 442 return false, fmt.Errorf("node not started") 443 } 444 445 url := fmt.Sprintf("%s@%s:%s", verifyNotify.EnodeId, verifyNotify.Ip, verifyNotify.Port) 446 447 localeNode := s.node.Server().NodeInfo().Enode 448 localeNodeId, _, _, err := splitENode(localeNode) 449 if err != nil { 450 return false, err 451 } 452 //退出联盟 453 if verifyNotify.OpCode.Cmp(big.NewInt(int64(Remove))) == 0 { 454 //remove from network 455 // Try to remove the url as a static peer and return 456 nodeObject, err := enode.Parse(enode.ValidSchemes, url) 457 if err != nil { 458 return false, fmt.Errorf("invalid eNode: %v", err) 459 } 460 server.RemovePeer(nodeObject) 461 if localeNodeId == verifyNotify.EnodeId { 462 s.opAllNodeOnChain(server, Remove) 463 } 464 } 465 //成功加入联盟 466 if verifyNotify.OpCode.Cmp(big.NewInt(int64(Join))) == 0 { 467 // Try to add the url as a static peer and return 468 nodeObject, err := enode.Parse(enode.ValidSchemes, url) 469 if err != nil { 470 return false, fmt.Errorf("invalid eNode: %v", err) 471 } 472 server.AddPeer(nodeObject) 473 if localeNodeId == verifyNotify.EnodeId { 474 s.opAllNodeOnChain(server, Join) 475 } 476 log.Info("onPermissionNotify before syncNodeId") 477 } 478 return true, nil 479 } 480 481 // InitFinish 完成联盟网络初始化 482 func (s *Service) InitFinish(from common.Address) (string, error) { 483 result := "" 484 if s.permissionContract == nil { 485 return result, permissionContractNotSet 486 } 487 auth, err := s.getAuth(from) 488 if err != nil { 489 return result, err 490 } 491 tx, err := s.permissionContract.InitFinish(auth) 492 if err != nil { 493 return result, err 494 } 495 result = tx.Hash().String() 496 return result, nil 497 } 498 499 // SetAdminNode 设置管理员节点 500 func (s *Service) SetAdminNode(fullNodeId string, nodeName string, address common.Address, from common.Address) (string, error) { 501 result := "" 502 if s.permissionContract == nil { 503 return result, permissionContractNotSet 504 } 505 auth, err := s.getAuth(from) 506 if err != nil { 507 return result, err 508 } 509 nodeId, ip, port, err := splitENode(fullNodeId) 510 if err != nil { 511 return result, err 512 } 513 //todo verify ip and port 514 tx, err := s.permissionContract.SetAdminNode(auth, nodeId, ip, port, nodeName, address) 515 if err != nil { 516 return result, err 517 } 518 log.Debug("permission:set a new admin node", "nodeId", nodeId, "nodeName", nodeName) 519 result = tx.Hash().String() 520 return result, nil 521 } 522 523 // MakeProposalForAdmin 申请成为管理节点 524 func (s *Service) MakeProposalForAdmin(fullNodeId string, from common.Address) (string, error) { 525 result := "" 526 if s.permissionContract == nil { 527 return result, permissionContractNotSet 528 } 529 localFullNodeId := s.node.Server().NodeInfo().Enode 530 temp := strings.Split(localFullNodeId, "@") 531 localNodeId := temp[0] 532 nodeId, _, _, err := splitENode(fullNodeId) 533 if err != nil { 534 return result, err 535 } 536 auth, err := s.getAuth(from) 537 if err != nil { 538 return result, err 539 } 540 opAdmin := "2" 541 tx, err := s.permissionContract.MakeProposeForRoleChange(auth, nodeId, opAdmin, localNodeId) 542 if err != nil { 543 return result, err 544 } 545 log.Debug("permission:proposal to make an admin node", "nodeId", nodeId, "txHash", tx.Hash().String()) 546 result = tx.Hash().String() 547 return result, err 548 } 549 550 // AcceptProposalForAdmin 节点升级投赞成票 551 func (s *Service) AcceptProposalForAdmin(fullNodeId string, from common.Address) (string, error) { 552 result := "" 553 localFullNodeId := s.node.Server().NodeInfo().Enode 554 temp := strings.Split(localFullNodeId, "@") 555 localNodeId := temp[0] 556 nodeId, _, _, err := splitENode(fullNodeId) 557 if err != nil { 558 return result, err 559 } 560 auth, err := s.getAuth(from) 561 if err != nil { 562 return result, err 563 } 564 //2 升级为管理节点 565 opAdmin := "2" 566 tx, err := s.permissionContract.VoteForRoleChange(auth, nodeId, localNodeId, opAdmin) 567 if err != nil { 568 return result, err 569 } 570 log.Debug("permission:voting for node upgrading to admin", "nodeId", nodeId, "txHash", tx.Hash().String()) 571 result = tx.Hash().String() 572 return result, err 573 } 574 575 // MakeProposalForCommon 申请成为普通节点 576 func (s *Service) MakeProposalForCommon(fullNodeId string, from common.Address) (string, error) { 577 result := "" 578 if s.permissionContract == nil { 579 return result, permissionContractNotSet 580 } 581 localFullNodeId := s.node.Server().NodeInfo().Enode 582 temp := strings.Split(localFullNodeId, "@") 583 localNodeId := temp[0] 584 nodeId, _, _, err := splitENode(fullNodeId) 585 if err != nil { 586 return result, err 587 } 588 auth, err := s.getAuth(from) 589 if err != nil { 590 return result, err 591 } 592 // 3 降级成普通节点 593 opCommon := "3" 594 tx, err := s.permissionContract.MakeProposeForRoleChange(auth, nodeId, opCommon, localNodeId) 595 if err != nil { 596 return result, err 597 } 598 log.Debug("permission:proposal to make a normal node", "nodeId", nodeId, "txHash", tx.Hash().String()) 599 result = tx.Hash().String() 600 return result, err 601 } 602 603 // AcceptProposalForCommon 节点降级投票 604 // 使用fullNodeId和nodeAddress绑定组成一个节点的唯一标识 605 func (s *Service) AcceptProposalForCommon(fullNodeId string, from common.Address) (string, error) { 606 result := "" 607 //本节点 608 localFullNodeId := s.node.Server().NodeInfo().Enode 609 temp := strings.Split(localFullNodeId, "@") 610 localNodeId := temp[0] 611 nodeId, _, _, err := splitENode(fullNodeId) 612 if err != nil { 613 return result, err 614 } 615 auth, err := s.getAuth(from) 616 if err != nil { 617 return result, err 618 } 619 // 3 降级成普通节点 620 var opCommon string = "3" 621 tx, err := s.permissionContract.VoteForRoleChange(auth, nodeId, localNodeId, opCommon) 622 if err != nil { 623 return result, err 624 } 625 log.Debug("permission:voting for node degrading to normal", "nodeId", nodeId, "txHash", tx.Hash().String()) 626 result = tx.Hash().String() 627 return result, err 628 } 629 630 // MakeProposalForExit 发起退出联盟提案 631 func (s *Service) MakeProposalForExit(fullNodeId string, from common.Address) (string, error) { 632 result := "" 633 if s.permissionContract == nil { 634 return result, permissionContractNotSet 635 } 636 localFullNodeId := s.node.Server().NodeInfo().Enode 637 temp := strings.Split(localFullNodeId, "@") 638 localNodeId := temp[0] 639 nodeId, _, _, err := splitENode(fullNodeId) 640 if err != nil { 641 return result, err 642 } 643 auth, err := s.getAuth(from) 644 if err != nil { 645 return result, err 646 } 647 opExit := "1" 648 tx, err := s.permissionContract.MakeProposeForRoleChange(auth, nodeId, opExit, localNodeId) 649 if err != nil { 650 return result, err 651 } 652 log.Debug("permission:proposal to exclude a node", "nodeId", nodeId, "txHash", tx.Hash().String()) 653 result = tx.Hash().String() 654 return result, err 655 } 656 657 // AcceptProposalForExit 变成游离节点(退出联盟) 658 func (s *Service) AcceptProposalForExit(fullNodeId string, from common.Address) (string, error) { 659 result := "" 660 if s.permissionContract == nil { 661 return result, permissionContractNotSet 662 } 663 localFullNodeId := s.node.Server().NodeInfo().Enode 664 temp := strings.Split(localFullNodeId, "@") 665 localNodeId := temp[0] 666 nodeId, _, _, err := splitENode(fullNodeId) 667 if err != nil { 668 return result, err 669 } 670 auth, err := s.getAuth(from) 671 if err != nil { 672 return result, err 673 } 674 // 1 退出联盟,也就是变成游离节点 675 opExit := "1" 676 tx, err := s.permissionContract.VoteForRoleChange(auth, nodeId, localNodeId, opExit) 677 if err != nil { 678 return result, err 679 } 680 log.Debug("permission:voting for excluding node", "nodeId", nodeId, "txHash", tx.Hash().String()) 681 result = tx.Hash().String() 682 return result, err 683 } 684 685 // MakeProposalForJoin 申请加入联盟 686 // add new node application 687 func (s *Service) MakeProposalForJoin(fullNodeId string, nodeName string, nodeAddress common.Address, from common.Address) (string, error) { 688 result := "" 689 if s.permissionContract == nil { 690 return result, permissionContractNotSet 691 } 692 localFullNodeId := s.node.Server().NodeInfo().Enode 693 temp := strings.Split(localFullNodeId, "@") 694 localNodeId := temp[0] 695 nodeId, ip, port, err := splitENode(fullNodeId) 696 if err != nil { 697 return result, err 698 } 699 auth, err := s.getAuth(from) 700 if err != nil { 701 return result, err 702 } 703 tx, err := s.permissionContract.MakeProposeForAddNewNode(auth, nodeId, ip, port, nodeName, nodeAddress, localNodeId) 704 if err != nil { 705 return result, err 706 } 707 log.Debug("permission:proposal to add a node", "nodeId", nodeId, "txHash", tx.Hash().String()) 708 return tx.Hash().String(), err 709 } 710 711 // AcceptProposalForJoin 对申请加入联盟进行投赞成票 712 // AcceptProposalForJoin 713 func (s *Service) AcceptProposalForJoin(fullNodeId string, from common.Address) (string, error) { 714 result := "" 715 if s.permissionContract == nil { 716 return result, permissionContractNotSet 717 } 718 localFullNodeId := s.node.Server().NodeInfo().Enode 719 temp := strings.Split(localFullNodeId, "@") 720 localNodeId := temp[0] 721 nodeId, _, _, err := splitENode(fullNodeId) 722 if err != nil { 723 return result, err 724 } 725 auth, err := s.getAuth(from) 726 if err != nil { 727 return result, err 728 } 729 tx, err := s.permissionContract.VoteForNewNodeApply(auth, nodeId, localNodeId) 730 if err != nil { 731 return result, err 732 } 733 result = tx.Hash().String() 734 log.Debug("permission:voting for node adding", "nodeId", nodeId, "txHash", tx.Hash().String()) 735 return result, err 736 } 737 738 // UpdateNodeInfo 更新节点信息 739 // 只能自己更新 740 // update node info 741 func (s *Service) UpdateNodeInfo(from common.Address, ip, port string) (string, error) { 742 result := "" 743 if s.permissionContract == nil { 744 return result, permissionContractNotSet 745 } 746 localFullNodeId := s.node.Server().NodeInfo().Enode 747 temp := strings.Split(localFullNodeId, "@") 748 localNodeId := temp[0] 749 auth, err := s.getAuth(from) 750 if err != nil { 751 return result, err 752 } 753 tx, err := s.permissionContract.UpdateNodeInfo(auth, localNodeId, ip, port) 754 if err != nil { 755 return result, err 756 } 757 result = tx.Hash().String() 758 return result, err 759 } 760 func (s *Service) UpdateNodeName(fullNodeId string, nodeName string, from common.Address) (string, error) { 761 result := "" 762 if s.permissionContract == nil { 763 return result, permissionContractNotSet 764 } 765 temp := strings.Split(fullNodeId, "@") 766 nodeId := temp[0] 767 auth, err := s.getAuth(from) 768 if err != nil { 769 return result, err 770 } 771 tx, err := s.permissionContract.UpdateNodeName(auth, nodeId, nodeName) 772 if err != nil { 773 return result, err 774 } 775 result = tx.Hash().String() 776 return result, err 777 } 778 779 // Disagree 投反对票 780 // 包括加入,升级,降级 781 func (s *Service) Disagree(fullNodeId string, opCode int, from common.Address) (string, error) { 782 result := "" 783 if s.permissionContract == nil { 784 return result, permissionContractNotSet 785 } 786 localFullNodeId := s.node.Server().NodeInfo().Enode 787 temp := strings.Split(localFullNodeId, "@") 788 localNodeId := temp[0] 789 auth, err := s.getAuth(from) 790 if err != nil { 791 return result, err 792 } 793 nodeId, _, _, err := splitENode(fullNodeId) 794 if err != nil { 795 return result, err 796 } 797 tx, err := s.permissionContract.Disagree(auth, nodeId, localNodeId, fmt.Sprintf("%d", opCode)) 798 if err != nil { 799 return result, err 800 } 801 result = tx.Hash().String() 802 return result, err 803 } 804 805 // GetNodeByRole 根据角色类型获取节点 806 func (s *Service) GetNodeByRole(role *big.Int, from common.Address) (string, error) { 807 result := "" 808 if s.permissionContract == nil { 809 return result, permissionContractNotSet 810 } 811 opts := &bind.CallOpts{From: from} 812 ret, err := s.permissionContract.GetNodeByRole(opts, role) 813 if err != nil { 814 return result, err 815 } 816 return ret, nil 817 } 818 819 // GetNodeRole 获取节点的角色 820 // 821 // //管理节点 822 // uint admin=2; 823 // //普通节点 824 // uint common=0; 825 // //游离节点 826 // uint isolated=1; 827 func (s *Service) GetNodeRole(fullNodeId string, from common.Address) (*big.Int, error) { 828 result := big.NewInt(0) 829 if s.permissionContract == nil { 830 return result, permissionContractNotSet 831 } 832 nodeId := strings.Split(fullNodeId, "@")[0] 833 opts := &bind.CallOpts{From: from} 834 eNodeRet, _, _, _, _, role, _, _, err := s.permissionContract.GetNodeMap(opts, nodeId) 835 if err != nil || eNodeRet == "" { 836 if err != nil { 837 log.Error("Service GetNodeRole", "eNodeId err", err.Error()) 838 return big.NewInt(3), fmt.Errorf("GetNodeRole query failed %s", err.Error()) 839 } 840 return big.NewInt(3), fmt.Errorf("GetNodeRole query failed") 841 } 842 return role, nil 843 } 844 845 // GetNodeInfoByName 通过节点名称获取节点信息 846 func (s *Service) GetNodeInfoByName(nodeName string, from common.Address) (string, error) { 847 result := "" 848 if s.permissionContract == nil { 849 return result, permissionContractNotSet 850 } 851 opts := &bind.CallOpts{From: from} 852 nodeId, ip, port, _, address, role, ifMiner, createdAt, err := s.permissionContract.GetInfoByName(opts, nodeName) 853 if err != nil { 854 return result, err 855 } 856 if nodeId == "" { 857 return result, errors.New("node not exists") 858 } 859 return fmt.Sprintf("%v,%v,%v,%v,%v,%v,%v,%v", nodeId, ip, port, nodeName, address.String(), role, ifMiner, createdAt), nil 860 } 861 862 func (s *Service) GetStateMap(fullNodeId string, opCode string, from common.Address) (string, error) { 863 result := "" 864 if s.permissionContract == nil { 865 return result, permissionContractNotSet 866 } 867 opts := &bind.CallOpts{From: from} 868 869 nodeId := strings.Split(fullNodeId, "@")[0] 870 871 agree, disagree, proposeNodeId, opCode, status, err := s.permissionContract.GetLastStatistics(opts, nodeId, opCode) 872 873 if err != nil || proposeNodeId == "" { 874 return "", fmt.Errorf("GetStateMap query failed") 875 } 876 return fmt.Sprintf("%v,%v,%v,%v,%v", agree, disagree, proposeNodeId, opCode, status), nil 877 } 878 879 func (s *Service) GetNodeInfo(fullNodeId string, from common.Address) (string, error) { 880 result := "" 881 if s.permissionContract == nil { 882 return result, permissionContractNotSet 883 } 884 opts := &bind.CallOpts{From: from} 885 nodeId := strings.Split(fullNodeId, "@")[0] 886 returnNodeId, ip, port, nodeName, eNodeAddress, role, ifMiner, createdAt, err := s.permissionContract.GetNodeMap(opts, nodeId) 887 if err != nil { 888 return result, fmt.Errorf("GetNodeInfo query failed") 889 } 890 if returnNodeId == "" { 891 result = "the node is not a member of the alliance" 892 return result, nil 893 } 894 return fmt.Sprintf("%s,%s,%s,%s,%s,%v,%v,%v", returnNodeId, ip, port, nodeName, eNodeAddress.String(), role, ifMiner, createdAt), nil 895 } 896 func (s *Service) GetAllStatingRecord(from common.Address) (string, error) { 897 result := "" 898 if s.permissionContract == nil { 899 return result, permissionContractNotSet 900 } 901 opts := &bind.CallOpts{From: from} 902 stateKeys, err := s.permissionContract.GetAllStatingRecord(opts) 903 if err != nil { 904 return result, err 905 } 906 return stateKeys, nil 907 } 908 909 func (s *Service) IsAdmin(fullNodeId string, from common.Address) (bool, error) { 910 if s.permissionContract == nil { 911 return false, permissionContractNotSet 912 } 913 nodeId := strings.Split(fullNodeId, "@")[0] 914 opts := &bind.CallOpts{From: from} 915 h := crypto.Keccak256Hash([]byte(nodeId)) 916 flag, err := s.permissionContract.IsAdmin(opts, h) 917 if err != nil { 918 return false, err 919 } 920 return flag, nil 921 } 922 923 // AddPeer 添加节点 924 func (s *Service) AddPeer(url string, from common.Address) (bool, error) { 925 //本节点 926 localNode := s.node.Server().NodeInfo().Enode 927 if s.node.Config().EnableNodePermission { 928 available, err := s.verifyPermission(url, from) 929 if err != nil { 930 log.Error("verify permission failed", "url", url, "err", err) 931 return false, err 932 } 933 if !available { 934 return false, errors.New(fmt.Sprintf("the node %s does not join the network", url)) 935 } 936 available, err = s.verifyPermission(localNode, from) 937 if err != nil { 938 log.Error("verify permission failed", "url", localNode, "err", err) 939 return false, err 940 } 941 if !available { 942 return false, errors.New(fmt.Sprintf("local %s does not join the network", localNode)) 943 } 944 } 945 if s.eth != nil && s.eth.ChainConfig().Clique != nil { 946 // Make sure the server is running, fail otherwise 947 server := s.node.Server() 948 if server == nil { 949 return false, fmt.Errorf("node not started") 950 } 951 // Try to add the url as a static peer and return 952 nodeObject, err := enode.Parse(enode.ValidSchemes, url) 953 if err != nil { 954 return false, fmt.Errorf("invalid enode: %v", err) 955 } 956 server.AddPeer(nodeObject) 957 } 958 return true, nil 959 } 960 961 func (s *Service) RemovePeer(url string) (bool, error) { 962 // Make sure the server is running, fail otherwise 963 if s.eth.ChainConfig().Clique != nil { //poa 964 server := s.node.Server() 965 if server == nil { 966 return false, fmt.Errorf("node not started") 967 } 968 // Try to remove the url as a static peer and return 969 nodeObject, err := enode.Parse(enode.ValidSchemes, url) 970 if err != nil { 971 return false, fmt.Errorf("invalid enode: %v", err) 972 } 973 server.RemovePeer(nodeObject) 974 } 975 return true, nil 976 } 977 978 func (s *Service) verifyPermission(url string, from common.Address) (bool, error) { 979 nodeId, _, _, err := splitENode(url) 980 if err != nil { 981 return false, err 982 } 983 if s.permissionContract == nil { 984 return false, permissionContractNotSet 985 } 986 987 opts := &bind.CallOpts{From: from} 988 returnNodeId, _, _, _, _, role, _, _, err := s.permissionContract.GetNodeMap(opts, nodeId) 989 if err != nil { 990 return false, err 991 } 992 if returnNodeId == "" { 993 return false, errors.New("the node is isolated node") 994 } 995 if role.Cmp(big.NewInt(int64(Isolated))) == 0 { 996 return false, errors.New("the node can not join network") 997 } 998 return true, nil 999 } 1000 func (s *Service) WatchNetworkInitComplete() { 1001 sink := make(chan *PermissionNetworkInitComplete, 1) 1002 var start uint64 = 1 1003 opts := &bind.WatchOpts{ 1004 Start: &start, 1005 } 1006 filter, err := s.permissionContract.WatchNetworkInitComplete(opts, sink) 1007 if err != nil { 1008 log.Error(err.Error()) 1009 return 1010 } 1011 defer filter.Unsubscribe() 1012 for { 1013 select { 1014 case initCompleteEvent := <-sink: 1015 log.Info("WatchNetworkInitComplete", "block number", initCompleteEvent.Number) 1016 log.Info("call syncNodeId in WatchNetworkInitComplete") 1017 s.syncNodeId() 1018 s.CacheManager() 1019 case <-s.stop: 1020 log.Info("quit permission contract watch") 1021 return 1022 case err := <-filter.Err(): 1023 if err != nil { 1024 log.Error("permission contract watch exits", "error", err) 1025 return 1026 } 1027 } 1028 } 1029 } 1030 1031 func (s *Service) CacheManager() { 1032 //获取管理员节点 1033 role := big.NewInt(0).SetInt64(int64(Admin)) 1034 am := s.GetAccountManager() 1035 //获取所有的管理员节点 1036 nodeIdStr, err := s.GetNodeByRole(role, am.Accounts()[0]) 1037 if err != nil { 1038 log.Error("GetAllNode", "err", err) 1039 return 1040 } 1041 nodeIds := strings.Split(nodeIdStr, ",") 1042 for _, nodeId := range nodeIds { 1043 callOpts := &bind.CallOpts{ 1044 Pending: true, 1045 } 1046 _, _, _, _, addr, _, isOriginator, _, err := s.permissionContract.GetNodeMap(callOpts, nodeId) 1047 if err != nil { 1048 log.Error("GetNodeMap", "error", err) 1049 continue 1050 } 1051 //缓存所有的创世管理员 1052 if addr != (common.Address{}) && isOriginator { 1053 log.Debug("CacheManager", "addr", addr.String()) 1054 s.eth.GetSuperManager().AddManager(addr) 1055 } 1056 } 1057 } 1058 func (s *Service) isInitFinished() bool { 1059 if s.permissionContract == nil { 1060 return false 1061 } 1062 finish, err := s.permissionContract.IsInitFinished(&bind.CallOpts{ 1063 Pending: true, 1064 }) 1065 if err != nil { 1066 log.Error("Service IsInitFinished", "err", err.Error()) 1067 return false 1068 } 1069 return finish 1070 } 1071 func (s *Service) GetAdminCount() (*big.Int, error) { 1072 if s.permissionContract == nil { 1073 return big.NewInt(0), errors.New("permission Contract is nil") 1074 } 1075 count, err := s.permissionContract.GetAdminCount(&bind.CallOpts{ 1076 Pending: true, 1077 }) 1078 if err != nil { 1079 log.Error("Service GetAdminCount", "err", err.Error()) 1080 return big.NewInt(0), err 1081 } 1082 return count, nil 1083 } 1084 func (s *Service) nodeExists(fullNodeId string) bool { 1085 if s.permissionContract == nil { 1086 return false 1087 } 1088 nodeId := strings.Split(fullNodeId, "@")[0] 1089 opts := &bind.CallOpts{Pending: true} 1090 exists, err := s.permissionContract.NodeExists(opts, nodeId) 1091 if err != nil { 1092 log.Error("Service nodeExists", "err", err.Error()) 1093 return false 1094 } 1095 return exists 1096 } 1097 func (s *Service) SetInitFinishedFlag(db ethdb.Database) error { 1098 return db.Put([]byte(common.PermissionInitFinished), []byte("true")) 1099 } 1100 1101 func (s *Service) cacheNodeId(nodeId string, db ethdb.Database) error { 1102 log.Info("cacheNodeId", "nodeId", nodeId) 1103 return db.Put([]byte(nodeId), []byte("true")) 1104 } 1105 1106 // filterNodeId nodeId形如 "enode://217d5b...928b@101.68.74.170:30303" 1107 // 取 217d5b...928b 1108 func (s *Service) filterNodeId(nodeId string) string { 1109 if strings.Contains(nodeId, "enode://") { 1110 nodeId = strings.ReplaceAll(nodeId, "enode://", "") 1111 } 1112 if strings.Contains(nodeId, "@") { 1113 strArr := strings.Split(nodeId, "@") 1114 nodeId = strArr[0] 1115 } 1116 return nodeId 1117 } 1118 1119 // 同步节点 1120 func (s *Service) syncNodeId() { 1121 if s.isInitFinished() { 1122 err := s.SetInitFinishedFlag(s.GetCommonDb()) 1123 if err != nil { 1124 log.Error("SetInitFinishedFlag", "err", err.Error()) 1125 } 1126 //游离节点要删除 1127 nodeString := s.dissociateNodes() 1128 if nodeString != "" { 1129 log.Info("syncNodeId", "dissociateNodes", nodeString) 1130 nodeArr := strings.Split(nodeString, ",") 1131 for _, v := range nodeArr { 1132 if v == "" { 1133 continue 1134 } 1135 err := s.removeNodeId(s.filterNodeId(v), s.GetCommonDb()) 1136 if err != nil { 1137 log.Error("removeNodeId", "err", err.Error()) 1138 } 1139 } 1140 } 1141 //正常节点要缓存 1142 nodeStr := s.getAvailableNodes() 1143 if nodeStr != "" { 1144 log.Info("syncNodeId", "availableNodes", nodeStr) 1145 nodeArray := strings.Split(nodeStr, ",") 1146 for _, v := range nodeArray { 1147 if v == "" { 1148 continue 1149 } 1150 err := s.cacheNodeId(s.filterNodeId(v), s.GetCommonDb()) 1151 if err != nil { 1152 log.Error("CacheNodeId", "err", err.Error()) 1153 } 1154 } 1155 } 1156 } 1157 } 1158 1159 // 从db中删除节点id 1160 func (s *Service) removeNodeId(nodeId string, db ethdb.Database) error { 1161 return db.Delete([]byte(nodeId)) 1162 } 1163 1164 // 获取游离节点 1165 func (s *Service) dissociateNodes() string { 1166 var ret string 1167 callOpts := &bind.CallOpts{ 1168 Pending: true, 1169 } 1170 //获取游离节点 1171 normalNodes, err := s.permissionContract.GetNodeByRole(callOpts, big.NewInt(int64(Isolated))) 1172 if err != nil { 1173 log.Error("get normal node from contract failed", "error", err) 1174 } 1175 ret += normalNodes 1176 return ret 1177 } 1178 func (s *Service) isAdminRoleEvent() { 1179 log.Info(" isAdminRoleEvent enter") 1180 sink := make(chan *PermissionIsAdminRoleEvent, 1) 1181 var start uint64 = 1 1182 opts := &bind.WatchOpts{ 1183 Start: &start, 1184 } 1185 filter, err := s.permissionContract.WatchIsAdminRoleEvent(opts, sink) 1186 if err != nil { 1187 log.Error(err.Error()) 1188 return 1189 } 1190 defer filter.Unsubscribe() 1191 for { 1192 select { 1193 case eventObject := <-sink: 1194 log.Info("call isAdminRoleEvent") 1195 log.Info("eventObject", "voteNodeId", eventObject.NodeId, "sender", eventObject.Sender) 1196 1197 case <-s.stop: 1198 log.Info("quit permission contract watch") 1199 return 1200 case err := <-filter.Err(): 1201 if err != nil { 1202 log.Info("permission contract watch exits") 1203 return 1204 } 1205 } 1206 } 1207 } 1208 1209 func (s *Service) isVotedEvent() { 1210 log.Info(" isVotedEvent enter") 1211 sink := make(chan *PermissionIsVotedEvent, 1) 1212 var start uint64 = 1 1213 opts := &bind.WatchOpts{ 1214 Start: &start, 1215 } 1216 filter, err := s.permissionContract.WatchIsVotedEvent(opts, sink) 1217 if err != nil { 1218 log.Error(err.Error()) 1219 return 1220 } 1221 1222 defer filter.Unsubscribe() 1223 for { 1224 select { 1225 case eventObject := <-sink: 1226 log.Info("call isVotedEvent") 1227 log.Info("eventObject", "nodeId", eventObject.NodeId, "voteId", eventObject.VoterNodeId) 1228 case <-s.stop: 1229 log.Info("quit permission contract watch") 1230 return 1231 case err := <-filter.Err(): 1232 if err != nil { 1233 log.Info("permission contract watch exits") 1234 return 1235 } 1236 } 1237 } 1238 }