def __init__(self,
ksize=20,
alpha=3,
node_id=None,
storage=None,
discovery_mode='neighborhood',
loop=None,
max_peers=64,
dht=None):
"""
Create a server instance. This will start listening on the given port.
Args:
ksize (int): The k parameter from the paper
alpha (int): The alpha parameter from the paper
node_id: The id for this node on the network.
storage: An instance that implements
:interface:`~kademlia.storage.IStorage`
"""
self.loop = loop if loop else asyncio.get_event_loop()
asyncio.set_event_loop(self.loop)
self.ksize = ksize
self.alpha = alpha
self.port = os.getenv('NETWORK_PORT', 5678)
self.storage = storage or ForgetfulStorage()
self.node = Node(digest(node_id) or digest(random.getrandbits(255)))
self.dht = dht
self.transport = None
self.protocol = None
self.refresh_loop = None
self.save_state_loop = None
self.max_peers = max_peers
self.setup_stethoscope()
def __init__(self, key, ksize=20, alpha=3, storage=None):
"""
Create a server instance. This will start listening on the given port.
Args:
key: bitcoin wif/hwif to be used as id and for signing/encryption
ksize (int): The k parameter from the kademlia paper
alpha (int): The alpha parameter from the kademlia paper
storage: implements :interface:`~kademlia.storage.IStorage`
"""
# TODO validate key is valid wif/hwif for mainnet or testnet
testnet = False # FIXME get from wif/hwif
self._btctxstore = btctxstore.BtcTxStore(testnet=testnet)
# allow hwifs
is_hwif = self._btctxstore.validate_wallet(key)
self._key = self._btctxstore.get_key(key) if is_hwif else key
# XXX Server.__init__ cannot call super because of StorjProtocol
# passing the protocol class should be added upstream
self.ksize = ksize
self.alpha = alpha
self.log = logging.getLogger(__name__)
self.storage = storage or ForgetfulStorage()
self.node = Node(self.get_id())
self.protocol = StorjProtocol(self.node, self.storage, ksize)
self.refreshLoop = LoopingCall(self.refreshTable).start(3600)
def __init__(self,
ksize=20,
alpha=3,
node_id=None,
storage=None,
timeout=5,
record=False):
"""
Create a server instance. This will start listening on the given port.
Args:
ksize (int): The k parameter from the paper
alpha (int): The alpha parameter from the paper
node_id: The id for this node on the network.
storage: An instance that implements
:interface:`~kademlia.storage.IStorage`
timeout: Maximum ping time, initial param for RPCProtocol.wait_timeout
"""
self.ksize = ksize
self.alpha = alpha
self.storage = storage or ForgetfulStorage()
self.node = Node(node_id or digest(random.getrandbits(255)))
self.transport = None
self.protocol = None
self.refresh_loop = None
self.save_state_loop = None
self.timeout = timeout
self.record = record
if self.record == True:
print('In record mode:')
def __init__(self,
ksize=20,
alpha=3,
node_id=None,
storage=None,
custom_event_loop=None):
"""
Create a server instance. This will start listening on the given port.
Args:
ksize (int): The k parameter from the paper
alpha (int): The alpha parameter from the paper
node_id: The id for this node on the network.
storage: An instance that implements
:interface:`~kademlia.storage.IStorage`
"""
self.ksize = ksize
self.alpha = alpha
self.storage = storage or ForgetfulStorage()
self.node = Node(node_id or digest(random.getrandbits(255)))
self.transport = None
self.protocol = None
self.refresh_loop = None
self.save_state_loop = None
self.custom_event_loop = custom_event_loop
def __init__(self, ksize=20, alpha=3, id=None, storage=None):
"""
Create a server instance. This will start listening on the given port.
@param port: UDP port to listen on
@param k: The k parameter from the paper
@param alpha: The alpha parameter from the paper
"""
self.ksize = ksize
self.alpha = alpha
self.log = Logger(system=self)
self.storage = storage or ForgetfulStorage()
self.node = Node(id or digest(random.getrandbits(255)))
self.protocol = KademliaProtocol(self.node, self.storage, ksize)
self.refreshLoop = LoopingCall(self.refreshTable).start(3600)
def __init__(self, ksize=20, alpha=3, id=None, storage=None):
"""
Create a server instance. This will start listening on the given port.
Args:
ksize (int): The k parameter from the paper
alpha (int): The alpha parameter from the paper
id: The id for this node on the network.
storage: An instance that implements :interface:`~kademlia.storage.IStorage`
"""
self.ksize = ksize
self.alpha = alpha
self.log = Logger(system=self)
self.storage = storage or ForgetfulStorage()
self.node = Node(id or digest(random.getrandbits(255)))
self.protocol = KademliaProtocol(self.node, self.storage, ksize)
self.refreshLoop = LoopingCall(self.refreshTable).start(3600)
def __init__(self,
key,
ksize=20,
alpha=3,
storage=None,
max_messages=1024,
default_hop_limit=64,
refresh_neighbours_interval=0.0):
"""
Create a server instance. This will start listening on the given port.
Args:
key (str): Bitcoin wif/hwif for auth, encryption and node id.
ksize (int): The k parameter from the kademlia paper.
alpha (int): The alpha parameter from the kademlia paper
storage: implements :interface:`~kademlia.storage.IStorage`
refresh_neighbours_interval (float): Auto refresh neighbours.
"""
self._default_hop_limit = default_hop_limit
self._refresh_neighbours_interval = refresh_neighbours_interval
# TODO validate key is valid wif/hwif for mainnet or testnet
testnet = False # FIXME get from wif/hwif
self._btctxstore = btctxstore.BtcTxStore(testnet=testnet)
# allow hwifs
is_hwif = self._btctxstore.validate_wallet(key)
self.key = self._btctxstore.get_key(key) if is_hwif else key
# XXX Server.__init__ cannot call super because of StorjProtocol
# passing the protocol class should be added upstream
self.ksize = ksize
self.alpha = alpha
self.log = logging.getLogger(__name__)
self.storage = storage or ForgetfulStorage()
self.node = Node(self.get_id())
self.protocol = StorjProtocol(self.node,
self.storage,
ksize,
max_messages=max_messages,
max_hop_limit=self._default_hop_limit)
self.refreshLoop = LoopingCall(self.refreshTable).start(3600)
self._start_threads()
def __init__(self, ksize=20, alpha=3, node_id=None, storage=None):
"""
Create a server instance. This will start listening on the given port.
Args:
ksize (int): The k parameter from the paper
alpha (int): The alpha parameter from the paper
node_id: The id for this node on the network.
storage: An instance that implements
:interface:`~kademlia.storage.IStorage`
"""
self.ksize = ksize
self.alpha = alpha
# self.storage = storage or ForgetfulStorage()
self.storage = ForgetfulStorage() # PermanentStorage()
self.node = Node(node_id or digest(random.getrandbits(255)))
self.transport = None
self.protocol = None
self.refresh_loop = None
self.save_state_loop = None
# print('from network:Server node_id =', self.node, type(self.node))
log.debug('node_id=%s type=%s', self.node, type(self.node))
log.debug('storage type: %s', type(self.storage))
def setUp(self):
self.ts = ForgetfulStorage()
def test_forgetting(self): # pylint: disable=no-self-use
storage = ForgetfulStorage(0)
storage['one'] = 'two'
assert storage.get('one') is None
def test_storing(self): # pylint: disable=no-self-use
storage = ForgetfulStorage(10)
storage['one'] = 'two'
assert storage['one'] == 'two'
def test_iter_old(self): # pylint: disable=no-self-use
storage = ForgetfulStorage(10)
storage['one'] = 'two'
for key, value in storage.iter_older_than(0):
assert key == 'one'
assert value == 'two'
def test_storing(self):
storage = ForgetfulStorage(10)
storage['one'] = 'two'
self.assertEqual(storage['one'], 'two')
def test_iter_old(self):
storage = ForgetfulStorage(10)
storage['one'] = 'two'
for key, value in storage.iter_older_than(0):
self.assertEqual(key, 'one')
self.assertEqual(value, 'two')
def test_forgetting(self):
storage = ForgetfulStorage(0)
storage['one'] = 'two'
self.assertEqual(storage.get('one'), None)
