def eraseLocalIdentity(do_backup=True):
if do_backup:
if os.path.isfile(settings.LocalIdentityFilename()):
current_identity_xmlsrc = local_fs.ReadBinaryFile(settings.LocalIdentityFilename())
if current_identity_xmlsrc:
fd, fname = tempfile.mkstemp(prefix='localidentity_', dir=settings.MetaDataDir())
os.write(fd, current_identity_xmlsrc)
os.close(fd)
lg.info('created backup copy of my local identity in the file : %r' % fname)
filename = bpio.portablePath(settings.LocalIdentityFilename())
if not os.path.exists(filename):
if _Debug:
lg.out(_DebugLevel, "my_id.eraseLocalIdentity SKIP file %s not exist" % filename)
return True
if not os.path.isfile(filename):
if _Debug:
lg.out(_DebugLevel, "my_id.eraseLocalIdentity ERROR path %s is not a file" % filename)
return False
try:
os.remove(filename)
except:
lg.exc()
return False
events.send('local-identity-erased', data=dict())
if _Debug:
lg.out(_DebugLevel, "my_id.eraseLocalIdentity file %s was deleted" % filename)
return True
def _create_new_identity(self):
"""
Generate new Private key and new identity file.
Reads some extra info from config files.
"""
login = bpio.ReadTextFile(settings.UserNameFilename())
externalIP = misc.readExternalIP(
) # bpio.ReadTextFile(settings.ExternalIPFilename())
lg.out(
4,
'id_registrator._create_new_identity %s %s ' % (login, externalIP))
key.InitMyKey()
lg.out(4, ' my key is ready')
ident = my_id.buildDefaultIdentity(name=login,
ip=externalIP,
idurls=self.free_idurls)
# localIP = bpio.ReadTextFile(settings.LocalIPFilename())
my_identity_xmlsrc = ident.serialize()
newfilename = settings.LocalIdentityFilename() + '.new'
bpio.WriteFile(newfilename, my_identity_xmlsrc)
self.new_identity = ident
lg.out(
4, ' wrote %d bytes to %s' %
(len(my_identity_xmlsrc), newfilename))
def _do_send_my_identity(self):
"""
Send my updated identity to the identity servers to register it.
"""
from transport.tcp import tcp_node
sendfilename = settings.LocalIdentityFilename()
my_sources = my_id.getLocalIdentity().getSources(as_originals=True)
dlist = []
if _Debug:
lg.out(
_DebugLevel,
'id_rotator._do_send_my_identity my_sources=%r' % my_sources)
for idurl_bin in my_sources:
_, host, _, _ = nameurl.UrlParse(idurl_bin)
tcpport = None
if host in self.preferred_servers:
tcpport = int(self.preferred_servers[host][1])
if not tcpport and host in self.known_servers:
tcpport = int(self.known_servers[host][1])
if not tcpport:
tcpport = settings.IdentityServerPort()
srvhost = net_misc.pack_address((
host,
tcpport,
))
if _Debug:
lg.out(_DebugLevel, ' sending to %r via TCP' % srvhost)
dlist.append(
tcp_node.send(
sendfilename,
srvhost,
'Identity',
keep_alive=False,
))
return DeferredList(dlist, fireOnOneCallback=True)
def _send_new_identity(self):
"""
Send created identity to the identity servers to register it.
"""
if _Debug:
lg.out(_DebugLevel, 'id_registrator._send_new_identity')
from transport.tcp import tcp_node
sendfilename = settings.LocalIdentityFilename() + '.new'
dlist = []
for idurl in self.new_identity.getSources(as_originals=True):
self.free_idurls.remove(strng.to_bin(idurl))
_, host, _, _ = nameurl.UrlParse(idurl)
_, tcpport = known_servers.by_host().get(
host,
(settings.IdentityWebPort(), settings.IdentityServerPort()))
srvhost = net_misc.pack_address((
host,
tcpport,
))
if _Debug:
lg.out(_DebugLevel, ' sending to %r via TCP' % srvhost)
dlist.append(
tcp_node.send(
sendfilename,
srvhost,
'Identity',
keep_alive=False,
))
return DeferredList(dlist, fireOnOneCallback=True)
def loadLocalIdentity():
"""
The core method.
The file [BitDust data dir]/metadata/localidentity keeps the user
identity in XML format. Do read the local file and set into object
in memory.
"""
global _LocalIdentity
xmlid = ''
filename = bpio.portablePath(settings.LocalIdentityFilename())
if os.path.exists(filename):
xmlid = bpio.ReadTextFile(filename)
if _Debug:
lg.out(_DebugLevel, 'my_id.loadLocalIdentity %d bytes read from %s' % (len(xmlid), filename))
if not xmlid:
if _Debug:
lg.out(_DebugLevel, "my_id.loadLocalIdentity SKIPPED, local identity in %s is EMPTY !!!" % filename)
return False
lid = identity.identity(xmlsrc=xmlid)
if not lid.isCorrect():
if _Debug:
lg.out(_DebugLevel, "my_id.loadLocalIdentity ERROR loaded identity is not Correct")
return False
if not lid.Valid():
if _Debug:
lg.out(_DebugLevel, "my_id.loadLocalIdentity ERROR loaded identity is not Valid")
return False
setLocalIdentity(lid)
setTransportOrder(getOrderFromContacts(_LocalIdentity))
if _Debug:
lg.out(_DebugLevel, "my_id.loadLocalIdentity my global id is %s" % getGlobalID())
return True
def setUp(self):
try:
bpio.rmdir_recursive('/tmp/.bitdust_tmp')
except Exception:
pass
lg.set_debug_level(30)
settings.init(base_dir='/tmp/.bitdust_tmp')
try:
os.makedirs('/tmp/.bitdust_tmp/metadata')
except:
pass
automat.OpenLogFile('/tmp/.bitdust_tmp/logs/automats.log')
self.my_current_key = None
fout = open('/tmp/_some_priv_key', 'w')
fout.write(_some_priv_key)
fout.close()
fout = open(settings.LocalIdentityFilename(), 'w')
fout.write(_some_identity_xml)
fout.close()
self.assertTrue(key.LoadMyKey(keyfilename='/tmp/_some_priv_key'))
self.assertTrue(my_id.loadLocalIdentity())
my_id.init()
try:
os.makedirs('/tmp/.bitdust_tmp/logs')
except:
pass
local_fs.WriteTextFile('/tmp/.bitdust_tmp/logs/parallelp.log', '')
tmpfile.init(temp_dir_path='/tmp/.bitdust_tmp/temp/')
os.makedirs(
'/tmp/.bitdust_tmp/backups/[email protected]_8084/1/F1234')
try:
bpio.rmdir_recursive('/tmp/_some_folder', ignore_errors=True)
except:
pass
os.makedirs('/tmp/_some_folder')
def _send_new_identity(self):
"""
Send created identity to the identity server to register it.
TODO: need to close transport and gateway after that
"""
lg.out(4, 'id_registrator._send_new_identity ')
from transport import gateway
from transport import network_transport
from transport.tcp import tcp_interface
gateway.init()
interface = tcp_interface.GateInterface()
transport = network_transport.NetworkTransport('tcp', interface)
transport.automat('init', gateway.listener())
transport.automat('start')
gateway.start()
sendfilename = settings.LocalIdentityFilename() + '.new'
dlist = []
for idurl in self.new_identity.sources:
self.free_idurls.remove(strng.to_bin(idurl))
_, host, _, _ = nameurl.UrlParse(idurl)
_, tcpport = known_servers.by_host().get(
host,
(settings.IdentityWebPort(), settings.IdentityServerPort()))
srvhost = net_misc.pack_address((
host,
tcpport,
))
dlist.append(
gateway.send_file_single(idurl, 'tcp', srvhost, sendfilename,
'Identity'))
# assert len(self.free_idurls) == 0
return DeferredList(dlist, fireOnOneCallback=True)
def _create_new_identity(self):
"""
Generate new Private key and new identity file.
Reads some extra info from config files.
"""
login = strng.to_bin(bpio.ReadTextFile(settings.UserNameFilename()))
externalIP = strng.to_bin(misc.readExternalIP()) or b'127.0.0.1'
if self.free_idurls[0].count(b'127.0.0.1'):
externalIP = b'127.0.0.1'
lg.out(
4,
'id_registrator._create_new_identity %s %s ' % (login, externalIP))
my_id.forgetLocalIdentity()
my_id.eraseLocalIdentity(do_backup=True)
key.ForgetMyKey(erase_file=True, do_backup=True)
key.InitMyKey()
if not key.isMyKeyReady():
key.GenerateNewKey()
lg.out(4, ' my key is ready')
ident = my_id.buildDefaultIdentity(name=login,
ip=externalIP,
idurls=self.free_idurls)
my_identity_xmlsrc = ident.serialize(as_text=True)
newfilename = settings.LocalIdentityFilename() + '.new'
bpio.WriteTextFile(newfilename, my_identity_xmlsrc)
try:
id_url.identity_cached(ident)
except:
lg.exc()
self.new_identity = ident
lg.out(
4, ' wrote %d bytes to %s' %
(len(my_identity_xmlsrc), newfilename))
def _create_new_identity(self):
"""
Generate new Private key and new identity file.
Reads some extra info from config files.
"""
login = strng.to_bin(bpio.ReadTextFile(settings.UserNameFilename()))
externalIP = strng.to_bin(misc.readExternalIP()) or b'127.0.0.1'
if self.free_idurls[0].count(b'127.0.0.1'):
externalIP = b'127.0.0.1'
lg.out(
4,
'id_registrator._create_new_identity %s %s ' % (login, externalIP))
key.InitMyKey()
if not key.isMyKeyReady():
key.GenerateNewKey()
lg.out(4, ' my key is ready')
ident = my_id.buildDefaultIdentity(name=login,
ip=externalIP,
idurls=self.free_idurls)
# my_id.rebuildLocalIdentity(
# identity_object=ident, revision_up=True, save_identity=False)
# localIP = bpio.ReadTextFile(settings.LocalIPFilename())
my_identity_xmlsrc = ident.serialize(as_text=True)
newfilename = settings.LocalIdentityFilename() + '.new'
bpio.WriteTextFile(newfilename, my_identity_xmlsrc)
self.new_identity = ident
lg.out(
4, ' wrote %d bytes to %s' %
(len(my_identity_xmlsrc), newfilename))
def saveLocalIdentity():
"""
Save identity object from memory into local file.
Do sign the identity than serialize to write to the file.
"""
global _LocalIdentity
if not isLocalIdentityReady():
lg.warn("ERROR local identity not exist!")
return False
if not _LocalIdentity.isCorrect():
lg.warn('local identity is not correct')
return False
_LocalIdentity.sign()
if not _LocalIdentity.Valid():
lg.err('local identity is not valid')
return False
xmlid = _LocalIdentity.serialize(as_text=True)
filename = bpio.portablePath(settings.LocalIdentityFilename())
bpio.WriteTextFile(filename, xmlid)
setTransportOrder(getOrderFromContacts(_LocalIdentity))
events.send('local-identity-written', data=dict(idurl=_LocalIdentity.getIDURL(), filename=filename))
if _Debug:
lg.out(_DebugLevel, "my_id.saveLocalIdentity %d bytes wrote to %s" % (len(xmlid), filename))
return True
def loadLocalIdentity():
"""
The core method.
The file [BitDust data dir]/metadata/localidentity keeps the user
identity in XML format. Do read the local file and set into object
in memory.
"""
global _LocalIdentity
global _LocalIDURL
global _LocalName
xmlid = ''
filename = bpio.portablePath(settings.LocalIdentityFilename())
if os.path.exists(filename):
xmlid = bpio.ReadTextFile(filename)
lg.out(6, 'my_id.loadLocalIdentity %d bytes read from\n %s' % (len(xmlid), filename))
if xmlid == '':
lg.out(2, "my_id.loadLocalIdentity SKIPPED, local identity in %s is EMPTY !!!" % filename)
return
lid = identity.identity(xmlsrc=xmlid)
if not lid.isCorrect():
lg.out(2, "my_id.loadLocalIdentity ERROR loaded identity is not Correct")
return
if not lid.Valid():
lg.out(2, "my_id.loadLocalIdentity ERROR loaded identity is not Valid")
return
setLocalIdentity(lid)
# _LocalIdentity = lid
# _LocalIDURL = lid.getIDURL()
# _LocalName = lid.getIDName()
setTransportOrder(getOrderFromContacts(_LocalIdentity))
lg.out(6, "my_id.loadLocalIdentity my name is [%s]" % lid.getIDName())
def setUp(self):
try:
bpio.rmdir_recursive('/tmp/.bitdust_tmp')
except Exception:
pass
lg.set_debug_level(30)
settings.init(base_dir='/tmp/.bitdust_tmp')
self.my_current_key = None
try:
os.makedirs('/tmp/.bitdust_tmp/metadata/')
except:
pass
try:
os.makedirs('/tmp/.bitdust_tmp/identitycache/')
except:
pass
fout = open('/tmp/_some_priv_key', 'w')
fout.write(_some_priv_key)
fout.close()
fout = open(settings.LocalIdentityFilename(), 'w')
fout.write(_some_identity_xml)
fout.close()
self.assertTrue(key.LoadMyKey(keyfilename='/tmp/_some_priv_key'))
self.assertTrue(my_id.loadLocalIdentity())
self.bob_ident = identity.identity(xmlsrc=_another_identity_xml)
identitycache.UpdateAfterChecking(idurl=self.bob_ident.getIDURL(),
xml_src=_another_identity_xml)
def _check_install(self):
"""
Return True if Private Key and local identity files exists and both is
valid.
"""
if _Debug:
lg.out(_DebugLevel, 'initializer._check_install')
from userid import identity
from crypt import key
keyfilename = settings.KeyFileName()
keyfilenamelocation = settings.KeyFileNameLocation()
if os.path.exists(keyfilenamelocation):
keyfilename = bpio.ReadTextFile(keyfilenamelocation)
if not os.path.exists(keyfilename):
keyfilename = settings.KeyFileName()
idfilename = settings.LocalIdentityFilename()
if not os.path.exists(keyfilename) or not os.path.exists(idfilename):
if _Debug:
lg.out(_DebugLevel, 'initializer._check_install local key or local id not exists')
return False
current_key = bpio.ReadTextFile(keyfilename)
current_id = bpio.ReadTextFile(idfilename)
if not current_id:
if _Debug:
lg.out(_DebugLevel, 'initializer._check_install local identity is empty ')
return False
if not current_key:
if _Debug:
lg.out(_DebugLevel, 'initializer._check_install private key is empty ')
return False
try:
key.InitMyKey()
except:
if _Debug:
lg.out(_DebugLevel, 'initializer._check_install fail loading private key ')
return False
try:
ident = identity.identity(xmlsrc=current_id)
except:
if _Debug:
lg.out(_DebugLevel, 'initializer._check_install fail init local identity ')
return False
if not ident.isCorrect():
lg.err('local identity is not correct !!!')
return False
try:
res = ident.Valid()
except:
if _Debug:
lg.out(_DebugLevel, 'failed to validate local identity')
return False
if not res:
lg.err('local identity is not valid !!!')
return False
if _Debug:
lg.out(_DebugLevel, 'initializer._check_install SUCCESS!!!')
return True
def setUp(self):
from logs import lg
from main import settings
from crypt import key
from userid import my_id
lg.set_debug_level(30)
settings.init()
self.my_current_key = None
if key.isMyKeyExists():
os.rename(settings.KeyFileName(), '/tmp/_current_priv_key')
fout = open('/tmp/_some_priv_key', 'w')
fout.write(_some_priv_key)
fout.close()
if my_id.isLocalIdentityExists():
os.rename(settings.LocalIdentityFilename(),
'/tmp/_current_localidentity')
fout = open(settings.LocalIdentityFilename(), 'w')
fout.write(_some_identity_xml)
fout.close()
self.assertTrue(key.LoadMyKey(keyfilename='/tmp/_some_priv_key'))
self.assertTrue(my_id.loadLocalIdentity())
def tearDown(self):
from main import settings
from crypt import key
from userid import my_id
key.ForgetMyKey()
my_id.forgetLocalIdentity()
if os.path.isfile('/tmp/_current_localidentity'):
os.rename('/tmp/_current_localidentity',
settings.LocalIdentityFilename())
if os.path.isfile('/tmp/_current_priv_key'):
os.rename('/tmp/_current_priv_key', settings.KeyFileName())
os.remove('/tmp/_some_priv_key')
def update():
"""
A good way to check all things - load and sign again.
"""
from userid import my_id
bpio.init()
settings.init()
src = bpio.ReadTextFile(settings.LocalIdentityFilename())
my_id.setLocalIdentity(identity(xmlsrc=src))
my_id.getLocalIdentity().sign()
my_id.saveLocalIdentity()
print my_id.getLocalIdentity().serialize()
def _check_install(self):
"""
Return True if Private Key and local identity files exists and both is
valid.
"""
lg.out(2, 'initializer._check_install')
from userid import identity
from crypt import key
keyfilename = settings.KeyFileName()
keyfilenamelocation = settings.KeyFileNameLocation()
if os.path.exists(keyfilenamelocation):
keyfilename = bpio.ReadTextFile(keyfilenamelocation)
if not os.path.exists(keyfilename):
keyfilename = settings.KeyFileName()
idfilename = settings.LocalIdentityFilename()
if not os.path.exists(keyfilename) or not os.path.exists(idfilename):
lg.out(
2,
'initializer._check_install local key or local id not exists')
return False
current_key = bpio.ReadBinaryFile(keyfilename)
current_id = bpio.ReadBinaryFile(idfilename)
if current_id == '':
lg.out(2, 'initializer._check_install local identity is empty ')
return False
if current_key == '':
lg.out(2, 'initializer._check_install private key is empty ')
return False
try:
key.InitMyKey()
except:
lg.out(2, 'initializer._check_install fail loading private key ')
return False
try:
ident = identity.identity(xmlsrc=current_id)
except:
lg.out(2, 'initializer._check_install fail init local identity ')
return False
try:
res = ident.Valid() and ident.isCorrect()
except:
lg.out(
2,
'initializer._check_install wrong data in local identity ')
return False
if not res:
lg.out(2,
'initializer._check_install local identity is not valid ')
return False
lg.out(2, 'initializer._check_install done')
return True
def eraseLocalIdentity():
filename = bpio.portablePath(settings.LocalIdentityFilename())
if not os.path.exists(filename):
lg.out(6, "my_id.eraseLocalIdentity SKIP file %s not exist" % filename)
return True
if not os.path.isfile(filename):
lg.out(6, "my_id.eraseLocalIdentity ERROR path %s is not a file" % filename)
return False
try:
os.remove(filename)
except:
lg.exc()
return False
lg.out(6, "my_id.eraseLocalIdentity file %s was deleted" % filename)
return True
def update():
"""
A good way to check all things - load and sign again.
Also will test rebuilding of the identity
"""
from userid import my_id
bpio.init()
settings.init()
src = bpio.ReadTextFile(settings.LocalIdentityFilename())
print(src)
my_id.setLocalIdentity(identity(xmlsrc=src))
my_id.getLocalIdentity().sign()
my_id.saveLocalIdentity()
print(my_id.getLocalIdentity().serialize())
print(my_id.rebuildLocalIdentity(revision_up=True))
def saveLocalIdentity():
"""
Save identity object from memory into local file.
Do sign the identity than serialize to write to the file.
"""
global _LocalIdentity
if not isLocalIdentityReady():
lg.warn("ERROR local identity not exist!")
return
if not _LocalIdentity.isCorrect():
lg.warn('local identity is not correct')
return
_LocalIdentity.sign()
xmlid = _LocalIdentity.serialize()
filename = bpio.portablePath(settings.LocalIdentityFilename())
bpio.WriteFile(filename, xmlid)
lg.out(6, "my_id.saveLocalIdentity %d bytes wrote to %s" % (len(xmlid), filename))
def setUp(self):
try:
bpio.rmdir_recursive('/tmp/.bitdust_tmp')
except Exception:
pass
lg.set_debug_level(30)
settings.init(base_dir='/tmp/.bitdust_tmp')
self.my_current_key = None
try:
os.makedirs('/tmp/.bitdust_tmp/metadata/')
except:
pass
fout = open('/tmp/_some_priv_key', 'w')
fout.write(_some_priv_key)
fout.close()
fout = open(settings.LocalIdentityFilename(), 'w')
fout.write(_some_identity_xml)
fout.close()
self.assertTrue(key.LoadMyKey(keyfilename='/tmp/_some_priv_key'))
self.assertTrue(my_id.loadLocalIdentity())
def test_signed_key(self):
try:
bpio.rmdir_recursive('/tmp/.bitdust_test_signed_key')
except Exception:
pass
lg.set_debug_level(30)
settings.init(base_dir='/tmp/.bitdust_test_signed_key')
self.my_current_key = None
try:
os.makedirs('/tmp/.bitdust_test_signed_key/metadata/')
except:
pass
fout = open('/tmp/_some_priv_key', 'w')
fout.write(_some_priv_key)
fout.close()
fout = open(settings.LocalIdentityFilename(), 'w')
fout.write(_some_identity_xml)
fout.close()
self.assertTrue(key.LoadMyKey(keyfilename='/tmp/_some_priv_key'))
self.assertTrue(my_id.loadLocalIdentity())
key_id = '[email protected]_8084'
my_keys.erase_key(key_id, keys_folder='/tmp/')
my_keys.register_key(key_id, _sample_private_key, keys_folder='/tmp/')
is_valid = my_keys.validate_key(my_keys.key_obj(key_id))
self.assertTrue(is_valid)
my_keys.sign_key(key_id)
signed_key_info = my_keys.get_key_info(key_id,
include_private=True,
include_signature=True)
self.assertTrue(my_keys.verify_key_info_signature(signed_key_info))
key.ForgetMyKey()
my_id.forgetLocalIdentity()
settings.shutdown()
os.remove('/tmp/_some_priv_key')
bpio.rmdir_recursive('/tmp/.bitdust_test_signed_key')
def isLocalIdentityExists():
"""
Return True if local file `~/.bitdust/metadata/localidentity` exists.
"""
return os.path.isfile(settings.LocalIdentityFilename())
def doVerifyAndRestore(self, arg):
global _WorkingKey
lg.out(4, 'identity_restorer.doVerifyAndRestore')
remote_identity_src = arg
if os.path.isfile(settings.KeyFileName()):
lg.out(
4,
'identity_restorer.doVerifyAndRestore will backup and remove '
+ settings.KeyFileName())
bpio.backup_and_remove(settings.KeyFileName())
if os.path.isfile(settings.LocalIdentityFilename()):
lg.out(
4,
'identity_restorer.doVerifyAndRestore will backup and remove '
+ settings.LocalIdentityFilename())
bpio.backup_and_remove(settings.LocalIdentityFilename())
try:
remote_ident = identity.identity(xmlsrc=remote_identity_src)
local_ident = identity.identity(xmlsrc=remote_identity_src)
except:
# lg.exc()
reactor.callLater(0.1, self.automat, 'restore-failed',
('remote identity have incorrect format', 'red'))
return
lg.out(
4, 'identity_restorer.doVerifyAndRestore checking remote identity')
try:
res = remote_ident.isCorrect()
except:
lg.exc()
res = False
if not res:
lg.out(
4,
'identity_restorer.doVerifyAndRestore remote identity is not correct FAILED!!!!'
)
reactor.callLater(0.1, self.automat, 'restore-failed',
('remote identity format is not correct', 'red'))
return
lg.out(
4, 'identity_restorer.doVerifyAndRestore validate remote identity')
try:
res = remote_ident.Valid()
except:
lg.exc()
res = False
if not res:
lg.out(
4,
'identity_restorer.doVerifyAndRestore validate remote identity FAILED!!!!'
)
reactor.callLater(0.1, self.automat, 'restore-failed',
('remote identity is not valid', 'red'))
return
key.ForgetMyKey()
bpio.WriteFile(settings.KeyFileName(), _WorkingKey)
try:
key.InitMyKey()
except:
key.ForgetMyKey()
# lg.exc()
try:
os.remove(settings.KeyFileName())
except:
pass
reactor.callLater(0.1, self.automat, 'restore-failed',
('private key is not valid', 'red'))
return
try:
local_ident.sign()
except:
# lg.exc()
reactor.callLater(0.1, self.automat, 'restore-failed',
('error while signing identity', 'red'))
return
if remote_ident.signature != local_ident.signature:
reactor.callLater(
0.1, self.automat, 'restore-failed',
('signature did not match, key verification failed!', 'red'))
return
my_id.setLocalIdentity(local_ident)
my_id.saveLocalIdentity()
bpio.WriteFile(settings.UserNameFilename(), my_id.getIDName())
if os.path.isfile(settings.KeyFileName() + '.backup'):
lg.out(
4,
'identity_restorer.doVerifyAndRestore will remove backup file for '
+ settings.KeyFileName())
bpio.remove_backuped_file(settings.KeyFileName())
if os.path.isfile(settings.LocalIdentityFilename() + '.backup'):
lg.out(
4,
'identity_restorer.doVerifyAndRestore will remove backup file for '
+ settings.LocalIdentityFilename())
bpio.remove_backuped_file(settings.LocalIdentityFilename())
reactor.callLater(0.1, self.automat, 'restore-success')
def init(UI='', options=None, args=None, overDict=None, executablePath=None):
"""
In the method ``main()`` program firstly checks the command line arguments
and then calls this method to start the whole process.
This initialize some low level modules and finally create an
instance of ``initializer()`` state machine and send it an event
"run".
"""
global AppDataDir
from logs import lg
lg.out(4, 'bpmain.run UI="%s"' % UI)
from system import bpio
#---settings---
from main import settings
if overDict:
settings.override_dict(overDict)
settings.init(AppDataDir)
if not options or options.debug is None:
lg.set_debug_level(settings.getDebugLevel())
from main import config
config.conf().addCallback('logs/debug-level',
lambda p, value, o, r: lg.set_debug_level(value))
#---USE_TRAY_ICON---
if os.path.isfile(settings.LocalIdentityFilename()) and os.path.isfile(settings.KeyFileName()):
try:
from system.tray_icon import USE_TRAY_ICON
if bpio.Mac() or not bpio.isGUIpossible():
lg.out(4, ' GUI is not possible')
USE_TRAY_ICON = False
if USE_TRAY_ICON:
from twisted.internet import wxreactor
wxreactor.install()
lg.out(4, ' wxreactor installed')
except:
USE_TRAY_ICON = False
lg.exc()
else:
lg.out(4, ' local identity or key file is not ready')
USE_TRAY_ICON = False
lg.out(4, ' USE_TRAY_ICON=' + str(USE_TRAY_ICON))
if USE_TRAY_ICON:
from system import tray_icon
icons_path = bpio.portablePath(os.path.join(bpio.getExecutableDir(), 'icons'))
lg.out(4, 'bpmain.run call tray_icon.init(%s)' % icons_path)
tray_icon.init(icons_path)
def _tray_control_func(cmd):
if cmd == 'exit':
from . import shutdowner
shutdowner.A('stop', 'exit')
tray_icon.SetControlFunc(_tray_control_func)
#---OS Windows init---
if bpio.Windows():
try:
from win32event import CreateMutex # @UnresolvedImport
mutex = CreateMutex(None, False, "BitDust")
lg.out(4, 'bpmain.run created a Mutex: %s' % str(mutex))
except:
lg.exc()
#---twisted reactor---
lg.out(4, 'bpmain.run want to import twisted.internet.reactor')
try:
from twisted.internet import reactor # @UnresolvedImport
except:
lg.exc()
sys.exit('Error initializing reactor in bpmain.py\n')
#---logfile----
if lg.logs_enabled() and lg.log_file():
lg.out(2, 'bpmain.run want to switch log files')
if bpio.Windows() and bpio.isFrozen():
lg.stdout_stop_redirecting()
lg.close_log_file()
lg.open_log_file(settings.MainLogFilename())
# lg.open_log_file(settings.MainLogFilename() + '-' + time.strftime('%y%m%d%H%M%S') + '.log')
if bpio.Windows() and bpio.isFrozen():
lg.stdout_start_redirecting()
#---memdebug---
# if settings.uconfig('logs.memdebug-enable') == 'True':
# try:
# from logs import memdebug
# memdebug_port = int(settings.uconfig('logs.memdebug-port'))
# memdebug.start(memdebug_port)
# reactor.addSystemEventTrigger('before', 'shutdown', memdebug.stop)
# lg.out(2, 'bpmain.run memdebug web server started on port %d' % memdebug_port)
# except:
# lg.exc()
#---process ID---
try:
pid = os.getpid()
pid_file_path = os.path.join(settings.MetaDataDir(), 'processid')
bpio.WriteTextFile(pid_file_path, str(pid))
lg.out(2, 'bpmain.run wrote process id [%s] in the file %s' % (str(pid), pid_file_path))
except:
lg.exc()
# #---reactor.callLater patch---
# if lg.is_debug(12):
# patchReactorCallLater(reactor)
# monitorDelayedCalls(reactor)
# #---plugins---
# from plugins import plug
# plug.init()
# reactor.addSystemEventTrigger('before', 'shutdown', plug.shutdown)
lg.out(2, " python executable is: %s" % sys.executable)
lg.out(2, " python version is:\n%s" % sys.version)
lg.out(2, " python sys.path is:\n %s" % ('\n '.join(sys.path)))
lg.out(2, "bpmain.run UI=[%s]" % UI)
if lg.is_debug(20):
lg.out(0, '\n' + bpio.osinfofull())
lg.out(4, 'import automats')
#---START!---
from automats import automat
automat.LifeBegins(lg.when_life_begins())
automat.OpenLogFile(settings.AutomatsLog())
from main import events
events.init()
from main import initializer
IA = initializer.A()
lg.out(4, 'sending event "run" to initializer()')
reactor.callWhenRunning(IA.automat, 'run', UI) # @UndefinedVariable
return IA
