github.com/klaytn/klaytn@v1.10.2/cmd/kbn/backend.go (about)

     1  // Copyright 2019 The klaytn Authors
     2  // This file is part of the klaytn library.
     3  //
     4  // The klaytn library is free software: you can redistribute it and/or modify
     5  // it under the terms of the GNU Lesser General Public License as published by
     6  // the Free Software Foundation, either version 3 of the License, or
     7  // (at your option) any later version.
     8  //
     9  // The klaytn library is distributed in the hope that it will be useful,
    10  // but WITHOUT ANY WARRANTY; without even the implied warranty of
    11  // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
    12  // GNU Lesser General Public License for more details.
    13  //
    14  // You should have received a copy of the GNU Lesser General Public License
    15  // along with the klaytn library. If not, see <http://www.gnu.org/licenses/>.
    16  
    17  package main
    18  
    19  import (
    20  	"fmt"
    21  	"strings"
    22  
    23  	"github.com/klaytn/klaytn/networks/p2p/discover"
    24  	"github.com/klaytn/klaytn/networks/rpc"
    25  )
    26  
    27  type BN struct {
    28  	ntab discover.Discovery
    29  }
    30  
    31  func NewBN(t discover.Discovery) *BN {
    32  	return &BN{ntab: t}
    33  }
    34  
    35  func (b *BN) Name() string {
    36  	return b.ntab.Name()
    37  }
    38  
    39  func (b *BN) Resolve(target discover.NodeID, targetType discover.NodeType) *discover.Node {
    40  	return b.ntab.Resolve(target, targetType)
    41  }
    42  
    43  func (b *BN) Lookup(target discover.NodeID, targetType discover.NodeType) []*discover.Node {
    44  	return b.ntab.Lookup(target, targetType)
    45  }
    46  
    47  func (b *BN) ReadRandomNodes(buf []*discover.Node, nType discover.NodeType) int {
    48  	return b.ntab.ReadRandomNodes(buf, nType)
    49  }
    50  
    51  func (b *BN) CreateUpdateNodeOnDB(nodekni string) error {
    52  	node, err := discover.ParseNode(nodekni)
    53  	if err != nil {
    54  		return err
    55  	}
    56  	return b.ntab.CreateUpdateNodeOnDB(node)
    57  }
    58  
    59  func (b *BN) CreateUpdateNodeOnTable(nodekni string) error {
    60  	node, err := discover.ParseNode(nodekni)
    61  	if err != nil {
    62  		return nil
    63  	}
    64  	return b.ntab.CreateUpdateNodeOnTable(node)
    65  }
    66  
    67  func (b *BN) GetNodeFromDB(id discover.NodeID) (*discover.Node, error) {
    68  	return b.ntab.GetNodeFromDB(id)
    69  }
    70  
    71  func (b *BN) GetTableEntries() []*discover.Node {
    72  	return b.ntab.GetBucketEntries()
    73  }
    74  
    75  func (b *BN) GetTableReplacements() []*discover.Node {
    76  	return b.ntab.GetReplacements()
    77  }
    78  
    79  func (b *BN) DeleteNodeFromDB(nodekni string) error {
    80  	node, err := discover.ParseNode(nodekni)
    81  	if err != nil {
    82  		return err
    83  	}
    84  	return b.ntab.DeleteNodeFromDB(node)
    85  }
    86  
    87  func (b *BN) DeleteNodeFromTable(nodekni string) error {
    88  	node, err := discover.ParseNode(nodekni)
    89  	if err != nil {
    90  		return err
    91  	}
    92  	return b.ntab.DeleteNodeFromTable(node)
    93  }
    94  
    95  func (b *BN) GetAuthorizedNodes() []*discover.Node {
    96  	return b.ntab.GetAuthorizedNodes()
    97  }
    98  
    99  func parseNodeList(rawurl string) ([]*discover.Node, error) {
   100  	nodeStrings := strings.Split(rawurl, ",")
   101  	var nodes []*discover.Node
   102  	for _, url := range nodeStrings {
   103  		if node, err := discover.ParseNode(url); err != nil {
   104  			return nil, fmt.Errorf("node url is wrong. url: %v", url)
   105  		} else {
   106  			nodes = append(nodes, node)
   107  		}
   108  	}
   109  	return nodes, nil
   110  }
   111  
   112  func (b *BN) PutAuthorizedNodes(rawurl string) error {
   113  	nodes, err := parseNodeList(rawurl)
   114  	if err != nil {
   115  		return err
   116  	}
   117  	b.ntab.PutAuthorizedNodes(nodes)
   118  	return nil
   119  }
   120  
   121  func (b *BN) DeleteAuthorizedNodes(rawurl string) error {
   122  	nodes, err := parseNodeList(rawurl)
   123  	if err != nil {
   124  		return err
   125  	}
   126  	b.ntab.DeleteAuthorizedNodes(nodes)
   127  	return nil
   128  }
   129  
   130  func (b *BN) APIs() []rpc.API {
   131  	return []rpc.API{
   132  		{
   133  			Namespace: "admin",
   134  			Version:   "1.0",
   135  			Service:   NewPrivateBootnodeAPI(b),
   136  			Public:    true,
   137  		},
   138  		{
   139  			Namespace: "bootnode",
   140  			Version:   "1.0",
   141  			Service:   NewPublicBootnodeAPI(b),
   142  			Public:    true,
   143  		},
   144  	}
   145  }