def _list_local(params):
result = []
path = params['path']
if bpio.Linux() or bpio.Mac():
path = '/' + path.lstrip('/')
path = bpio.portablePath(path)
only_folders = params['onlyFolders']
if (path == '' or path == '/') and bpio.Windows():
for itemname in bpio.listLocalDrivesWindows():
result.append({
"name": itemname.rstrip('\\').rstrip('/').lower(),
"rights": "drwxr-xr-x",
"size": "",
"date": "",
"type": "dir",
"dirpath": path,
})
else:
if bpio.Windows() and len(path) == 2 and path[1] == ':':
path += '/'
apath = path
for itemname in bpio.list_dir_safe(apath):
itempath = os.path.join(apath, itemname)
if only_folders and not os.path.isdir(itempath):
continue
result.append({
"name": itemname,
"rights": "drwxr-xr-x",
"size": str(os.path.getsize(itempath)),
"date": str(os.path.getmtime(itempath)),
"type": "dir" if os.path.isdir(itempath) else "file",
"dirpath": apath,
})
return {'result': result, }
def run(child_name, params=[], base_dir='.', process_protocol=None):
"""
This is another portable solution to execute a process.
"""
if bpio.isFrozen() and bpio.Windows():
progpath = os.path.abspath(os.path.join(base_dir, child_name + '.exe'))
executable = progpath
cmdargs = [progpath]
cmdargs.extend(params)
else:
progpath = os.path.abspath(os.path.join(base_dir, child_name + '.py'))
executable = sys.executable
cmdargs = [executable, progpath]
cmdargs.extend(params)
if not os.path.isfile(executable):
lg.out(1, 'child_process.run ERROR %s not found' % executable)
return None
if not os.path.isfile(progpath):
lg.out(1, 'child_process.run ERROR %s not found' % progpath)
return None
lg.out(6, 'child_process.run: "%s"' % (' '.join(cmdargs)))
if bpio.Windows():
from twisted.internet import _dumbwin32proc
real_CreateProcess = _dumbwin32proc.win32process.CreateProcess # @UndefinedVariable
def fake_createprocess(_appName, _commandLine, _processAttributes,
_threadAttributes, _bInheritHandles,
creationFlags, _newEnvironment,
_currentDirectory, startupinfo):
import win32con # @UnresolvedImport
flags = win32con.CREATE_NO_WINDOW
return real_CreateProcess(_appName, _commandLine,
_processAttributes, _threadAttributes,
_bInheritHandles, flags, _newEnvironment,
_currentDirectory, startupinfo)
setattr(_dumbwin32proc.win32process, 'CreateProcess',
fake_createprocess)
if process_protocol is None:
process_protocol = ChildProcessProtocol(child_name)
try:
Process = reactor.spawnProcess(process_protocol,
executable,
cmdargs,
path=base_dir) # @UndefinedVariable
except:
lg.out(1, 'child_process.run ERROR executing: %s' % str(cmdargs))
lg.exc()
return None
if bpio.Windows():
setattr(_dumbwin32proc.win32process, 'CreateProcess',
real_CreateProcess)
lg.out(6, 'child_process.run [%s] pid=%d' % (child_name, Process.pid))
return Process
def execute(cmdargs,
base_dir=None,
process_protocol=None,
env=None,
callback=None):
global _CurrentProcess
if _Debug:
lg.out(_DebugLevel,
'git_proc.execute: "%s" in %s' % (' '.join(cmdargs), base_dir))
write2log('EXECUTE: %s, base_dir=%s' % (cmdargs, base_dir))
executable = cmdargs[0]
if bpio.Windows():
from twisted.internet import _dumbwin32proc
real_CreateProcess = _dumbwin32proc.win32process.CreateProcess # @UndefinedVariable
def fake_createprocess(_appName, _commandLine, _processAttributes,
_threadAttributes, _bInheritHandles,
creationFlags, _newEnvironment,
_currentDirectory, startupinfo):
import win32con # @UnresolvedImport
import subprocess
flags = win32con.CREATE_NO_WINDOW
startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW
startupinfo.wShowWindow = subprocess.SW_HIDE
return real_CreateProcess(_appName, _commandLine,
_processAttributes, _threadAttributes,
_bInheritHandles, flags, _newEnvironment,
_currentDirectory, startupinfo)
setattr(_dumbwin32proc.win32process, 'CreateProcess',
fake_createprocess)
if process_protocol is None:
process_protocol = GitProcessProtocol(callbacks=[
lambda out, err, ret_code: write2log('STDOUT:\n%s\nSTDERR:\n%s\n' %
(out, err)),
callback,
])
try:
_CurrentProcess = reactor.spawnProcess( # @UndefinedVariable
process_protocol,
executable,
cmdargs,
path=base_dir,
env=env)
except:
lg.exc()
return None
if bpio.Windows():
setattr(_dumbwin32proc.win32process, 'CreateProcess',
real_CreateProcess)
return _CurrentProcess
def run(args_list, base_dir=None, callback=None):
# TODO: Currently disabled
return None
global _CurrentProcess
if _CurrentProcess is not None:
lg.warn('only one process at once')
return None
if bpio.Windows():
cmdargs = [
'upnpc-static.exe',
]
elif bpio.Linux():
cmdargs = [
'upnpc',
]
elif bpio.Mac():
cmdargs = [
'upnpc',
]
else:
return None
if bpio.Windows():
# if we run windows binaries - upnpc-static.exe can be in the system sub folder
if not os.path.isfile(cmdargs[0]):
if os.path.isfile(os.path.join('system', cmdargs[0])):
cmdargs[0] = os.path.join('system', cmdargs[0])
else:
lg.warn('can not find executable file ' + cmdargs[0])
return None
cmdargs += args_list
if _Debug:
lg.out(_DebugLevel, 'run_upnpc.run is going to execute: %s' % cmdargs)
try:
out_data, returncode = execute_in_shell(cmdargs)
except:
lg.exc()
return None
if _Debug:
lg.out(
_DebugLevel, ' %s finished with return code: %s' %
(str(_CurrentProcess), str(returncode)))
_CurrentProcess = None
return out_data
def execute(cmdargs,
base_dir=None,
process_protocol=None,
env=None,
callback=None):
"""
"""
global _CurrentProcess
if _Debug:
lg.out(
_DebugLevel,
'geth_service.execute: "%s" in %s' % (' '.join(cmdargs), base_dir))
executable = cmdargs[0]
if bpio.Windows():
from twisted.internet import _dumbwin32proc
real_CreateProcess = _dumbwin32proc.win32process.CreateProcess
def fake_createprocess(_appName, _commandLine, _processAttributes,
_threadAttributes, _bInheritHandles,
creationFlags, _newEnvironment,
_currentDirectory, startupinfo):
import win32con
import subprocess
flags = win32con.CREATE_NO_WINDOW
startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW
startupinfo.wShowWindow = subprocess.SW_HIDE
return real_CreateProcess(_appName, _commandLine,
_processAttributes, _threadAttributes,
_bInheritHandles, flags, _newEnvironment,
_currentDirectory, startupinfo)
setattr(_dumbwin32proc.win32process, 'CreateProcess',
fake_createprocess)
if process_protocol is None:
process_protocol = GethProcessProtocol(callback)
try:
_CurrentProcess = reactor.spawnProcess(process_protocol,
executable,
cmdargs,
path=base_dir,
env=env)
except:
lg.exc()
return None
if bpio.Windows():
setattr(_dumbwin32proc.win32process, 'CreateProcess',
real_CreateProcess)
return _CurrentProcess
def detach(cmdargs):
"""
"""
lg.out(2, "child_process.detach %s" % str(cmdargs))
try:
if bpio.Windows():
import win32process # @UnresolvedImport
p = nonblocking.Popen(
cmdargs,
shell=False,
# stdin=subprocess.PIPE,
# stdout=subprocess.PIPE,
# stderr=subprocess.PIPE,
universal_newlines=False,
creationflags=win32process.CREATE_NO_WINDOW
| win32process.DETACHED_PROCESS,
close_fds=True,
)
else:
p = nonblocking.Popen(
cmdargs,
shell=False,
stdin=subprocess.PIPE,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
universal_newlines=False,
close_fds=True,
)
except:
lg.out(1, 'child_process.detach ERROR executing: %s' + str(cmdargs))
lg.exc()
return None
return p
def backuptardir(directorypath, arcname=None, recursive_subfolders=True, compress=None):
"""
Returns file descriptor for process that makes tar archive.
In other words executes a child process and create a Pipe to
communicate with it.
"""
if not bpio.pathIsDir(directorypath):
lg.out(1, 'backup_tar.backuptar ERROR %s not found' % directorypath)
return None
subdirs = 'subdirs'
if not recursive_subfolders:
subdirs = 'nosubdirs'
if compress is None:
compress = 'none'
if arcname is None:
arcname = strng.to_text(os.path.basename(directorypath))
# lg.out(14, "backup_tar.backuptar %s %s compress=%s" % (directorypath, subdirs, compress))
if bpio.Windows():
if bpio.isFrozen():
commandpath = "bppipe.exe"
cmdargs = [commandpath, subdirs, compress, directorypath, arcname]
else:
commandpath = "bppipe.py"
cmdargs = [sys.executable, commandpath, subdirs, compress, directorypath, arcname]
else:
commandpath = "bppipe.py"
cmdargs = [sys.executable, commandpath, subdirs, compress, directorypath, arcname]
if not os.path.isfile(commandpath):
lg.out(1, 'backup_tar.backuptar ERROR %s not found' % commandpath)
return None
# lg.out(14, "backup_tar.backuptar going to execute %s" % str(cmdargs))
# p = child_process.run('bppipe', cmdargs[2:])
p = child_process.pipe(cmdargs)
return p
def ExplorePathInOS(filepath):
"""
Very nice and portable way to show location or file on local disk.
"""
try:
if bpio.Windows():
# os.startfile(filepath)
if os.path.isfile(filepath):
subprocess.Popen([
'explorer', '/select,',
'%s' % (filepath.replace('/', '\\'))
])
else:
subprocess.Popen(
['explorer',
'%s' % (filepath.replace('/', '\\'))])
elif bpio.Linux():
subprocess.Popen(['`which xdg-open`', filepath])
elif bpio.Mac():
subprocess.Popen(["open", "-R", filepath])
except:
try:
import webbrowser
webbrowser.open(filepath)
except:
lg.exc()
return
def getClipboardText():
"""
A portable way to get a clipboard data - some sort of Ctrl-V.
"""
if bpio.Windows():
try:
import win32clipboard # @UnresolvedImport
import win32con # @UnresolvedImport
win32clipboard.OpenClipboard()
d = win32clipboard.GetClipboardData(win32con.CF_TEXT)
win32clipboard.CloseClipboard()
return d.replace('\r\n', '\n')
except:
lg.exc()
return ''
elif bpio.Linux():
try:
import wx
# may crash, otherwise
# this needs app.MainLoop() to be started
if not wx.TheClipboard.IsOpened(): # @UndefinedVariable
do = wx.TextDataObject() # @UndefinedVariable
wx.TheClipboard.Open() # @UndefinedVariable
success = wx.TheClipboard.GetData(do) # @UndefinedVariable
wx.TheClipboard.Close() # @UndefinedVariable
if success:
return do.GetText()
else:
return ''
else:
return ''
except:
return ''
else:
return ''
def __init__(self, ncpus):
self._ncpus = ncpus
if six.PY34:
try:
multiprocessing.set_start_method('spawn')
except RuntimeError:
pass
multiprocessing.util.log_to_stderr(multiprocessing.util.SUBDEBUG)
from system import bpio
if bpio.Windows():
from system import deploy
deploy.init_base_dir()
venv_python_path = os.path.join(deploy.current_base_dir(), 'venv',
'Scripts', 'BitDustNode.exe')
lg.info('will use %s as multiprocessing executable' %
venv_python_path)
multiprocessing.set_executable(venv_python_path)
self.processor = multiprocessing.Pool(ncpus)
#: implement queue per Manager instance
# self.queue = multiprocessing.Queue()
self.tasks = OrderedDict({})
self.task_id = 0
self.thread = Thread(target=func_thread,
args=(self.tasks, self.processor))
self.thread.daemon = True
self.thread.start()
self._propagate_queue()
def pipe(cmdargs):
"""
Execute a process in different way, create a Pipe to do read/write
operations with child process.
See ``lib.nonblocking`` module.
"""
lg.out(6, "child_process.pipe %s" % str(cmdargs))
try:
if bpio.Windows():
import win32process # @UnresolvedImport
p = nonblocking.Popen(
cmdargs,
shell=True,
stdin=subprocess.PIPE,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
universal_newlines=False,
creationflags=win32process.CREATE_NO_WINDOW,
)
else:
p = nonblocking.Popen(
cmdargs,
shell=False,
stdin=subprocess.PIPE,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
universal_newlines=False,
)
except:
lg.out(1, 'child_process.pipe ERROR executing: %s' + str(cmdargs))
lg.exc()
return None
return p
def do_restart(param):
from lib import misc
from system import bpio
detach = False
if bpio.Windows():
detach = True
misc.DoRestart(param, detach=detach)
def backuptarfile(filepath, arcname=None, compress=None):
"""
Almost same - returns file descriptor for process that makes tar archive.
But tar archive is created from single file, not folder.
"""
if not os.path.isfile(filepath):
lg.out(1, 'backup_tar.backuptarfile ERROR %s not found' % filepath)
return None
if compress is None:
compress = 'none'
if arcname is None:
arcname = strng.to_text(os.path.basename(filepath))
# lg.out(14, "backup_tar.backuptarfile %s compress=%s" % (filepath, compress))
if bpio.Windows():
if bpio.isFrozen():
commandpath = "bppipe.exe"
cmdargs = [commandpath, 'nosubdirs', compress, filepath, arcname]
else:
commandpath = "bppipe.py"
cmdargs = [sys.executable, commandpath, 'nosubdirs', compress, filepath, arcname]
else:
commandpath = "bppipe.py"
cmdargs = [sys.executable, commandpath, 'nosubdirs', compress, filepath, arcname]
if not os.path.isfile(commandpath):
lg.out(1, 'backup_tar.backuptarfile ERROR %s not found' % commandpath)
return None
# lg.out(12, "backup_tar.backuptarfile going to execute %s" % str(cmdargs))
# p = run(cmdargs)
p = child_process.pipe(cmdargs)
return p
def run(cmdargs, base_dir=None, git_bin=None, env=None, callback=None):
"""
"""
if _Debug:
lg.out(_DebugLevel, 'git_proc.run')
base_dir = base_dir or bpio.getExecutableDir()
if bpio.Windows():
cmd = ['git', ] + cmdargs
if git_bin:
git_exe = git_bin
else:
git_exe = bpio.portablePath(os.path.join(base_dir, '..', 'git', 'bin', 'git.exe'))
if not os.path.isfile(git_exe):
if _Debug:
lg.out(_DebugLevel, ' not found git.exe, try to run from shell')
try:
response, error, retcode = execute_in_shell(cmd, base_dir=base_dir)
except:
response = ''
error = ''
retcode = 1
if callback:
callback(response, error, retcode)
return
if _Debug:
lg.out(_DebugLevel, ' found git in %s' % git_exe)
cmd = [git_exe, ] + cmdargs
else:
cmd = [git_bin or 'git', ] + cmdargs
execute(cmd, callback=callback, base_dir=base_dir, env=env)
def extracttar(tarfile, outdir):
"""
Opposite method, run bppipe to extract files and folders from ".tar" file.
"""
if not os.path.isfile(tarfile):
lg.out(1, 'backup_tar.extracttar ERROR %s not found' % tarfile)
return None
lg.out(6, "backup_tar.extracttar %s %s" % (tarfile, outdir))
if bpio.Windows():
if bpio.isFrozen():
commandpath = 'bppipe.exe'
cmdargs = [commandpath, 'extract', tarfile, outdir]
else:
commandpath = "bppipe.py"
cmdargs = [sys.executable, commandpath, 'extract', tarfile, outdir]
else:
commandpath = "bppipe.py"
cmdargs = [sys.executable, commandpath, 'extract', tarfile, outdir]
if not os.path.isfile(commandpath):
lg.out(1, 'backup_tar.extracttar ERROR %s is not found' % commandpath)
return None
# p = run(cmdargs)
cmdargs = [strng.to_text(a) for a in cmdargs]
p = child_process.pipe(cmdargs)
return p
def run(Tester):
global _CurrentProcess
# lg.out(8, 'localtester.run ' + str(Tester))
if bpio.isFrozen() and bpio.Windows():
commandpath = 'bptester.exe'
cmdargs = [commandpath, Tester]
else:
commandpath = 'bptester.py'
cmdargs = [sys.executable, commandpath, Tester]
if not os.path.isfile(commandpath):
lg.out(1, 'localtester.run ERROR %s not found' % commandpath)
return None
lg.out(14, 'localtester.run execute: %s' % cmdargs)
try:
if bpio.Windows():
import win32process
_CurrentProcess = nonblocking.Popen(
cmdargs,
shell=False,
stdin=subprocess.PIPE,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
universal_newlines=False,
creationflags=win32process.CREATE_NO_WINDOW,
)
else:
_CurrentProcess = nonblocking.Popen(
cmdargs,
shell=False,
stdin=subprocess.PIPE,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
universal_newlines=False,
)
except:
lg.out(1, 'localtester.run ERROR executing: %s' % str(cmdargs))
lg.exc()
return None
return _CurrentProcess
def shutdown():
from logs import lg
from main import config
from system import bpio
if _Debug:
lg.out(_DebugLevel, 'bpmain.shutdown')
if config.conf():
config.conf().removeConfigNotifier('logs/debug-level')
from . import shutdowner
shutdowner.A('reactor-stopped')
from main import events
events.shutdown()
from automats import automat
automat.objects().clear()
if len(automat.index()) > 0:
lg.warn('%d automats was not cleaned' % len(automat.index()))
for a in automat.index().keys():
if _Debug:
lg.out(_DebugLevel, ' %r' % a)
else:
if _Debug:
lg.out(
_DebugLevel,
'bpmain.shutdown automat.objects().clear() SUCCESS, no state machines left in memory'
)
if _Debug:
lg.out(
_DebugLevel, 'bpmain.shutdown currently %d threads running:' %
len(threading.enumerate()))
for t in threading.enumerate():
if _Debug:
lg.out(_DebugLevel, ' ' + str(t))
if _Debug:
lg.out(_DebugLevel,
'bpmain.shutdown finishing and closing log file, EXIT')
automat.CloseLogFile()
lg.close_log_file()
lg.close_intercepted_log_file()
if bpio.Windows() and bpio.isFrozen():
lg.stdout_stop_redirecting()
from main import settings
settings.shutdown()
return 0
def _config(params):
result = []
homepath = bpio.portablePath(os.path.expanduser('~'))
if bpio.Windows():
# set "c:" as a starting point when pick files for Windows
# probably should be MyDocuments folder or something else,
# but lets take that for now
homepath = homepath[:2]
result.append({'key': 'homepath',
'value': homepath})
return {'result': result, }
def init():
lg.out(4, 'os_windows_update.init')
# update_shedule_file(settings.getUpdatesSheduleData())
if not bpio.isFrozen() or not bpio.Windows():
lg.out(6, 'os_windows_update.init finishing')
return
# if not os.path.isfile(settings.VersionFile()):
# bpio.WriteFile(settings.VersionFile(), '')
SetLocalDir(bpio.getExecutableDir())
if settings.getUpdatesMode() != settings.getUpdatesModeValues()[2]:
lg.out(6, 'os_windows_update.init starting the loop')
reactor.callLater(0, loop, True)
else:
lg.out(6, 'os_windows_update.init skip, update mode is: %s' % settings.getUpdatesMode())
def GetDriveSpace(path):
"""
So this a sort of portable way to get the free HDD space in the system.
"""
if bpio.Windows():
drive = os.path.abspath(path)[0]
if os.path.isdir(drive + ':'):
# the drive the data directory is on, ie C
return GetWinDriveSpace(drive)
else:
return None, None
else:
# on linux the mount points can make a directory be off a different disk than root
return GetLinuxDriveSpace(path)
def do_restart(param):
from lib import misc
from system import bpio
settings.init()
# appdata = settings.BaseDir()
detach = False
if bpio.Windows():
detach = True
misc.DoRestart(
param,
detach=detach,
# std_out=os.path.join(appdata, 'logs', 'stdout.log'),
# std_err=os.path.join(appdata, 'logs', 'stderr.log'),
)
settings.shutdown()
def getValueOfType(self, entryPath):
from main import config_types
typ = self.getType(entryPath)
value = None
if not typ or typ in [
config_types.TYPE_STRING,
config_types.TYPE_TEXT,
config_types.TYPE_UNDEFINED,
]:
value = self.getData(entryPath)
elif typ in [
config_types.TYPE_BOOLEAN,
]:
value = self.getBool(entryPath)
elif typ in [
config_types.TYPE_INTEGER,
config_types.TYPE_POSITIVE_INTEGER,
config_types.TYPE_NON_ZERO_POSITIVE_INTEGER,
config_types.TYPE_PORT_NUMBER,
]:
value = self.getInt(entryPath)
elif typ in [
config_types.TYPE_FOLDER_PATH,
config_types.TYPE_FILE_PATH,
config_types.TYPE_COMBO_BOX,
config_types.TYPE_PASSWORD,
]:
value = self.getString(entryPath) or ''
if typ in [
config_types.TYPE_FOLDER_PATH,
]:
if value:
from system import bpio
if bpio.Windows():
if not value.endswith(u'/') and not value.endswith(
u'\\'):
value = value + u'\\'
elif not value.endswith(u'/'):
value = value + u'/'
else:
value = self.getData(entryPath)
return value
def setClipboardText(txt):
"""
A portable way to set a clipboard data - just like when you select something and press Ctrl-C.
"""
if bpio.Windows():
try:
import win32clipboard # @UnresolvedImport
import win32con # @UnresolvedImport
win32clipboard.OpenClipboard()
win32clipboard.EmptyClipboard()
win32clipboard.SetClipboardData(win32con.CF_TEXT, txt)
win32clipboard.CloseClipboard()
except:
lg.exc()
elif bpio.Linux():
try:
import wx
clipdata = wx.TextDataObject() # @UndefinedVariable
clipdata.SetText(txt)
if wx.TheClipboard: # @UndefinedVariable
wx.TheClipboard.Open() # @UndefinedVariable
wx.TheClipboard.SetData(clipdata) # @UndefinedVariable
wx.TheClipboard.Close() # @UndefinedVariable
except:
lg.exc()
elif bpio.Mac():
try:
fd, fname = tempfile.mkstemp()
os.write(fd, txt)
os.close(fd)
os.system('cat %s | pbcopy' % fname)
os.remove(fname)
except:
lg.exc()
def DoRestart(param='',
detach=False,
std_out='/dev/null',
std_err='/dev/null'):
"""
A smart and portable way to restart a whole program.
"""
if bpio.Windows():
if bpio.isFrozen():
# lg.out(2, "misc.DoRestart under Windows (Frozen), param=%s" % param)
# lg.out(2, "misc.DoRestart sys.executable=" + sys.executable)
# lg.out(2, "misc.DoRestart sys.argv=" + str(sys.argv))
starter_filepath = os.path.join(bpio.getExecutableDir(),
settings.WindowsStarterFileName())
if not os.path.isfile(starter_filepath):
# lg.out(2, "misc.DoRestart ERROR %s not found" % starter_filepath)
main_filepath = os.path.join(
bpio.getExecutableDir(),
settings.WindowsMainScriptFileName())
cmdargs = [
os.path.basename(main_filepath),
]
if param != '':
cmdargs.append(param)
# lg.out(2, "misc.DoRestart cmdargs="+str(cmdargs))
return os.spawnve(os.P_DETACH, main_filepath, cmdargs,
os.environ) # @UndefinedVariable
cmdargs = [
os.path.basename(starter_filepath),
]
if param != '':
cmdargs.append(param)
# lg.out(2, "misc.DoRestart cmdargs="+str(cmdargs))
return os.spawnve(os.P_DETACH, starter_filepath, cmdargs,
os.environ) # @UndefinedVariable
pypath = sys.executable
cmdargs = [
sys.executable,
]
cmdargs.append(sys.argv[0])
cmdargs += sys.argv[1:]
if param != '' and not sys.argv.count(param):
cmdargs.append(param)
if cmdargs.count('restart'):
cmdargs.remove('restart')
if cmdargs.count('detach'):
cmdargs.remove('detach')
if cmdargs.count('daemon'):
cmdargs.remove('daemon')
if detach:
from system import child_process
cmdargs = [strng.to_text(a) for a in cmdargs]
return child_process.detach(cmdargs)
return os.execvpe(pypath, cmdargs, os.environ)
pypyth = sys.executable
cmdargs = [
sys.executable,
]
if sys.argv[0] == '/usr/share/bitdust/bitdust.py':
cmdargs.append('/usr/bin/bitdust')
else:
cmdargs.append(sys.argv[0])
if param:
cmdargs.append(param)
if cmdargs.count('restart'):
cmdargs.remove('restart')
if cmdargs.count('detach'):
cmdargs.remove('detach')
if cmdargs.count('daemon'):
cmdargs.remove('daemon')
pid = os.fork()
if pid != 0:
return None
if detach:
cmdargs[1] = os.path.abspath(cmdargs[1])
cmdargs.append('1>%s' % std_out)
cmdargs.append('2>%s' % std_err)
cmd = '/usr/bin/nohup ' + (' '.join(cmdargs)) + ' &'
BITDUST_COVERAGE_PROCESS_START = os.environ.get(
'COVERAGE_PROCESS_START')
if BITDUST_COVERAGE_PROCESS_START:
cmd = 'COVERAGE_PROCESS_START="%s" %s' % (
BITDUST_COVERAGE_PROCESS_START,
cmd,
)
BITDUST_LOG_USE_COLORS = os.environ.get('BITDUST_LOG_USE_COLORS')
if BITDUST_LOG_USE_COLORS:
cmd = 'BITDUST_LOG_USE_COLORS="%s" %s' % (
BITDUST_LOG_USE_COLORS,
cmd,
)
return os.system(cmd)
return os.execvpe(pypyth, cmdargs, os.environ)
from __future__ import print_function
import os
import time
import glob
#------------------------------------------------------------------------------
from lib import diskspace
from main import settings
from system import bpio
#------------------------------------------------------------------------------
if bpio.Windows():
import win32api # @UnresolvedImport
import win32file # @UnresolvedImport
#------------------------------------------------------------------------------
def GetWinDriveSpace(drive):
"""
For Windows.
Return a tuple (<free space in bytes>, <total space in bytes>) or
(None, None). Call system method ``win32file.GetDiskFreeSpace``.
"""
try:
sectorsPerCluster, bytesPerSector, numFreeClusters, totalNumClusters = win32file.GetDiskFreeSpace(
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
def main(executable_path=None, start_reactor=True):
"""
THE ENTRY POINT
"""
global AppDataDir
pars = parser()
(opts, args) = pars.parse_args()
if opts.coverage:
import coverage # @UnresolvedImport
cov = coverage.Coverage(config_file=opts.coverage_config)
cov.start()
overDict = override_options(opts, args)
cmd = ''
if len(args) > 0:
cmd = args[0].lower()
try:
from system import deploy
except:
dirpath = os.path.dirname(os.path.abspath(sys.argv[0]))
sys.path.insert(0, os.path.abspath(os.path.join(dirpath, '..')))
from distutils.sysconfig import get_python_lib
sys.path.append(os.path.join(get_python_lib(), 'bitdust'))
try:
from system import deploy
except:
print_text('ERROR! can not import working code. Python Path:')
print_text('\n'.join(sys.path))
return 1
#---install---
if cmd in [
'deploy',
'install',
'venv',
'virtualenv',
]:
from system import deploy
return deploy.run(args)
if opts.appdir:
appdata = opts.appdir
AppDataDir = appdata
else:
curdir = os.getcwd()
appdatafile = os.path.join(curdir, 'appdata')
defaultappdata = deploy.default_base_dir_portable()
appdata = defaultappdata
if os.path.isfile(appdatafile):
try:
appdata = os.path.abspath(
open(appdatafile, 'rb').read().strip())
except:
appdata = defaultappdata
if not os.path.isdir(appdata):
appdata = defaultappdata
AppDataDir = appdata
#---BitDust Home
deploy.init_base_dir(base_dir=AppDataDir)
from logs import lg
#---init IO module
from system import bpio
bpio.init()
appList = bpio.find_main_process(
pid_file_path=os.path.join(appdata, 'metadata', 'processid'))
if bpio.Android():
lg.close_intercepted_log_file()
lg.open_intercepted_log_file(
'/storage/emulated/0/Android/data/org.bitdust_io.bitdust1/files/Documents/.bitdust/logs/android.log'
)
# sys.excepthook = lg.exception_hook
#---init logging
from twisted.internet.defer import setDebugging
if _Debug:
if bpio.isFrozen():
setDebugging(False)
else:
setDebugging(True)
else:
setDebugging(False)
from twisted.logger import globalLogPublisher, LogLevel
tw_log_observer = TwistedUnhandledErrorsObserver(level=LogLevel.critical)
globalLogPublisher.addObserver(tw_log_observer)
#---life begins!
# ask logger to count time for each log line from that moment, not absolute time
lg.life_begins()
# try to read debug level value at the early stage - no problem if fail here
try:
if cmd == '' or cmd == 'start' or cmd == 'go' or cmd == 'show' or cmd == 'open':
lg.set_debug_level(
int(
bpio.ReadTextFile(
os.path.abspath(
os.path.join(appdata, 'config', 'logs',
'debug-level')))))
except:
pass
if opts.no_logs:
lg.disable_logs()
if opts.debug or str(opts.debug) == '0':
lg.set_debug_level(int(opts.debug))
#---logpath---
logpath = None
if opts.output:
logpath = opts.output
else:
try:
os.makedirs(os.path.join(appdata, 'logs'), exist_ok=True)
except:
pass
logpath = os.path.join(appdata, 'logs', 'stdout.log')
need_redirecting = False
if bpio.Windows() and not bpio.isConsoled():
need_redirecting = True
if logpath:
if not appList:
if cmd not in [
'detach',
'daemon',
'stop',
'kill',
'shutdown',
'restart',
'reboot',
'reconnect',
'show',
'open',
]:
lg.open_log_file(logpath)
if bpio.Windows() and bpio.isFrozen():
need_redirecting = True
if bpio.Android():
need_redirecting = True
if opts.quite and not opts.verbose:
lg.disable_output()
else:
if need_redirecting:
lg.stdout_start_redirecting()
lg.stderr_start_redirecting()
#---start---
if cmd == '' or cmd == 'start' or cmd == 'go':
if appList:
print_text('BitDust already started, found another process: %s\n' %
str(appList),
nl='')
bpio.shutdown()
return 0
UI = ''
try:
ret = run(UI, opts, args, overDict, executable_path, start_reactor)
except:
lg.exc()
ret = 1
bpio.shutdown()
if opts.coverage:
cov.stop()
cov.save()
if opts.coverage_report:
cov.report(file=open(opts.coverage_report, 'w'))
return ret
#---daemon---
elif cmd == 'detach' or cmd == 'daemon':
appList = bpio.find_main_process(
pid_file_path=os.path.join(appdata, 'metadata', 'processid'))
if len(appList) > 0:
print_text('main BitDust process already started: %s\n' %
str(appList),
nl='')
bpio.shutdown()
if opts.coverage:
cov.stop()
cov.save()
if opts.coverage_report:
cov.report(file=open(opts.coverage_report, 'w'))
return 0
from lib import misc
print_text('new BitDust process will be started in daemon mode\n',
nl='')
result = misc.DoRestart(
detach=True,
# std_out=os.path.join(appdata, 'logs', 'stdout.log'),
# std_err=os.path.join(appdata, 'logs', 'stderr.log'),
)
if result is not None:
try:
result = int(result)
except:
try:
result = result.pid
except:
pass
bpio.shutdown()
if opts.coverage:
cov.stop()
cov.save()
if opts.coverage_report:
cov.report(file=open(opts.coverage_report, 'w'))
return 0
#---restart---
elif cmd == 'restart' or cmd == 'reboot':
appList = bpio.find_main_process(
pid_file_path=os.path.join(appdata, 'metadata', 'processid'))
ui = False
if len(appList) > 0:
print_text('found main BitDust process: %r ... ' % appList, nl='')
def done(x):
print_text('finished successfully\n', nl='')
from twisted.internet import reactor # @UnresolvedImport
if reactor.running and not reactor._stopped: # @UndefinedVariable
reactor.stop() # @UndefinedVariable
def failed(x):
if isinstance(x, Failure):
print_text('finished with: %s\n' % x.getErrorMessage(),
nl='')
else:
print_text('finished successfully\n', nl='')
ok = str(x).count('Connection was closed cleanly') > 0
from twisted.internet import reactor # @UnresolvedImport
if ok and reactor.running and not reactor._stopped: # @UndefinedVariable
# print_text('DONE\n', '')
reactor.stop() # @UndefinedVariable
return
print_text('forcing previous process shutdown\n', nl='')
try:
kill()
except:
lg.exc()
from lib import misc
reactor.addSystemEventTrigger( # @UndefinedVariable
'after',
'shutdown',
misc.DoRestart,
param='show' if ui else '',
detach=True,
# std_out=os.path.join(appdata, 'logs', 'stdout.log'),
# std_err=os.path.join(appdata, 'logs', 'stderr.log'),
)
reactor.stop() # @UndefinedVariable
try:
from twisted.internet import reactor # @UnresolvedImport
# from interface.command_line import run_url_command
# d = run_url_command('?action=restart', False)
# from interface import cmd_line
# d = cmd_line.call_xmlrpc_method('restart', ui)
from interface import cmd_line_json
d = cmd_line_json.call_websocket_method('process_restart',
websocket_timeout=5)
d.addCallback(done)
d.addErrback(failed)
reactor.run() # @UndefinedVariable
bpio.shutdown()
if opts.coverage:
cov.stop()
cov.save()
if opts.coverage_report:
cov.report(file=open(opts.coverage_report, 'w'))
return 0
except:
lg.exc()
bpio.shutdown()
if opts.coverage:
cov.stop()
cov.save()
if opts.coverage_report:
cov.report(file=open(opts.coverage_report, 'w'))
return 1
else:
ui = ''
if cmd == 'restart':
ui = 'show'
try:
ret = run(ui, opts, args, overDict, executable_path)
except:
lg.exc()
ret = 1
bpio.shutdown()
if opts.coverage:
cov.stop()
cov.save()
if opts.coverage_report:
cov.report(file=open(opts.coverage_report, 'w'))
return ret
#---show---
elif cmd == 'show' or cmd == 'open':
if not bpio.isGUIpossible():
print_text('BitDust GUI is turned OFF\n', nl='')
bpio.shutdown()
return 0
if bpio.Linux() and not bpio.X11_is_running():
print_text('this operating system not supporting X11 interface\n',
nl='')
bpio.shutdown()
return 0
appList = bpio.find_main_process(
pid_file_path=os.path.join(appdata, 'metadata', 'processid'))
if len(appList) == 0:
try:
ret = run('show', opts, args, overDict, executable_path)
except:
lg.exc()
ret = 1
bpio.shutdown()
return ret
# print_text('found main BitDust process: %s, start the GUI\n' % str(appList))
# ret = show()
bpio.shutdown()
return ret
#---stop---
elif cmd == 'stop' or cmd == 'kill' or cmd == 'shutdown':
if cmd == 'kill':
ret = kill()
bpio.shutdown()
if opts.coverage:
cov.stop()
cov.save()
if opts.coverage_report:
cov.report(file=open(opts.coverage_report, 'w'))
return ret
appList = bpio.find_main_process(pid_file_path=os.path.join(
appdata, 'metadata', 'processid'), )
if len(appList) > 0:
if cmd == 'kill':
print_text(
'found main BitDust process: %s, about to kill running process ... '
% appList,
nl='')
ret = kill()
bpio.shutdown()
if opts.coverage:
cov.stop()
cov.save()
if opts.coverage_report:
cov.report(file=open(opts.coverage_report, 'w'))
return ret
try:
from twisted.internet import reactor # @UnresolvedImport
from twisted.python.failure import Failure
def _stopped(x):
if _Debug:
if isinstance(x, Failure):
print_text('finished with: %s\n' %
x.getErrorMessage(),
nl='')
else:
print_text('finished with: %s\n' % x, nl='')
else:
print_text('finished successfully\n', nl='')
reactor.stop() # @UndefinedVariable
bpio.shutdown()
print_text('found main BitDust process: %s ... ' % appList,
nl='')
from interface import cmd_line_json
cmd_line_json.call_websocket_method(
'process_stop', websocket_timeout=2).addBoth(_stopped)
reactor.run() # @UndefinedVariable
if opts.coverage:
cov.stop()
cov.save()
if opts.coverage_report:
cov.report(file=open(opts.coverage_report, 'w'))
return 0
except:
lg.exc()
ret = kill()
bpio.shutdown()
if opts.coverage:
cov.stop()
cov.save()
if opts.coverage_report:
cov.report(file=open(opts.coverage_report, 'w'))
return ret
else:
appListAllChilds = bpio.find_main_process(
check_processid_file=False,
extra_lookups=[],
)
if len(appListAllChilds) > 0:
print_text(
'BitDust child processes found: %s, performing "kill process" action ...\n'
% appListAllChilds,
nl='')
ret = kill()
if opts.coverage:
cov.stop()
cov.save()
if opts.coverage_report:
cov.report(file=open(opts.coverage_report, 'w'))
return ret
print_text('BitDust is not running at the moment\n', nl='')
bpio.shutdown()
if opts.coverage:
cov.stop()
cov.save()
if opts.coverage_report:
cov.report(file=open(opts.coverage_report, 'w'))
return 0
#---command_line---
from interface import cmd_line_json as cmdln
ret = cmdln.run(opts, args, pars, overDict, executable_path)
if ret == 2:
print_text(usage_text())
bpio.shutdown()
#---coverage report---
if opts.coverage:
cov.stop()
cov.save()
if opts.coverage_report:
cov.report(file=open(opts.coverage_report, 'w'))
return ret
def renderWizardStoragePage(self, request):
template = 'pages/wizard_storage.html'
req = {}
if request is not None:
req = request.REQUEST
self.data['customersdir'] = unicode(req.get('customersdir',
settings.getCustomersFilesDir()))
self.data['localbackupsdir'] = unicode(req.get('localbackupsdir',
settings.getLocalBackupsDir()))
self.data['restoredir'] = unicode(req.get('restoredir',
settings.getRestoreDir()))
self.data['needed'] = req.get('needed', self.data['needed'])
neededV = diskspace.GetBytesFromString(self.data['needed'] + ' Mb',
settings.DefaultNeededBytes())
self.data['donated'] = req.get('donated', self.data['donated'])
donatedV = diskspace.GetBytesFromString(self.data['donated'] + ' Mb',
settings.DefaultDonatedBytes())
self.data['suppliers'] = req.get('suppliers', self.data['suppliers'])
mounts = []
freeSpaceIsOk = True
if bpio.Windows():
for d in bpio.listLocalDrivesWindows():
free, total = diskusage.GetWinDriveSpace(d[0])
if free is None or total is None:
continue
color = '#ffffff'
if self.data['customersdir'][0].upper() == d[0].upper():
color = '#60e060'
if donatedV >= free:
color = '#e06060'
freeSpaceIsOk = False
if self.data['localbackupsdir'][0].upper() == d[0].upper():
color = '#60e060'
if neededV >= free:
color = '#e06060'
freeSpaceIsOk = False
mounts.append((d[0:2],
diskspace.MakeStringFromBytes(free),
diskspace.MakeStringFromBytes(total),
color,))
elif bpio.Linux() or bpio.Mac():
for mnt in bpio.listMountPointsLinux():
free, total = diskusage.GetLinuxDriveSpace(mnt)
if free is None or total is None:
continue
color = '#ffffff'
if bpio.getMountPointLinux(self.data['customersdir']) == mnt:
color = '#60e060'
if donatedV >= free:
color = '#e06060'
freeSpaceIsOk = False
if bpio.getMountPointLinux(self.data['localbackupsdir']) == mnt:
color = '#60e060'
if neededV >= free:
color = '#e06060'
freeSpaceIsOk = False
mounts.append((mnt,
diskspace.MakeStringFromBytes(free),
diskspace.MakeStringFromBytes(total),
color,))
ok = True
out = ''
if not freeSpaceIsOk:
out += '<font color=red>you do not have enough free space on the disk</font><br/>\n'
ok = False
if donatedV < settings.MinimumDonatedBytes():
out += '<font color=red>you must donate at least %f MB</font><br/>\n' % (
round(settings.MinimumDonatedBytes() / (1024.0 * 1024.0), 2))
ok = False
if not os.path.isdir(self.data['customersdir']):
out += '<font color=red>directory %s not exist</font><br/>\n' % self.data['customersdir']
ok = False
if not os.access(self.data['customersdir'], os.W_OK):
out += '<font color=red>folder %s does not have write permissions</font><br/>\n' % self.data['customersdir']
ok = False
if not os.path.isdir(self.data['localbackupsdir']):
out += '<font color=red>directory %s not exist</font><br/>\n' % self.data['localbackupsdir']
ok = False
if not os.access(self.data['localbackupsdir'], os.W_OK):
out += '<font color=red>folder %s does not have write permissions</font><br/>\n' % self.data['localbackupsdir']
ok = False
if int(self.data['suppliers']) not in settings.getECCSuppliersNumbers():
out += '<font color=red>incorrect number of suppliers, correct values are: %s</font><br/>\n' % (
str(settings.getECCSuppliersNumbers()).strip('[]'))
ok = False
context = {'output': out,
'mounts': mounts,
'needed': self.data['needed'],
'donated': self.data['donated'],
'localbackupsdir': self.data['localbackupsdir'],
'customersdir': self.data['customersdir'],
'restoredir': self.data['restoredir'],
'suppliers': self.data['suppliers'],
}
if request is None:
return template, context, request
action = request.REQUEST.get('action', None)
if action == 'next':
if ok:
install_wizard.A(action, self.data)
return None
if action == 'back':
install_wizard.A(action)
return None
return template, context, request
def main(executable_path=None):
"""
THIS IS THE ENTRY POINT OF THE PROGRAM!
"""
global AppDataDir
pars = parser()
(opts, args) = pars.parse_args()
overDict = override_options(opts, args)
cmd = ''
if len(args) > 0:
cmd = args[0].lower()
#---install---
if cmd in ['deploy', 'install', 'venv', 'virtualenv', ]:
from system import deploy
return deploy.run(args)
try:
from logs import lg
except:
dirpath = os.path.dirname(os.path.abspath(sys.argv[0]))
sys.path.insert(0, os.path.abspath(os.path.join(dirpath, '..')))
# sys.path.insert(0, os.path.abspath(os.path.join(dirpath, '..', '..')))
from distutils.sysconfig import get_python_lib
sys.path.append(os.path.join(get_python_lib(), 'bitdust'))
try:
from logs import lg
except:
print('ERROR! can not import working code. Python Path:')
print('\n'.join(sys.path))
return 1
# init IO module, update locale
from system import bpio
bpio.init()
# sys.excepthook = lg.exception_hook
if not bpio.isFrozen():
try:
from twisted.internet.defer import setDebugging
setDebugging(True)
# from twisted.python import log as twisted_log
# twisted_log.startLogging(sys.stdout)
except:
lg.warn('python-twisted is not installed')
if opts.appdir:
appdata = opts.appdir
AppDataDir = appdata
else:
curdir = os.getcwd() # os.path.dirname(os.path.abspath(sys.executable))
appdatafile = os.path.join(curdir, 'appdata')
defaultappdata = os.path.join(os.path.expanduser('~'), '.bitdust')
appdata = defaultappdata
if os.path.isfile(appdatafile):
try:
appdata = os.path.abspath(open(appdatafile, 'rb').read().strip())
except:
appdata = defaultappdata
if not os.path.isdir(appdata):
appdata = defaultappdata
AppDataDir = appdata
# ask to count time for each log line from that moment, not absolute time
lg.life_begins()
# try to read debug level value at the early stage - no problem if fail here
try:
if cmd == '' or cmd == 'start' or cmd == 'go' or cmd == 'show' or cmd == 'open':
lg.set_debug_level(int(
bpio.ReadTextFile(
os.path.abspath(
os.path.join(appdata, 'config', 'logs', 'debug-level')))))
except:
pass
if opts.no_logs:
lg.disable_logs()
#---logpath---
logpath = os.path.join(appdata, 'logs', 'start.log')
if opts.output:
logpath = opts.output
need_redirecting = False
if bpio.Windows() and not bpio.isConsoled():
need_redirecting = True
if logpath != '':
lg.open_log_file(logpath)
lg.out(2, 'bpmain.main log file opened ' + logpath)
if bpio.Windows() and bpio.isFrozen():
need_redirecting = True
if need_redirecting:
lg.stdout_start_redirecting()
lg.out(2, 'bpmain.main redirecting started')
# very basic solution to record run-time errors
try:
if os.path.isfile(os.path.join(appdata, 'logs', 'exception.log')):
os.remove(os.path.join(appdata, 'logs', 'exception.log'))
except:
pass
if opts.debug or str(opts.debug) == '0':
lg.set_debug_level(opts.debug)
# if opts.quite and not opts.verbose:
# lg.disable_output()
if opts.verbose:
copyright_text()
lg.out(2, 'bpmain.main started ' + time.asctime())
lg.out(2, 'bpmain.main args=%s' % str(args))
#---start---
if cmd == '' or cmd == 'start' or cmd == 'go':
appList = bpio.find_main_process(pid_file_path=os.path.join(appdata, 'metadata', 'processid'))
if appList:
lg.out(0, 'BitDust already started, found another process: %s\n' % str(appList))
bpio.shutdown()
return 0
UI = ''
# if cmd == 'show' or cmd == 'open':
# UI = 'show'
try:
ret = run(UI, opts, args, overDict, executable_path)
except:
lg.exc()
ret = 1
bpio.shutdown()
return ret
#---daemon---
elif cmd == 'detach' or cmd == 'daemon':
appList = bpio.find_main_process(pid_file_path=os.path.join(appdata, 'metadata', 'processid'))
if len(appList) > 0:
lg.out(0, 'main BitDust process already started: %s\n' % str(appList))
bpio.shutdown()
return 0
from lib import misc
lg.out(0, 'new BitDust process will be started in daemon mode, finishing current process\n')
bpio.shutdown()
result = misc.DoRestart(
detach=True,
std_out=os.path.join(appdata, 'logs', 'stdout.log'),
std_err=os.path.join(appdata, 'logs', 'stderr.log'),
)
if result is not None:
try:
result = int(result)
except:
try:
result = result.pid
except:
pass
return 0
#---restart---
elif cmd == 'restart' or cmd == 'reboot':
appList = bpio.find_main_process(pid_file_path=os.path.join(appdata, 'metadata', 'processid'))
ui = False
if len(appList) > 0:
lg.out(0, 'found main BitDust process: %s, sending "restart" command ... ' % str(appList), '')
def done(x):
lg.out(0, 'DONE\n', '')
from twisted.internet import reactor # @UnresolvedImport
if reactor.running and not reactor._stopped: # @UndefinedVariable
reactor.stop() # @UndefinedVariable
def failed(x):
ok = str(x).count('Connection was closed cleanly') > 0
from twisted.internet import reactor # @UnresolvedImport
if ok and reactor.running and not reactor._stopped: # @UndefinedVariable
lg.out(0, 'DONE\n', '')
reactor.stop() # @UndefinedVariable
return
lg.out(0, 'FAILED while killing previous process - do HARD restart\n', '')
try:
kill()
except:
lg.exc()
from lib import misc
reactor.addSystemEventTrigger( # @UndefinedVariable
'after',
'shutdown',
misc.DoRestart,
param='show' if ui else '',
detach=True,
std_out=os.path.join(appdata, 'logs', 'stdout.log'),
std_err=os.path.join(appdata, 'logs', 'stderr.log'),
)
reactor.stop() # @UndefinedVariable
try:
from twisted.internet import reactor # @UnresolvedImport
# from interface.command_line import run_url_command
# d = run_url_command('?action=restart', False)
# from interface import cmd_line
# d = cmd_line.call_xmlrpc_method('restart', ui)
from interface import cmd_line_json
d = cmd_line_json.call_jsonrpc_method('restart', ui)
d.addCallback(done)
d.addErrback(failed)
reactor.run() # @UndefinedVariable
bpio.shutdown()
return 0
except:
lg.exc()
bpio.shutdown()
return 1
else:
ui = ''
if cmd == 'restart':
ui = 'show'
try:
ret = run(ui, opts, args, overDict, executable_path)
except:
lg.exc()
ret = 1
bpio.shutdown()
return ret
#---show---
elif cmd == 'show' or cmd == 'open':
if not bpio.isGUIpossible():
lg.out(0, 'BitDust GUI is turned OFF\n')
bpio.shutdown()
return 0
if bpio.Linux() and not bpio.X11_is_running():
lg.out(0, 'this operating system not supported X11 interface\n')
bpio.shutdown()
return 0
appList = bpio.find_main_process(pid_file_path=os.path.join(appdata, 'metadata', 'processid'))
if len(appList) == 0:
try:
ret = run('show', opts, args, overDict, executable_path)
except:
lg.exc()
ret = 1
bpio.shutdown()
return ret
lg.out(0, 'found main BitDust process: %s, start the GUI\n' % str(appList))
ret = show()
bpio.shutdown()
return ret
#---stop---
elif cmd == 'stop' or cmd == 'kill' or cmd == 'shutdown':
appList = bpio.find_main_process(
pid_file_path=os.path.join(appdata, 'metadata', 'processid'),
)
if len(appList) > 0:
lg.out(0, 'found main BitDust process: %r, sending command "exit" ... ' % appList, '')
try:
from twisted.internet import reactor # @UnresolvedImport
# from interface.command_line import run_url_command
# url = '?action=exit'
# run_url_command(url, False).addBoth(wait_then_kill)
# reactor.run()
# bpio.shutdown()
def _stopped(x):
lg.out(0, 'BitDust process finished correctly\n')
reactor.stop() # @UndefinedVariable
bpio.shutdown()
# from interface import cmd_line
# cmd_line.call_xmlrpc_method('stop').addBoth(_stopped)
from interface import cmd_line_json
cmd_line_json.call_jsonrpc_method('stop').addBoth(_stopped)
reactor.run() # @UndefinedVariable
return 0
except:
lg.exc()
ret = kill()
bpio.shutdown()
return ret
else:
appListAllChilds = bpio.find_main_process(
check_processid_file=False,
extra_lookups=['regexp:^.*python.*bitdust.py.*?$', ],
)
if len(appListAllChilds) > 0:
lg.out(0, 'BitDust child processes found: %r, performing "kill process" actions ...\n' % appListAllChilds, '')
ret = kill()
return ret
lg.out(0, 'BitDust is not running at the moment\n')
bpio.shutdown()
return 0
#---command_line---
from interface import cmd_line_json as cmdln
ret = cmdln.run(opts, args, pars, overDict, executable_path)
if ret == 2:
print(usage_text())
bpio.shutdown()
return ret
def main(executable_path=None):
"""
THIS IS THE ENTRY POINT OF THE PROGRAM!
"""
global AppDataDir
import warnings
warnings.filterwarnings("ignore", message="You do not have a working installation of the service_identity module")
try:
from logs import lg
except:
dirpath = os.path.dirname(os.path.abspath(sys.argv[0]))
sys.path.insert(0, os.path.abspath(os.path.join(dirpath, '..')))
# sys.path.insert(0, os.path.abspath(os.path.join(dirpath, '..', '..')))
from distutils.sysconfig import get_python_lib
sys.path.append(os.path.join(get_python_lib(), 'bitdust'))
try:
from logs import lg
except:
print 'ERROR! can not import working code. Python Path:'
print '\n'.join(sys.path)
return 1
# init IO module, update locale
from system import bpio
bpio.init()
# sys.excepthook = lg.exception_hook
if not bpio.isFrozen():
try:
from twisted.internet.defer import setDebugging
setDebugging(True)
# from twisted.python import log as twisted_log
# twisted_log.startLogging(sys.stdout)
except:
lg.warn('python-twisted is not installed')
pars = parser()
(opts, args) = pars.parse_args()
if opts.appdir:
appdata = opts.appdir
AppDataDir = appdata
else:
curdir = os.getcwd() # os.path.dirname(os.path.abspath(sys.executable))
appdatafile = os.path.join(curdir, 'appdata')
defaultappdata = os.path.join(os.path.expanduser('~'), '.bitdust')
appdata = defaultappdata
if os.path.isfile(appdatafile):
try:
appdata = os.path.abspath(open(appdatafile, 'rb').read().strip())
except:
appdata = defaultappdata
if not os.path.isdir(appdata):
appdata = defaultappdata
AppDataDir = appdata
cmd = ''
if len(args) > 0:
cmd = args[0].lower()
# ask to count time for each log line from that moment, not absolute time
lg.life_begins()
# try to read debug level value at the early stage - no problem if fail here
try:
if cmd == '' or cmd == 'start' or cmd == 'go' or cmd == 'show' or cmd == 'open':
lg.set_debug_level(int(
bpio._read_data(
os.path.abspath(
os.path.join(appdata, 'config', 'logs', 'debug-level')))))
except:
pass
if opts.no_logs:
lg.disable_logs()
#---logpath---
logpath = os.path.join(appdata, 'logs', 'start.log')
if opts.output:
logpath = opts.output
need_redirecting = False
if bpio.Windows() and not bpio.isConsoled():
need_redirecting = True
if logpath != '':
lg.open_log_file(logpath)
lg.out(2, 'bpmain.main log file opened ' + logpath)
if bpio.Windows() and bpio.isFrozen():
need_redirecting = True
if need_redirecting:
lg.stdout_start_redirecting()
lg.out(2, 'bpmain.main redirecting started')
# TODO: temporary solution to record run-time errors
try:
if os.path.isfile(os.path.join(appdata, 'logs', 'exception.log')):
os.remove(os.path.join(appdata, 'logs', 'exception.log'))
except:
pass
if opts.debug or str(opts.debug) == '0':
lg.set_debug_level(opts.debug)
# if opts.quite and not opts.verbose:
# lg.disable_output()
if opts.verbose:
copyright_text()
lg.out(2, 'bpmain.main started ' + time.asctime())
overDict = override_options(opts, args)
lg.out(2, 'bpmain.main args=%s' % str(args))
#---start---
if cmd == '' or cmd == 'start' or cmd == 'go':
appList = bpio.find_main_process(pid_file_path=os.path.join(appdata, 'metadata', 'processid'))
if appList:
lg.out(0, 'BitDust already started, found another process: %s\n' % str(appList))
bpio.shutdown()
return 0
UI = ''
# if cmd == 'show' or cmd == 'open':
# UI = 'show'
try:
ret = run(UI, opts, args, overDict, executable_path)
except:
lg.exc()
ret = 1
bpio.shutdown()
return ret
#---daemon---
elif cmd == 'detach' or cmd == 'daemon' or cmd == 'background':
appList = bpio.find_main_process(pid_file_path=os.path.join(appdata, 'metadata', 'processid'))
if len(appList) > 0:
lg.out(0, 'main BitDust process already started: %s\n' % str(appList))
bpio.shutdown()
return 0
from lib import misc
lg.out(0, 'new BitDust process will be started in daemon mode, finishing current process\n')
bpio.shutdown()
result = misc.DoRestart(detach=True)
if result is not None:
try:
result = int(result)
except:
try:
result = result.pid
except:
pass
return 0
#---restart---
elif cmd == 'restart' or cmd == 'reboot':
appList = bpio.find_main_process(pid_file_path=os.path.join(appdata, 'metadata', 'processid'))
ui = False
if len(appList) > 0:
lg.out(0, 'found main BitDust process: %s, sending "restart" command ... ' % str(appList), '')
def done(x):
lg.out(0, 'DONE\n', '')
from twisted.internet import reactor
if reactor.running and not reactor._stopped:
reactor.stop()
def failed(x):
ok = str(x).count('Connection was closed cleanly') > 0
from twisted.internet import reactor
if ok and reactor.running and not reactor._stopped:
lg.out(0, 'DONE\n', '')
reactor.stop()
return
lg.out(0, 'FAILED while killing previous process - do HARD restart\n', '')
try:
kill()
except:
lg.exc()
from lib import misc
reactor.addSystemEventTrigger('after', 'shutdown', misc.DoRestart, param='show' if ui else '', detach=True)
reactor.stop()
try:
from twisted.internet import reactor
# from interface.command_line import run_url_command
# d = run_url_command('?action=restart', False)
# from interface import cmd_line
# d = cmd_line.call_xmlrpc_method('restart', ui)
from interface import cmd_line_json
d = cmd_line_json.call_jsonrpc_method('restart', ui)
d.addCallback(done)
d.addErrback(failed)
reactor.run()
bpio.shutdown()
return 0
except:
lg.exc()
bpio.shutdown()
return 1
else:
ui = ''
if cmd == 'restart':
ui = 'show'
try:
ret = run(ui, opts, args, overDict, executable_path)
except:
lg.exc()
ret = 1
bpio.shutdown()
return ret
#---show---
elif cmd == 'show' or cmd == 'open':
from main import settings
if not bpio.isGUIpossible() and not settings.NewWebGUI():
lg.out(0, 'BitDust GUI is turned OFF\n')
bpio.shutdown()
return 0
if bpio.Linux() and not bpio.X11_is_running():
lg.out(0, 'this operating system not supported X11 interface\n')
bpio.shutdown()
return 0
appList = bpio.find_main_process(pid_file_path=os.path.join(appdata, 'metadata', 'processid'))
if len(appList) == 0:
try:
ret = run('show', opts, args, overDict, executable_path)
except:
lg.exc()
ret = 1
bpio.shutdown()
return ret
lg.out(0, 'found main BitDust process: %s, start the GUI\n' % str(appList))
ret = show()
bpio.shutdown()
return ret
#---stop---
elif cmd == 'stop' or cmd == 'kill' or cmd == 'shutdown':
appList = bpio.find_main_process(pid_file_path=os.path.join(appdata, 'metadata', 'processid'))
if len(appList) > 0:
lg.out(0, 'found main BitDust process: %s, sending command "exit" ... ' % str(appList), '')
try:
from twisted.internet import reactor
# from interface.command_line import run_url_command
# url = '?action=exit'
# run_url_command(url, False).addBoth(wait_then_kill)
# reactor.run()
# bpio.shutdown()
def _stopped(x):
lg.out(0, 'BitDust process finished correctly\n')
reactor.stop()
bpio.shutdown()
# from interface import cmd_line
# cmd_line.call_xmlrpc_method('stop').addBoth(_stopped)
from interface import cmd_line_json
cmd_line_json.call_jsonrpc_method('stop').addBoth(_stopped)
reactor.run()
return 0
except:
lg.exc()
ret = kill()
bpio.shutdown()
return ret
else:
lg.out(0, 'BitDust is not running at the moment\n')
bpio.shutdown()
return 0
#---uninstall---
elif cmd == 'uninstall':
def do_spawn(x=None):
from main.settings import WindowsStarterFileName
starter_filepath = os.path.join(bpio.getExecutableDir(), WindowsStarterFileName())
lg.out(0, "bpmain.main bitstarter.exe path: %s " % starter_filepath)
if not os.path.isfile(starter_filepath):
lg.out(0, "ERROR: %s not found\n" % starter_filepath)
bpio.shutdown()
return 1
cmdargs = [os.path.basename(starter_filepath), 'uninstall']
lg.out(0, "bpmain.main os.spawnve cmdargs=" + str(cmdargs))
ret = os.spawnve(os.P_DETACH, starter_filepath, cmdargs, os.environ)
bpio.shutdown()
return ret
def do_reactor_stop_and_spawn(x=None):
lg.out(0, 'BitDust process finished correctly\n')
reactor.stop()
ret = do_spawn()
bpio.shutdown()
return ret
lg.out(0, 'bpmain.main UNINSTALL!')
if not bpio.Windows():
lg.out(0, 'This command can be used only under OS Windows.\n')
bpio.shutdown()
return 0
if not bpio.isFrozen():
lg.out(0, 'You are running BitDust from sources, uninstall command is available only for installable version.\n')
bpio.shutdown()
return 0
appList = bpio.find_process(['bitdust.exe', ])
if len(appList) > 0:
lg.out(0, 'found main BitDust process... ', '')
try:
# from twisted.internet import reactor
# from interface.command_line import run_url_command
# url = '?action=exit'
# run_url_command(url).addBoth(do_reactor_stop_and_spawn)
# reactor.run()
# bpio.shutdown()
# from interface import cmd_line
# cmd_line.call_xmlrpc_method('stop').addBoth(do_reactor_stop_and_spawn)
from interface import cmd_line_json
cmd_line_json.call_jsonrpc_method('stop').addBoth(do_reactor_stop_and_spawn)
reactor.run()
return 0
except:
lg.exc()
ret = do_spawn()
bpio.shutdown()
return ret
#---command_line---
# from interface import command_line as cmdln
# from interface import cmd_line as cmdln
from interface import cmd_line_json as cmdln
ret = cmdln.run(opts, args, pars, overDict, executable_path)
if ret == 2:
print usage_text()
bpio.shutdown()
return ret
