from allmydata.immutable.offloaded import Helper
from allmydata.control import ControlServer
from allmydata.introducer.client import IntroducerClient
-from allmydata.util import hashutil, base32, pollmixin, log, keyutil
+from allmydata.util import hashutil, base32, pollmixin, log, keyutil, idlib
from allmydata.util.encodingutil import get_filesystem_encoding
from allmydata.util.abbreviate import parse_abbreviated_size
from allmydata.util.time_format import parse_duration, parse_date
self.init_introducer_client()
self.init_stats_provider()
self.init_secrets()
+ self.init_node_key()
self.init_storage()
self.init_control()
self.helper = None
if webport:
self.init_web(webport) # strports string
+ def _sequencer(self):
+ seqnum_s = self.get_config_from_file("announcement-seqnum")
+ if not seqnum_s:
+ seqnum_s = "0"
+ seqnum = int(seqnum_s.strip())
+ seqnum += 1 # increment
+ self.write_config("announcement-seqnum", "%d\n" % seqnum)
+ nonce = _make_secret().strip()
+ return seqnum, nonce
+
def init_introducer_client(self):
self.introducer_furl = self.get_config("client", "introducer.furl")
ic = IntroducerClient(self.tub, self.introducer_furl,
self.nickname,
str(allmydata.__full_version__),
str(self.OLDEST_SUPPORTED_VERSION),
- self.get_app_versions())
+ self.get_app_versions(),
+ self._sequencer)
self.introducer_client = ic
# hold off on starting the IntroducerClient until our tub has been
# started, so we'll have a useful address on our RemoteReference, so
self.convergence = base32.a2b(convergence_s)
self._secret_holder = SecretHolder(lease_secret, self.convergence)
- def _maybe_create_server_key(self):
+ def init_node_key(self):
# we only create the key once. On all subsequent runs, we re-use the
# existing key
def _make_key():
sk_vs,vk_vs = keyutil.make_keypair()
return sk_vs+"\n"
- sk_vs = self.get_or_create_private_config("server.privkey", _make_key)
+ sk_vs = self.get_or_create_private_config("node.privkey", _make_key)
sk,vk_vs = keyutil.parse_privkey(sk_vs.strip())
- self.write_config("server.pubkey", vk_vs+"\n")
- self._server_key = sk
+ self.write_config("node.pubkey", vk_vs+"\n")
+ self._node_key = sk
+
+ def get_long_nodeid(self):
+ # this matches what IServer.get_longname() says about us elsewhere
+ vk_bytes = self._node_key.get_verifying_key_bytes()
+ return "v0-"+base32.b2a(vk_bytes)
+
+ def get_long_tubid(self):
+ return idlib.nodeid_b2a(self.nodeid)
def _init_permutation_seed(self, ss):
seed = self.get_config_from_file("permutation-seed")
else:
# otherwise, we're free to use the more natural seed of our
# pubkey-based serverid
- vk_bytes = self._server_key.get_verifying_key_bytes()
+ vk_bytes = self._node_key.get_verifying_key_bytes()
seed = base32.b2a(vk_bytes)
self.write_config("permutation-seed", seed+"\n")
return seed.strip()
return
readonly = self.get_config("storage", "readonly", False, boolean=True)
- self._maybe_create_server_key()
-
storedir = os.path.join(self.basedir, self.STOREDIR)
data = self.get_config("storage", "reserved_space", None)
- reserved = None
try:
reserved = parse_abbreviated_size(data)
except ValueError:
log.msg("[storage]reserved_space= contains unparseable value %s"
% data)
+ raise
if reserved is None:
reserved = 0
discard = self.get_config("storage", "debug_discard", False,
ann = {"anonymous-storage-FURL": furl,
"permutation-seed-base32": self._init_permutation_seed(ss),
}
- self.introducer_client.publish("storage", ann, self._server_key)
+ self.introducer_client.publish("storage", ann, self._node_key)
d.addCallback(_publish)
d.addErrback(log.err, facility="tahoe.init",
level=log.BAD, umid="aLGBKw")
def init_client(self):
helper_furl = self.get_config("client", "helper.furl", None)
+ if helper_furl in ("None", ""):
+ helper_furl = None
+
DEP = self.DEFAULT_ENCODING_PARAMETERS
DEP["k"] = int(self.get_config("client", "shares.needed", DEP["k"]))
DEP["n"] = int(self.get_config("client", "shares.total", DEP["n"]))