meta-tech/kirmah
meta-tech/kirmah
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

refactoring and manage multiproc interruption

Browse Source
This commit is contained in:
a-Sansara 2013-05-07 02:43:02 +02:00
parent 0dea1e7db0
commit 0d67d7bbcb
10 changed files with 438 additions and 296 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

201
kirmah/cli.py
View File

@ -31,91 +31,33 @@
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# ~~ module cli ~~ # ~~ module cli ~~
from optparse import OptionParser, OptionGroup from optparse import OptionGroup
import kirmah.conf as conf
from kirmah.cliapp import CliApp
from psr.sys import Sys, Io, Const, init from psr.sys import Sys, Io, Const, init
from psr.log import Log from psr.log import Log
from psr.cli import AbstractCli
if not Sys.isUnix : Const.LINE_SEP_CHAR = '-' from kirmah.cliapp import CliApp
import kirmah.conf as conf
def printLineSep(sep,lenSep):
""""""
s = sep*lenSep
Sys.print(s, Sys.CLZ_HEAD_LINE)
return [(s, Const.CLZ_HEAD_SEP)]
def printHeaderTitle(title):
""""""
s = ' == '+title+' == '
Sys.print(s, Sys.CLZ_HEAD_APP, False, True)
return [(s, Const.CLZ_HEAD_APP)]
def printHeaderPart(label,value):
""""""
a, b, c = ' [',':' ,'] '
Sys.print(a , Sys.CLZ_HEAD_SEP, False)
Sys.print(label, Sys.CLZ_HEAD_KEY, False)
Sys.print(b , Sys.CLZ_HEAD_SEP, False)
Sys.print(value, Sys.CLZ_HEAD_VAL, False)
Sys.print(c , Sys.CLZ_HEAD_SEP, False)
return [(a,Const.CLZ_HEAD_SEP),(label,Const.CLZ_HEAD_KEY),(b,Const.CLZ_HEAD_SEP),(value,Const.CLZ_HEAD_VAL),(c,Const.CLZ_HEAD_SEP)]
class _OptionParser(OptionParser):
"""A simplified OptionParser"""
def format_description(self, formatter):
return self.description
def format_epilog(self, formatter):
return self.epilog
def error(self, errMsg, errData=None):
self.print_usage('')
Cli.error_cmd(self, (errMsg,))
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# ~~ class Cli ~~ # ~~ class Cli ~~
class Cli: class Cli(AbstractCli):
def __init__(self, path, remote=False, rwargs=None, thread=None, loglvl=Const.LOG_DEFAULT): def __init__(self, path, remote=False, rwargs=None, thread=None, loglvl=Const.LOG_DEFAULT):
"""""" """"""
if thread is not None : AbstractCli.__init__(self, conf)
Sys.g.THREAD_CLI = thread
Sys.g.GUI = True
else :
Sys.g.GUI = False
self.HOME = conf.DEFVAL_USER_PATH Cli.HOME = conf.DEFVAL_USER_PATH
self.DIRKEY = self.HOME+'.'+conf.PRG_NAME.lower()+Sys.sep Cli.DIRKEY = Cli.HOME+'.'+conf.PRG_NAME.lower()+Sys.sep
if not Sys.isUnix() : if not Sys.isUnix() :
CHQ = '"' CHQ = '"'
self.HOME = 'C:'+Sys.sep+conf.PRG_NAME.lower()+Sys.sep self.HOME = 'C:'+Sys.sep+conf.PRG_NAME.lower()+Sys.sep
self.DIRKEY = self.HOME+'keys'+Sys.sep self.DIRKEY = self.HOME+'keys'+Sys.sep
Sys.mkdir_p(self.DIRKEY) Sys.mkdir_p(Cli.DIRKEY)
parser = _OptionParser()
parser.print_help = self.print_help
parser.print_usage = self.print_usage
gpData = OptionGroup(parser, '')
parser.add_option('-v', '--version' , action='store_true', default=False)
parser.add_option('-d', '--debug' , action='store_true', default=False)
parser.add_option('-f', '--force' , action='store_true', default=False)
parser.add_option('-q', '--quiet' , action='store_true', default=False)
parser.add_option('--no-color' , action='store_true' , default=False)
gpData = OptionGroup(self.parser, '')
gpData.add_option('-a', '--fullcompress' , action='store_true' ) gpData.add_option('-a', '--fullcompress' , action='store_true' )
gpData.add_option('-z', '--compress' , action='store_true' ) gpData.add_option('-z', '--compress' , action='store_true' )
gpData.add_option('-Z', '--nocompress' , action='store_true' ) gpData.add_option('-Z', '--nocompress' , action='store_true' )
@ -128,35 +70,38 @@ class Cli:
gpData.add_option('-l', '--length' , action='store', default=1024) gpData.add_option('-l', '--length' , action='store', default=1024)
gpData.add_option('-p', '--parts' , action='store', default=22) gpData.add_option('-p', '--parts' , action='store', default=22)
gpData.add_option('-o', '--outputfile' , action='store') gpData.add_option('-o', '--outputfile' , action='store')
parser.add_option_group(gpData) self.parser.add_option_group(gpData)
# rewrite argv sended by remote # rewrite argv sended by remote
if rwargs is not None : if rwargs is not None :
import sys import sys
sys.argv = rwargs sys.argv = rwargs
(o, a) = parser.parse_args() (o, a) = self.parser.parse_args()
Sys.g.QUIET = o.quiet Sys.g.QUIET = o.quiet
Sys.g.THREAD_CLI = thread
Sys.g.GUI = thread is not None
init(conf.PRG_NAME, o.debug, remote, not o.no_color, loglvl) init(conf.PRG_NAME, o.debug, remote, not o.no_color, loglvl)
if not a: if not a:
try : try :
if not o.help : if not o.help :
self.error_cmd(('no command specified',)) Cli.error_cmd(('no command specified',))
else : else :
Sys.clear() Sys.clear()
parser.print_help() Cli.print_help()
except : except :
self.error_cmd(('no command specified',)) Cli.error_cmd(('no command specified',))
else: else:
if a[0] == 'help': if a[0] == 'help':
Sys.clear() Sys.clear()
parser.print_help() Cli.print_help()
elif a[0] in ['key','enc','dec','split','merge'] : elif a[0] in ['key','enc','dec','split','merge'] :
@ -166,9 +111,9 @@ class Cli:
app.onCommandKey() app.onCommandKey()
else : else :
if not len(a)>1 : if not len(a)>1 :
self.error_cmd((('an ',('inputFile',Sys.Clz.fgb3),' is required !'),)) Cli.error_cmd((('an ',('inputFile',Sys.Clz.fgb3),' is required !'),))
elif not Io.file_exists(a[1]): elif not Io.file_exists(a[1]):
self.error_cmd((('the file ',(a[1], Sys.Clz.fgb3), ' doesn\'t exists !'),)) Cli.error_cmd((('the file ',(a[1], Sys.Clz.fgb3), ' doesn\'t exists !'),))
elif a[0]=='enc' : app.onCommandEnc() elif a[0]=='enc' : app.onCommandEnc()
elif a[0]=='dec' : app.onCommandDec() elif a[0]=='dec' : app.onCommandDec()
@ -180,59 +125,21 @@ class Cli:
Sys.g.LOG_QUEUE.put(Sys.g.SIGNAL_STOP) Sys.g.LOG_QUEUE.put(Sys.g.SIGNAL_STOP)
else : else :
self.error_cmd((('unknow command ',(a[0],Sys.Clz.fgb3)),)) Cli.error_cmd((('unknow command ',(a[0],Sys.Clz.fgb3)),))
if not o.quiet : Sys.dprint() if not o.quiet : Sys.dprint()
def clean(self): @staticmethod
def print_usage(data, withoutHeader=False):
"""""" """"""
print('cleaning') if not withoutHeader : Cli.print_header()
def error_cmd(self, data):
""""""
self.print_usage('')
Sys.dprint()
Sys.pwarn(data, True)
self.exit(1)
def exit(self, code):
""""""
if Sys.isUnix() : Sys.exit(code)
def print_header(self):
""""""
a = printLineSep(Const.LINE_SEP_CHAR,Const.LINE_SEP_LEN)
b = printHeaderTitle(conf.PRG_CLI_NAME)
c = printHeaderPart('version' ,conf.PRG_VERS)
d = printHeaderPart('author' ,conf.PRG_AUTHOR)
e = printHeaderPart('license' ,conf.PRG_LICENSE)
f = printHeaderPart('copyright',conf.PRG_COPY)
Sys.print(' ', Sys.Clz.OFF)
printLineSep(Const.LINE_SEP_CHAR,Const.LINE_SEP_LEN)
Sys.wlog(a)
Sys.wlog(b + c + d + e + f )
Sys.wlog(a)
Sys.wlog(Sys.dprint())
def print_version(self, data):
""""""
self.print_header()
def print_usage(self, data, withoutHeader=False):
""""""
if not withoutHeader : self.print_header()
Sys.print(' USAGE :\n' , Sys.CLZ_HELP_CMD) Sys.print(' USAGE :\n' , Sys.CLZ_HELP_CMD)
Sys.print(' '+conf.PRG_CLI_NAME+' ' , Sys.CLZ_HELP_PRG, False) Sys.print(' '+Cli.conf.PRG_CLI_NAME+' ' , Sys.CLZ_HELP_PRG, False)
Sys.print('help ' , Sys.CLZ_HELP_CMD) Sys.print('help ' , Sys.CLZ_HELP_CMD)
Sys.print(' '+conf.PRG_CLI_NAME+' ' , Sys.CLZ_HELP_PRG, False) Sys.print(' '+Cli.conf.PRG_CLI_NAME+' ' , Sys.CLZ_HELP_PRG, False)
Sys.print('key ' , Sys.CLZ_HELP_CMD, False) Sys.print('key ' , Sys.CLZ_HELP_CMD, False)
Sys.print('[ -l ' , Sys.CLZ_HELP_ARG, False) Sys.print('[ -l ' , Sys.CLZ_HELP_ARG, False)
Sys.print('{' , Sys.CLZ_HELP_PARAM, False) Sys.print('{' , Sys.CLZ_HELP_PARAM, False)
@ -244,7 +151,7 @@ class Cli:
Sys.print('}' , Sys.CLZ_HELP_PARAM, False) Sys.print('}' , Sys.CLZ_HELP_PARAM, False)
Sys.print(']' , Sys.CLZ_HELP_ARG) Sys.print(']' , Sys.CLZ_HELP_ARG)
Sys.print(' '+conf.PRG_CLI_NAME+' ' , Sys.CLZ_HELP_PRG, False) Sys.print(' '+Cli.conf.PRG_CLI_NAME+' ' , Sys.CLZ_HELP_PRG, False)
Sys.print('enc ' , Sys.CLZ_HELP_CMD, False) Sys.print('enc ' , Sys.CLZ_HELP_CMD, False)
Sys.print('{' , Sys.CLZ_HELP_PARAM, False) Sys.print('{' , Sys.CLZ_HELP_PARAM, False)
Sys.print('inputFile' , Sys.CLZ_HELP_PARAM, False) Sys.print('inputFile' , Sys.CLZ_HELP_PARAM, False)
@ -321,10 +228,11 @@ class Cli:
Sys.print(']' , Sys.CLZ_HELP_ARG) Sys.print(']' , Sys.CLZ_HELP_ARG)
def print_options(self): @staticmethod
def print_options():
"""""" """"""
Sys.dprint('\n') Sys.dprint('\n')
printLineSep(Const.LINE_SEP_CHAR,Const.LINE_SEP_LEN) Cli.printLineSep(Const.LINE_SEP_CHAR,Const.LINE_SEP_LEN)
Sys.print(' MAIN OPTIONS :\n' , Sys.CLZ_HELP_CMD) Sys.print(' MAIN OPTIONS :\n' , Sys.CLZ_HELP_CMD)
Sys.print(' '*4+'-v'.ljust(13,' ')+', --version' , Sys.CLZ_HELP_ARG) Sys.print(' '*4+'-v'.ljust(13,' ')+', --version' , Sys.CLZ_HELP_ARG)
@ -435,13 +343,14 @@ class Cli:
Sys.dprint('\n') Sys.dprint('\n')
def print_help(self): @staticmethod
def print_help():
"""""" """"""
self.print_header() Cli.print_header()
Sys.print(conf.PRG_DESC, Sys.CLZ_HELP_DESC) Sys.print(Cli.conf.PRG_DESC, Sys.CLZ_HELP_DESC)
self.print_usage('',True) Cli.print_usage('',True)
self.print_options() Cli.print_options()
printLineSep(Const.LINE_SEP_CHAR,Const.LINE_SEP_LEN) Cli.printLineSep(Const.LINE_SEP_CHAR,Const.LINE_SEP_LEN)
Sys.dprint() Sys.dprint()
Sys.print(' EXEMPLES :\n', Sys.CLZ_HELP_CMD) Sys.print(' EXEMPLES :\n', Sys.CLZ_HELP_CMD)
CHQ = "'" CHQ = "'"
@ -456,16 +365,16 @@ class Cli:
Sys.print(' '*8+'# generate a new crypted key (default length is 1024) in a specified location', Sys.CLZ_HELP_COMMENT) Sys.print(' '*8+'# generate a new crypted key (default length is 1024) in a specified location', Sys.CLZ_HELP_COMMENT)
Sys.print(' '*8+conf.PRG_CLI_NAME+' ', Sys.CLZ_HELP_PRG, False) Sys.print(' '*8+conf.PRG_CLI_NAME+' ', Sys.CLZ_HELP_PRG, False)
Sys.print('key -o ', Sys.CLZ_HELP_CMD, False) Sys.print('key -o ', Sys.CLZ_HELP_CMD, False)
Sys.print(self.DIRKEY+'.myNewKey', Sys.CLZ_HELP_PARAM) Sys.print(Cli.DIRKEY+'.myNewKey', Sys.CLZ_HELP_PARAM)
printLineSep(Const.LINE_SEP_CHAR,Const.LINE_SEP_LEN) Cli.printLineSep(Const.LINE_SEP_CHAR,Const.LINE_SEP_LEN)
Sys.print('\n'+' '*4+'command encrypt :', Sys.CLZ_HELP_CMD) Sys.print('\n'+' '*4+'command encrypt :', Sys.CLZ_HELP_CMD)
Sys.print(' '*8+'# encrypt specified file with default crypted key and default options', Sys.CLZ_HELP_COMMENT) Sys.print(' '*8+'# encrypt specified file with default crypted key and default options', Sys.CLZ_HELP_COMMENT)
Sys.print(' '*8+conf.PRG_CLI_NAME+' ', Sys.CLZ_HELP_PRG, False) Sys.print(' '*8+conf.PRG_CLI_NAME+' ', Sys.CLZ_HELP_PRG, False)
Sys.print('enc ', Sys.CLZ_HELP_CMD, False) Sys.print('enc ', Sys.CLZ_HELP_CMD, False)
Sys.print(self.HOME+'mySecretTextFile.txt', Sys.CLZ_HELP_PARAM) Sys.print(Cli.HOME+'mySecretTextFile.txt', Sys.CLZ_HELP_PARAM)
Sys.print(' '*8+'# encrypt specified file with specified crypted key (full compression, no random but mix mode)', Sys.CLZ_HELP_COMMENT) Sys.print(' '*8+'# encrypt specified file with specified crypted key (full compression, no random but mix mode)', Sys.CLZ_HELP_COMMENT)
Sys.print(' '*8+'# on specified output location', Sys.CLZ_HELP_COMMENT) Sys.print(' '*8+'# on specified output location', Sys.CLZ_HELP_COMMENT)
@ -473,7 +382,7 @@ class Cli:
Sys.print('enc ', Sys.CLZ_HELP_CMD, False) Sys.print('enc ', Sys.CLZ_HELP_CMD, False)
Sys.print('mySecretTextFile.txt', Sys.CLZ_HELP_PARAM, False) Sys.print('mySecretTextFile.txt', Sys.CLZ_HELP_PARAM, False)
Sys.print(' -aRm -k ' , Sys.CLZ_HELP_ARG, False) Sys.print(' -aRm -k ' , Sys.CLZ_HELP_ARG, False)
Sys.print(self.DIRKEY+'.myNewKey', Sys.CLZ_HELP_PARAM, False) Sys.print(Cli.DIRKEY+'.myNewKey', Sys.CLZ_HELP_PARAM, False)
Sys.print(' -o ' , Sys.CLZ_HELP_ARG, False) Sys.print(' -o ' , Sys.CLZ_HELP_ARG, False)
Sys.print('test.kmh', Sys.CLZ_HELP_PARAM) Sys.print('test.kmh', Sys.CLZ_HELP_PARAM)
@ -485,20 +394,20 @@ class Cli:
Sys.print('4', Sys.CLZ_HELP_PARAM) Sys.print('4', Sys.CLZ_HELP_PARAM)
printLineSep(Const.LINE_SEP_CHAR,Const.LINE_SEP_LEN) Cli.printLineSep(Const.LINE_SEP_CHAR,Const.LINE_SEP_LEN)
Sys.print('\n'+' '*4+'command decrypt :', Sys.CLZ_HELP_CMD) Sys.print('\n'+' '*4+'command decrypt :', Sys.CLZ_HELP_CMD)
Sys.print(' '*8+'# decrypt specified file with default crypted key', Sys.CLZ_HELP_COMMENT) Sys.print(' '*8+'# decrypt specified file with default crypted key', Sys.CLZ_HELP_COMMENT)
Sys.print(' '*8+conf.PRG_CLI_NAME+' ', Sys.CLZ_HELP_PRG, False) Sys.print(' '*8+conf.PRG_CLI_NAME+' ', Sys.CLZ_HELP_PRG, False)
Sys.print('dec ', Sys.CLZ_HELP_CMD, False) Sys.print('dec ', Sys.CLZ_HELP_CMD, False)
Sys.print(self.HOME+'mySecretFile.kmh', Sys.CLZ_HELP_PARAM) Sys.print(Cli.HOME+'mySecretFile.kmh', Sys.CLZ_HELP_PARAM)
Sys.print(' '*8+'# decrypt specified file with specified crypted key on specified output location', Sys.CLZ_HELP_COMMENT) Sys.print(' '*8+'# decrypt specified file with specified crypted key on specified output location', Sys.CLZ_HELP_COMMENT)
Sys.print(' '*8+conf.PRG_CLI_NAME+' ', Sys.CLZ_HELP_PRG, False) Sys.print(' '*8+Cli.conf.PRG_CLI_NAME+' ', Sys.CLZ_HELP_PRG, False)
Sys.print('dec ', Sys.CLZ_HELP_CMD, False) Sys.print('dec ', Sys.CLZ_HELP_CMD, False)
Sys.print('myEncryptedSecretFile.kmh', Sys.CLZ_HELP_PARAM, False) Sys.print('myEncryptedSecretFile.kmh', Sys.CLZ_HELP_PARAM, False)
Sys.print(' -k ' , Sys.CLZ_HELP_ARG, False) Sys.print(' -k ' , Sys.CLZ_HELP_ARG, False)
Sys.print(self.HOME+'.kirmah'+Sys.sep+'.myNewKey', Sys.CLZ_HELP_PARAM, False) Sys.print(Cli.HOME+'.kirmah'+Sys.sep+'.myNewKey', Sys.CLZ_HELP_PARAM, False)
Sys.print(' -o ' , Sys.CLZ_HELP_ARG, False) Sys.print(' -o ' , Sys.CLZ_HELP_ARG, False)
Sys.print('myDecryptedSecretFile.txt', Sys.CLZ_HELP_PARAM) Sys.print('myDecryptedSecretFile.txt', Sys.CLZ_HELP_PARAM)
@ -510,13 +419,13 @@ class Cli:
Sys.print('4' , Sys.CLZ_HELP_PARAM) Sys.print('4' , Sys.CLZ_HELP_PARAM)
printLineSep(Const.LINE_SEP_CHAR,Const.LINE_SEP_LEN) Cli.printLineSep(Const.LINE_SEP_CHAR,Const.LINE_SEP_LEN)
Sys.print('\n'+' '*4+'command split :', Sys.CLZ_HELP_CMD) Sys.print('\n'+' '*4+'command split :', Sys.CLZ_HELP_CMD)
Sys.print(' '*8+'# split specified file with default crypted key', Sys.CLZ_HELP_COMMENT) Sys.print(' '*8+'# split specified file with default crypted key', Sys.CLZ_HELP_COMMENT)
Sys.print(' '*8+conf.PRG_CLI_NAME+' ', Sys.CLZ_HELP_PRG, False) Sys.print(' '*8+conf.PRG_CLI_NAME+' ', Sys.CLZ_HELP_PRG, False)
Sys.print('split ', Sys.CLZ_HELP_CMD, False) Sys.print('split ', Sys.CLZ_HELP_CMD, False)
Sys.print(self.HOME+'myBigBinaryFile.avi', Sys.CLZ_HELP_PARAM) Sys.print(Cli.HOME+'myBigBinaryFile.avi', Sys.CLZ_HELP_PARAM)
Sys.print(' '*8+'# split specified file on 55 parts with specified crypted key on specified output location', Sys.CLZ_HELP_COMMENT) Sys.print(' '*8+'# split specified file on 55 parts with specified crypted key on specified output location', Sys.CLZ_HELP_COMMENT)
Sys.print(' '*8+conf.PRG_CLI_NAME+' ', Sys.CLZ_HELP_PRG, False) Sys.print(' '*8+conf.PRG_CLI_NAME+' ', Sys.CLZ_HELP_PRG, False)
@ -525,27 +434,27 @@ class Cli:
Sys.print(' -p ' , Sys.CLZ_HELP_ARG, False) Sys.print(' -p ' , Sys.CLZ_HELP_ARG, False)
Sys.print('55' , Sys.CLZ_HELP_PARAM, False) Sys.print('55' , Sys.CLZ_HELP_PARAM, False)
Sys.print(' -k ' , Sys.CLZ_HELP_ARG, False) Sys.print(' -k ' , Sys.CLZ_HELP_ARG, False)
Sys.print(self.DIRKEY+'.myNewKey', Sys.CLZ_HELP_PARAM, False) Sys.print(Cli.DIRKEY+'.myNewKey', Sys.CLZ_HELP_PARAM, False)
Sys.print(' -o ' , Sys.CLZ_HELP_ARG, False) Sys.print(' -o ' , Sys.CLZ_HELP_ARG, False)
Sys.print('myBigBinaryFile.encrypted', Sys.CLZ_HELP_PARAM) Sys.print('myBigBinaryFile.encrypted', Sys.CLZ_HELP_PARAM)
printLineSep(Const.LINE_SEP_CHAR,Const.LINE_SEP_LEN) Cli.printLineSep(Const.LINE_SEP_CHAR,Const.LINE_SEP_LEN)
Sys.print('\n'+' '*4+'command merge :', Sys.CLZ_HELP_CMD) Sys.print('\n'+' '*4+'command merge :', Sys.CLZ_HELP_CMD)
Sys.print(' '*8+'# merge specified splitted file with default crypted key', Sys.CLZ_HELP_COMMENT) Sys.print(' '*8+'# merge specified splitted file with default crypted key', Sys.CLZ_HELP_COMMENT)
Sys.print(' '*8+conf.PRG_CLI_NAME+' ', Sys.CLZ_HELP_PRG, False) Sys.print(' '*8+conf.PRG_CLI_NAME+' ', Sys.CLZ_HELP_PRG, False)
Sys.print('merge ', Sys.CLZ_HELP_CMD, False) Sys.print('merge ', Sys.CLZ_HELP_CMD, False)
Sys.print(self.HOME+'6136bd1b53d84ecbad5380594eea7256176c19e0266c723ea2e982f8ca49922b.kcf', Sys.CLZ_HELP_PARAM) Sys.print(Cli.HOME+'6136bd1b53d84ecbad5380594eea7256176c19e0266c723ea2e982f8ca49922b.kcf', Sys.CLZ_HELP_PARAM)
Sys.print(' '*8+'# merge specified tark splitted file with specified crypted key on specified output location', Sys.CLZ_HELP_COMMENT) Sys.print(' '*8+'# merge specified tark splitted file with specified crypted key on specified output location', Sys.CLZ_HELP_COMMENT)
Sys.print(' '*8+conf.PRG_CLI_NAME+' ', Sys.CLZ_HELP_PRG, False) Sys.print(' '*8+conf.PRG_CLI_NAME+' ', Sys.CLZ_HELP_PRG, False)
Sys.print('merge ', Sys.CLZ_HELP_CMD, False) Sys.print('merge ', Sys.CLZ_HELP_CMD, False)
Sys.print('myBigBinaryFile.encrypted.tark', Sys.CLZ_HELP_PARAM, False) Sys.print('myBigBinaryFile.encrypted.tark', Sys.CLZ_HELP_PARAM, False)
Sys.print(' -k ' , Sys.CLZ_HELP_ARG, False) Sys.print(' -k ' , Sys.CLZ_HELP_ARG, False)
Sys.print(self.DIRKEY+'.myNewKey', Sys.CLZ_HELP_PARAM, False) Sys.print(Cli.DIRKEY+'.myNewKey', Sys.CLZ_HELP_PARAM, False)
Sys.print(' -o ' , Sys.CLZ_HELP_ARG, False) Sys.print(' -o ' , Sys.CLZ_HELP_ARG, False)
Sys.print('myBigBinaryFile.decrypted.avi', Sys.CLZ_HELP_PARAM) Sys.print('myBigBinaryFile.decrypted.avi', Sys.CLZ_HELP_PARAM)
printLineSep(Const.LINE_SEP_CHAR,Const.LINE_SEP_LEN) Cli.printLineSep(Const.LINE_SEP_CHAR,Const.LINE_SEP_LEN)
Sys.dprint() Sys.dprint()

29
kirmah/cliapp.py
View File

@ -121,10 +121,11 @@ class CliApp:
except Exception as e : except Exception as e :
done = False done = False
print(e) print(e)
raise e
pass pass
if not Sys.g.QUIET : if not Sys.g.QUIET :
self.onend_cmd('Encrypting file', self.stime, done, self.o.outputfile) self.onend_cmd('Kirmah Encrypt', self.stime, done, self.o.outputfile)
@Log(Const.LOG_DEBUG) @Log(Const.LOG_DEBUG)
@ -164,7 +165,7 @@ class CliApp:
raise e raise e
if not Sys.g.QUIET : if not Sys.g.QUIET :
self.onend_cmd('Decrypting file', self.stime, done, self.o.outputfile) self.onend_cmd('Kirmah Decrypt', self.stime, done, self.o.outputfile)
@Log(Const.LOG_DEBUG) @Log(Const.LOG_DEBUG)
@ -173,7 +174,7 @@ class CliApp:
done = True done = True
Sys.cli_emit_progress(1) Sys.cli_emit_progress(1)
if not self.o.parts is None and not(int(self.o.parts)>=12 and int(self.o.parts) <=62) : if not self.o.parts is None and not(int(self.o.parts)>=12 and int(self.o.parts) <=62) :
self.error_cmd((('invalid option ',('-p, --parts', Sys.Clz.fgb3), ' value (', ('12',Sys.Clz.fgb3),' to ', ('62',Sys.Clz.fgb3),')'),)) self.parser.error_cmd((('invalid option ',('-p, --parts', Sys.Clz.fgb3), ' value (', ('12',Sys.Clz.fgb3),' to ', ('62',Sys.Clz.fgb3),')'),))
else : self.o.parts = int(self.o.parts) else : self.o.parts = int(self.o.parts)
if not Sys.g.QUIET : self.parser.print_header() if not Sys.g.QUIET : self.parser.print_header()
@ -199,30 +200,30 @@ class CliApp:
p = 85 p = 85
Sys.cli_emit_progress(p) Sys.cli_emit_progress(p)
Io.touch(kcf, times) Io.touch(kcf, times)
frav = 0.24 frav = 0.24
for row in hlst['data']: for row in hlst['data']:
p += frav p += frav
Io.touch(row[1]+km.EXT,times) Io.touch(row[1]+km.EXT,times)
Sys.cli_emit_progress(p) Sys.cli_emit_progress(p)
if self.o.outputfile is not None : if self.o.outputfile is not None :
d = Sys.datetime.now() d = Sys.datetime.now()
if Sys.g.DEBUG : Sys.wlog(Sys.dprint()) if Sys.g.DEBUG : Sys.wlog(Sys.dprint())
Sys.ptask('Preparing tark file') Sys.ptask('Preparing tark file')
hlst['data'] = sorted(hlst['data'], key=lambda lst: lst[4]) hlst['data'] = sorted(hlst['data'], key=lambda lst: lst[4])
with tarfile.open(self.o.outputfile, mode='w') as tar: with tarfile.open(self.o.outputfile, mode='w') as tar:
tar.add(kcf, arcname=Sys.basename(kcf)) tar.add(kcf, arcname=Sys.basename(kcf))
p = 90 p = 90
for row in hlst['data']: for row in hlst['data']:
tar.add(row[1]+km.EXT, arcname=Sys.basename(row[1]+km.EXT)) tar.add(row[1]+km.EXT, arcname=Sys.basename(row[1]+km.EXT))
p += frav p += frav
Sys.cli_emit_progress(p) Sys.cli_emit_progress(p)
Sys.pstep('Packing destination file', d, True) Sys.pstep('Packing destination file', d, True)
d = Sys.datetime.now() d = Sys.datetime.now()
Sys.ptask('Finalize') Sys.ptask('Finalize')
for row in hlst['data']: for row in hlst['data']:
Io.removeFile(row[1]+km.EXT) Io.removeFile(row[1]+km.EXT)
p += frav p += frav
Sys.cli_emit_progress(p) Sys.cli_emit_progress(p)
Io.removeFile(kcf) Io.removeFile(kcf)
Sys.pstep('Cleaning', d, True) Sys.pstep('Cleaning', d, True)
@ -235,11 +236,11 @@ class CliApp:
#~ raise e #~ raise e
elif not Sys.g.QUIET : elif not Sys.g.QUIET :
Sys.pwarn((str(e),)) Sys.pwarn((str(e),))
if not Sys.g.QUIET: if not Sys.g.QUIET:
Sys.cli_emit_progress(100) Sys.cli_emit_progress(100)
self.onend_cmd('Kirmah Split', self.stime, done, self.o.outputfile) self.onend_cmd('Kirmah Split', self.stime, done, self.o.outputfile)
@Log(Const.LOG_DEBUG) @Log(Const.LOG_DEBUG)
@ -253,7 +254,7 @@ class CliApp:
toPath = None toPath = None
try : try :
Sys.ptask() Sys.ptask()
key = Io.get_data(self.o.keyfile) key = Io.get_data(self.o.keyfile)
km = Kirmah(key) km = Kirmah(key)
@ -303,7 +304,7 @@ class CliApp:
@Log(Const.LOG_DEBUG) @Log(Const.LOG_DEBUG)
def onend_cmd(self, title, stime, done, outputfile): def onend_cmd(self, title, stime, done, outputfile):
"""""" """"""
s = Const.LINE_SEP_CHAR*Const.LINE_SEP_LEN s = Const.LINE_SEP_CHAR*Const.LINE_SEP_LEN
Sys.print(s, Sys.CLZ_HEAD_LINE) Sys.print(s, Sys.CLZ_HEAD_LINE)
Sys.wlog([(s, Const.CLZ_HEAD_SEP)]) Sys.wlog([(s, Const.CLZ_HEAD_SEP)])

190
kirmah/crypt.py
View File

@ -91,60 +91,6 @@ def represents_int(s):
return False return False
@Log(Const.LOG_DEBUG)
def getRandomListFromKey(key, size):
""""""
j, ok, lk, r, ho, hr, lv, hv, rev = 0, False, len(key), None, [], [], 0, size-1, False
for i in range(size) :
if j >= lk : j = 0
r = key[j]
ok = r < size and not r in ho
if not ok:
r = hv if not rev else lv
while r in ho :
r = r - 1 if not rev else r + 1
if r > size-1 : r = 0
elif r < 0 : r = size - 1
if not rev : hv = r
else : lv = r
ok = not r in ho
if ok : ho.append(r)
j += 1
rev = not rev
return getSimulRandomList(ho, getSimulNumber(key, size//5 if not size//5==0 else size*2, size//10 if not size//10 ==0 else size))
@Log(Const.LOG_ALL)
def getSimulRandomList(lst, chsize):
""""""
return _getSimulRandomList(list(reversed(_getSimulRandomList(_getSimulRandomList(lst, chsize), 4))),4)
@Log(Const.LOG_PRIVATE)
def _getSimulRandomList(lst, chsize):
""""""
size, rlst, pos = len(lst), [], 0
if chsize > 0 :
for i in range(chsize+1):
for j in range(ceil(size/chsize)+1):
pos = j*chsize+i
if pos in lst and not lst[pos] in rlst:
rlst.append(lst[pos])
else : rlst = lst
return rlst
@Log(Const.LOG_DEBUG)
def getSimulNumber(key, lim, delta=12):
""""""
s = 0
for c in key[::-1] :
if represents_int(chr(c)): c = int(chr(c))
if c > 2 and (lim-delta > c + s or c + s < lim + delta ) :
s += c
return s
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# ~~ class KeyGen ~~ # ~~ class KeyGen ~~
@ -231,8 +177,8 @@ class ConfigKey:
self.rdmz.new(count) self.rdmz.new(count)
dic, lst, hroot = {}, [], hash_sha256(self.salt+name) dic, lst, hroot = {}, [], hash_sha256(self.salt+name)
#~ srdl = Kirmah.getRandomListFromKey(self.key, count) srdl = Kirmah.getRandomListFromKey(self.key, count)
srdl = getRandomListFromKey(self.key, count) #~ srdl = getRandomListFromKey(self.key, count)
for i in range(count) : for i in range(count) :
self.noiser.build(i,ConfigKey.sumNumber(hash_sha256(str(i)+self.salt+name),1 if i%2 else 2)) self.noiser.build(i,ConfigKey.sumNumber(hash_sha256(str(i)+self.salt+name),1 if i%2 else 2))
d = str(i).rjust(2,'0') d = str(i).rjust(2,'0')
@ -419,27 +365,37 @@ class Kirmah:
@Log() @Log()
def compress_start(self, fromPath, toPath, compress=True, lvl=9): def compress_start(self, fromPath, toPath, compress=True, lvl=9):
"""""" """"""
if not Sys.is_cli_cancel(): d = Sys.datetime.now()
c = not Sys.is_cli_cancel()
if c :
with Io.rfile(fromPath) as fi : with Io.rfile(fromPath) as fi :
with Io.wfile(toPath) as fo : with Io.wfile(toPath) as fo :
data = fi.read() if not compress else Io.gzcompress(fi.read(), lvl) data = fi.read() if not compress else Io.gzcompress(fi.read(), lvl)
fo.write(b2a_base64(data)) fo.write(b2a_base64(data))
Sys.wlog(Sys.dprint())
Sys.pstep('Compression', d, c)
@Log() @Log()
def uncompress_start(self, fromPath, toPath, decompress=True): def uncompress_start(self, fromPath, toPath, decompress=True):
"""""" """"""
if not Sys.is_cli_cancel(): d = Sys.datetime.now()
c = not Sys.is_cli_cancel()
if c :
with Io.rfile(fromPath) as fi : with Io.rfile(fromPath) as fi :
with Io.wfile(toPath) as fo : with Io.wfile(toPath) as fo :
data = a2b_base64(fi.read()) data = a2b_base64(fi.read())
fo.write(data if not decompress else Io.gzdecompress(data)) fo.write(data if not decompress else Io.gzdecompress(data))
Sys.wlog(Sys.dprint())
Sys.pstep('Compression mode', d, c)
@Log() @Log()
def compress_end(self, fromPath, toPath, compress=True, lvl=9): def compress_end(self, fromPath, toPath, compress=True, lvl=9):
"""""" """"""
if not Sys.is_cli_cancel(): d = Sys.datetime.now()
c = not Sys.is_cli_cancel()
if c:
with Io.rfile(fromPath) as fi : with Io.rfile(fromPath) as fi :
with Io.wfile(toPath) as fo : with Io.wfile(toPath) as fo :
data = fi.read() data = fi.read()
@ -447,17 +403,22 @@ class Kirmah:
header = self.kh.buildHeader(len(data)) header = self.kh.buildHeader(len(data))
fo.write(header) fo.write(header)
fo.write(data) fo.write(data)
Sys.wlog(Sys.dprint())
Sys.pstep('Compression mode', d, c)
@Log() @Log()
def uncompress_end(self, fromPath, toPath, decompress=True): def uncompress_end(self, fromPath, toPath, decompress=True):
"""""" """"""
if not Sys.is_cli_cancel(): d = Sys.datetime.now()
c = not Sys.is_cli_cancel()
if c:
with Io.rfile(fromPath) as fi : with Io.rfile(fromPath) as fi :
with Io.wfile(toPath) as fo : with Io.wfile(toPath) as fo :
fi.seek(self.kh.POS_END) fi.seek(self.kh.POS_END)
fo.write(fi.read() if not decompress else Io.gzdecompress(fi.read())) fo.write(fi.read() if not decompress else Io.gzdecompress(fi.read()))
Sys.wlog(Sys.dprint())
Sys.pstep('Compression mode', d, c)
@Log(Const.LOG_ALL) @Log(Const.LOG_ALL)
def encryptStr(self, data): def encryptStr(self, data):
@ -474,7 +435,7 @@ class Kirmah:
@Log() @Log()
def encryptToFile(self, fromPath, toPath, i=0, lock=None): def encryptToFile(self, fromPath, toPath, i=0, event=None):
"""""" """"""
if not Sys.is_cli_cancel(): if not Sys.is_cli_cancel():
with Io.ufile(fromPath) as fi : with Io.ufile(fromPath) as fi :
@ -483,14 +444,15 @@ class Kirmah:
for c in Io.read_utf8_chr(fi): for c in Io.read_utf8_chr(fi):
if i >= lk: if i >= lk:
i = 0 i = 0
if Sys.is_cli_cancel(lock): if Sys.is_cli_cancel(event) :
Sys.pwarn((('terminating child process ',(str(Sys.getpid()),Sys.CLZ_WARN_PARAM), ' !'),), False)
break break
fo.write(chr(ord(c) + i//4 + (self.key[i] if ord(c) + self.key[i] + i//4 < 11000 else -self.key[i]))) fo.write(chr(ord(c) + i//4 + (self.key[i] if ord(c) + self.key[i] + i//4 < 11000 else -self.key[i])))
i += 1 i += 1
@Log() @Log()
def decryptToFile(self, fromPath, toPath, i=0): def decryptToFile(self, fromPath, toPath, i=0, event=None):
"""""" """"""
if not Sys.is_cli_cancel(): if not Sys.is_cli_cancel():
with Io.ufile(fromPath) as fi : with Io.ufile(fromPath) as fi :
@ -502,7 +464,9 @@ class Kirmah:
for c in Io.read_utf8_chr(fi): for c in Io.read_utf8_chr(fi):
if i >= lk: if i >= lk:
i = 0 i = 0
if Sys.is_cli_cancel(): break if Sys.is_cli_cancel(event) :
Sys.pwarn((('terminating child process ',(str(Sys.getpid()),Sys.CLZ_WARN_PARAM), ' !'),), False)
break
try : try :
fo.write(chr(ord(c)- i//4 + (-self.key[i] if ord(c) + self.key[i] +i//4 < 110000 else self.key[i]))) fo.write(chr(ord(c)- i//4 + (-self.key[i] if ord(c) + self.key[i] +i//4 < 110000 else self.key[i])))
except Exception as e : except Exception as e :
@ -516,7 +480,9 @@ class Kirmah:
@Log() @Log()
def randomFileContent(self, fromPath, toPath): def randomFileContent(self, fromPath, toPath):
"""""" """"""
if not Sys.is_cli_cancel(): d = Sys.datetime.now()
c = not Sys.is_cli_cancel()
if c:
with Io.rfile(fromPath) as fi : with Io.rfile(fromPath) as fi :
with Io.wfile(toPath) as fo : with Io.wfile(toPath) as fo :
fsize, chsize, size = Kirmah.getSizes(fromPath) fsize, chsize, size = Kirmah.getSizes(fromPath)
@ -525,6 +491,8 @@ class Kirmah:
for piece, i in Io.read_in_chunks(fi, chsize): for piece, i in Io.read_in_chunks(fi, chsize):
fo.seek(lst[i]*chsize-(rest if lst[i] > lst[size-1] else 0)) fo.seek(lst[i]*chsize-(rest if lst[i] > lst[size-1] else 0))
fo.write(piece[::-1]) fo.write(piece[::-1])
Sys.wlog(Sys.dprint())
Sys.pstep('Random mode', d, c)
@Log() @Log()
@ -562,7 +530,9 @@ class Kirmah:
@Log() @Log()
def mpMergeFiles(self,hlstPaths, toPath, noRemove=False): def mpMergeFiles(self,hlstPaths, toPath, noRemove=False):
"""""" """"""
if not Sys.is_cli_cancel(): d = Sys.datetime.now()
c = not Sys.is_cli_cancel()
if c:
with Io.wfile(toPath) as fo: with Io.wfile(toPath) as fo:
for fromPath in hlstPaths : for fromPath in hlstPaths :
with Io.rfile(fromPath) as fi : with Io.rfile(fromPath) as fi :
@ -573,25 +543,31 @@ class Kirmah:
@Log() @Log()
def unRandomFileContent(self, fromPath, toPath): def unRandomFileContent(self, fromPath, toPath):
"""""" """"""
if not Sys.is_cli_cancel(): d = Sys.datetime.now()
c = not Sys.is_cli_cancel()
if c:
with Io.rfile(fromPath) as fi : with Io.rfile(fromPath) as fi :
with Io.wfile(toPath) as fo : with Io.wfile(toPath) as fo :
fsize, chsize, size = Kirmah.getSizes(fromPath) fsize, chsize, size = Kirmah.getSizes(fromPath)
lst, rest, piece, data = Kirmah.getRandomListFromKey(self.ck.key, size), chsize - fsize%chsize, b'', [] lst, rest, piece, data = Kirmah.getRandomListFromKey(self.ck.key, size), chsize - fsize%chsize, b'', []
if rest == chsize : rest = 0 if rest == chsize : rest = 0
for i, pos in enumerate(lst): for i, pos in enumerate(lst):
d = pos*chsize-(rest if pos >= lst[size-1] and pos!=0 else 0) dp = pos*chsize-(rest if pos >= lst[size-1] and pos!=0 else 0)
if d >= 0 : fi.seek(d) if dp >= 0 : fi.seek(dp)
piece = fi.read(chsize) piece = fi.read(chsize)
if i == size-1 and rest > 0 : if i == size-1 and rest > 0 :
piece = piece[:-rest] if lst[i]==0 else piece[rest:] piece = piece[:-rest] if lst[i]==0 else piece[rest:]
fo.write(piece[::-1]) fo.write(piece[::-1])
Sys.wlog(Sys.dprint())
Sys.pstep('Random mode', d, c)
@Log() @Log()
def mixdata(self, fromPath, toPath, encryptNoise=False, label='kirmah', cpart=22): def mixdata(self, fromPath, toPath, encryptNoise=False, label='kirmah', cpart=22):
"""""" """"""
if not Sys.is_cli_cancel(): d = Sys.datetime.now()
c = not Sys.is_cli_cancel()
if c:
hlst = self.ck.getHashList(label, cpart, False) hlst = self.ck.getHashList(label, cpart, False)
hlst['data'] = sorted(hlst['data'], key=lambda hlst: hlst[0]) hlst['data'] = sorted(hlst['data'], key=lambda hlst: hlst[0])
size = Sys.getsize(fromPath) size = Sys.getsize(fromPath)
@ -607,9 +583,10 @@ class Kirmah:
if encryptNoise : if encryptNoise :
bdata, adata = self.encryptStr(bdata)[:row[2]], self.encryptStr(adata)[:row[3]] bdata, adata = self.encryptStr(bdata)[:row[2]], self.encryptStr(adata)[:row[3]]
fi.seek(psize*row[5]) fi.seek(psize*row[5])
d = fi.read(psize) fo.write(bdata[:row[2]] + fi.read(psize) + adata[:row[3]])
fo.write(bdata[:row[2]] + d + adata[:row[3]])
cp += 1 cp += 1
Sys.wlog(Sys.dprint())
Sys.pstep('Mix mode', d, c)
@Log(Const.LOG_DEBUG) @Log(Const.LOG_DEBUG)
@ -634,7 +611,9 @@ class Kirmah:
@Log() @Log()
def unmixdata(self, fromPath, toPath, label='kirmah', cpart=22): def unmixdata(self, fromPath, toPath, label='kirmah', cpart=22):
"""""" """"""
if not Sys.is_cli_cancel(): d = Sys.datetime.now()
c = not Sys.is_cli_cancel()
if c:
rsz, cp, hlst = 0, 0, self.ck.getHashList(label, cpart, True) rsz, cp, hlst = 0, 0, self.ck.getHashList(label, cpart, True)
for row in hlst['data']: for row in hlst['data']:
rsz += row[2]+row[3] rsz += row[2]+row[3]
@ -652,12 +631,14 @@ class Kirmah:
fi.seek(0,Io.SEEK_CUR) fi.seek(0,Io.SEEK_CUR)
for row in hlst['data']: for row in hlst['data']:
fi.seek(lbi[row[0]]+row[2]) fi.seek(lbi[row[0]]+row[2])
d = fi.read(psize if row[5] <= mxp else (rest if rest!=psize or (psize*cpart==size) else 0)) dp = fi.read(psize if row[5] <= mxp else (rest if rest!=psize or (psize*cpart==size) else 0))
cp += 1 cp += 1
if fo.tell() + len(d) > size : if fo.tell() + len(dp) > size :
fo.write(d[:rest]) fo.write(dp[:rest])
break break
fo.write(d) fo.write(dp)
Sys.wlog(Sys.dprint())
Sys.pstep('Mix mode', d, c)
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
@ -822,7 +803,8 @@ class Kirmah:
self.tmpPath2 = self.DIR_TEMP + Sys.basename(fromPath) + '.tmp2' self.tmpPath2 = self.DIR_TEMP + Sys.basename(fromPath) + '.tmp2'
compend, compstart = not decHeader['cmode']== KirmahHeader.COMP_NONE, decHeader['cmode']== KirmahHeader.COMP_ALL compend, compstart = not decHeader['cmode']== KirmahHeader.COMP_NONE, decHeader['cmode']== KirmahHeader.COMP_ALL
fp, tp = fromPath, self.tmpPath1 fp, tp = fromPath, self.tmpPath1
Sys.wlog(Sys.dprint())
Sys.ptask('Compressing data')
self.compress_start(fp, tp, compstart) self.compress_start(fp, tp, compstart)
fp, tp = tp, self.tmpPath2 if tp == self.tmpPath1 else self.tmpPath1 fp, tp = tp, self.tmpPath2 if tp == self.tmpPath1 else self.tmpPath1
return fp, tp, decHeader['rmode'], decHeader['mmode'], compend return fp, tp, decHeader['rmode'], decHeader['mmode'], compend
@ -834,16 +816,23 @@ class Kirmah:
if not Sys.is_cli_cancel(): if not Sys.is_cli_cancel():
if rmode : if rmode :
#~ self.mpRandomFileContent(fp, tp, 4) #~ self.mpRandomFileContent(fp, tp, 4)
Sys.wlog(Sys.dprint())
Sys.ptask('Randomizing data')
self.randomFileContent(fp, tp) self.randomFileContent(fp, tp)
fp, tp = tp, self.tmpPath2 if tp == self.tmpPath1 else self.tmpPath1 fp, tp = tp, self.tmpPath2 if tp == self.tmpPath1 else self.tmpPath1
if mmode : if mmode :
Sys.wlog(Sys.dprint())
Sys.ptask('Mixing data')
self.mixdata(fp, tp, True) self.mixdata(fp, tp, True)
fp, tp = tp, self.tmpPath2 if tp == self.tmpPath1 else self.tmpPath1 fp, tp = tp, self.tmpPath2 if tp == self.tmpPath1 else self.tmpPath1
Sys.wlog(Sys.dprint())
Sys.ptask('Compressing data')
self.compress_end(fp, toPath, compend) self.compress_end(fp, toPath, compend)
# clean tmp files # clean tmp files
Sys.wlog(Sys.dprint())
Sys.ptask('Cleaning')
try : try :
Sys.removeFile(self.tmpPath1) Sys.removeFile(self.tmpPath1)
Sys.removeFile(self.tmpPath2) Sys.removeFile(self.tmpPath2)
@ -870,30 +859,35 @@ class Kirmah:
@Log() @Log()
def mproc_encode_part(self, id, lock=None): def mproc_encode_part(self, id, event=None):
"""""" """"""
if not Sys.is_cli_cancel(): if not Sys.is_cli_cancel():
mpfile, mpfilenc = self.KMP_FILE+'_'+str(Sys.g.MAIN_PROC)+'_'+str(id), self.KMP_FILE+'enc_'+str(Sys.g.MAIN_PROC)+'_'+str(id) mpfile, mpfilenc = self.KMP_FILE+'_'+str(Sys.g.MAIN_PROC)+'_'+str(id), self.KMP_FILE+'enc_'+str(Sys.g.MAIN_PROC)+'_'+str(id)
self.encryptToFile(mpfile, mpfilenc, self.getSubStartIndice(id), lock) self.encryptToFile(mpfile, mpfilenc, self.getSubStartIndice(id), event)
Sys.removeFile(mpfile) Sys.removeFile(mpfile)
@Log() @Log()
def encrypt_mproc(self, fp, tp, nproc=1): def encrypt_mproc(self, fp, tp, nproc=1):
"""""" """"""
if not Sys.is_cli_cancel(): Sys.wlog(Sys.dprint())
Sys.ptask('Encrypting data')
d = Sys.datetime.now()
c = not Sys.is_cli_cancel()
if c:
if nproc == 1 : if nproc == 1 :
self.encryptToFile(fp, tp) self.encryptToFile(fp, tp)
else : else :
hlstPaths = self.prepare_mproc_encode(fp, nproc) hlstPaths = self.prepare_mproc_encode(fp, nproc)
mg = Manager(self.mproc_encode_part, nproc, None, Sys.g.MPRLOCK) mg = Manager(self.mproc_encode_part, nproc, None, Sys.g.MPEVENT)
mg.run() mg.run()
self.mpMergeFiles(hlstPaths, tp) self.mpMergeFiles(hlstPaths, tp)
Sys.wlog(Sys.dprint())
Sys.pstep('Encrypt data', d, c)
@Log() @Log()
def encrypt(self, fromPath, toPath, nproc=1, header=None): def encrypt(self, fromPath, toPath, nproc=1, header=None):
"""""" """"""
if not Sys.is_cli_cancel(): if not Sys.is_cli_cancel():
fp, tp, rmode, mmode, compend = self.encrypt_sp_start(fromPath, toPath, header) fp, tp, rmode, mmode, compend = self.encrypt_sp_start(fromPath, toPath, header)
@ -926,13 +920,19 @@ class Kirmah:
compend, compstart = not decHeader['cmode']== KirmahHeader.COMP_NONE, decHeader['cmode']== KirmahHeader.COMP_ALL compend, compstart = not decHeader['cmode']== KirmahHeader.COMP_NONE, decHeader['cmode']== KirmahHeader.COMP_ALL
fp, tp = fromPath, self.tmpPath1 fp, tp = fromPath, self.tmpPath1
Sys.wlog(Sys.dprint())
Sys.ptask('Uncompressing data')
self.uncompress_end(fp, tp, compend) self.uncompress_end(fp, tp, compend)
fp, tp = tp, self.tmpPath2 if tp == self.tmpPath1 else self.tmpPath1 fp, tp = tp, self.tmpPath2 if tp == self.tmpPath1 else self.tmpPath1
if decHeader['mmode'] : if decHeader['mmode'] :
Sys.wlog(Sys.dprint())
Sys.ptask('Sorting data')
self.unmixdata(fp, tp) self.unmixdata(fp, tp)
fp, tp = tp, self.tmpPath2 if tp == self.tmpPath1 else self.tmpPath1 fp, tp = tp, self.tmpPath2 if tp == self.tmpPath1 else self.tmpPath1
if decHeader['rmode'] : if decHeader['rmode'] :
Sys.wlog(Sys.dprint())
Sys.ptask('Reordering data')
self.unRandomFileContent(fp, tp) self.unRandomFileContent(fp, tp)
fp, tp = tp, self.tmpPath2 if tp == self.tmpPath1 else self.tmpPath1 fp, tp = tp, self.tmpPath2 if tp == self.tmpPath1 else self.tmpPath1
return fp, tp, compstart return fp, tp, compstart
@ -942,7 +942,11 @@ class Kirmah:
def decrypt_sp_end(self, fromPath, toPath, compstart): def decrypt_sp_end(self, fromPath, toPath, compstart):
"""""" """"""
if not Sys.is_cli_cancel(): if not Sys.is_cli_cancel():
Sys.wlog(Sys.dprint())
Sys.ptask('Uncompressing data')
self.uncompress_start(fromPath, toPath, compstart) self.uncompress_start(fromPath, toPath, compstart)
Sys.wlog(Sys.dprint())
Sys.ptask('Cleaning')
try : try :
Sys.removeFile(self.tmpPath1) Sys.removeFile(self.tmpPath1)
Sys.removeFile(self.tmpPath2) Sys.removeFile(self.tmpPath2)
@ -953,14 +957,20 @@ class Kirmah:
@Log() @Log()
def decrypt_mproc(self, fromPath, toPath, nproc=1): def decrypt_mproc(self, fromPath, toPath, nproc=1):
"""""" """"""
if not Sys.is_cli_cancel(): Sys.wlog(Sys.dprint())
Sys.ptask('Decrypting data')
d = Sys.datetime.now()
c = not Sys.is_cli_cancel()
if c:
if nproc == 1 : if nproc == 1 :
self.decryptToFile(fromPath, toPath) self.decryptToFile(fromPath, toPath)
else : else :
hlstPaths = self.prepare_mproc_decode(fromPath, nproc) hlstPaths = self.prepare_mproc_decode(fromPath, nproc)
mg = Manager(self.mproc_decode_part, nproc, None, Sys.g.MPRLOCK) mg = Manager(self.mproc_decode_part, nproc, None, Sys.g.MPEVENT)
mg.run() mg.run()
self.mpMergeFiles(hlstPaths, toPath) self.mpMergeFiles(hlstPaths, toPath)
Sys.wlog(Sys.dprint())
Sys.pstep('Decrypt data', d, c)
@Log() @Log()
@ -985,11 +995,11 @@ class Kirmah:
@Log() @Log()
def mproc_decode_part(self, id): def mproc_decode_part(self, id, event=None):
"""""" """"""
if not Sys.is_cli_cancel(): if not Sys.is_cli_cancel():
mpfile, mpfiledec = self.KMP_FILE+'_'+str(Sys.g.MAIN_PROC)+'_'+str(id), self.KMP_FILE+'dec_'+str(Sys.g.MAIN_PROC)+'_'+str(id) mpfile, mpfiledec = self.KMP_FILE+'_'+str(Sys.g.MAIN_PROC)+'_'+str(id), self.KMP_FILE+'dec_'+str(Sys.g.MAIN_PROC)+'_'+str(id)
self.decryptToFile(mpfile, mpfiledec, self.getSubStartIndice(id)) self.decryptToFile(mpfile, mpfiledec, self.getSubStartIndice(id), event)
Sys.removeFile(mpfile) Sys.removeFile(mpfile)

8
kirmah/gui.py
View File

@ -39,7 +39,6 @@ from time import time, sleep
from getpass import getuser as getUserLogin from getpass import getuser as getUserLogin
from mmap import mmap from mmap import mmap
from math import ceil from math import ceil
from threading import Thread, Event, Timer, Condition, RLock, current_thread, get_ident, enumerate as thread_enum
from kirmah.crypt import KeyGen, Kirmah, KirmahHeader, ConfigKey, BadKeyException, b2a_base64, a2b_base64, hash_sha256_file from kirmah.crypt import KeyGen, Kirmah, KirmahHeader, ConfigKey, BadKeyException, b2a_base64, a2b_base64, hash_sha256_file
from kirmah.app import KirmahApp, FileNotFoundException, FileNeedOverwriteException from kirmah.app import KirmahApp, FileNotFoundException, FileNeedOverwriteException
@ -47,7 +46,7 @@ from kirmah.ui import Gui, CliThread
from kirmah import conf from kirmah import conf
from psr.sys import Sys, Io, Const from psr.sys import Sys, Io, Const
from psr.log import Log from psr.log import Log
from psr.mproc import Manager, Lock from psr.mproc import Manager
import pdb import pdb
@ -115,8 +114,9 @@ class AppGui(Gui):
tree_iter = cbt.get_model().get_iter_from_string('3') tree_iter = cbt.get_model().get_iter_from_string('3')
cbt.set_active_iter(tree_iter) cbt.set_active_iter(tree_iter)
cbt = self.get('comboboxtext2') cbt = self.get('comboboxtext2')
cbt.connect("changed", self.on_logging_changed) cbt.connect("changed", self.on_logging_changed)
tree_iter = cbt.get_model().get_iter_first() tree_iter = cbt.get_model().get_iter_first()
tree_iter = cbt.get_model().get_iter_from_string('4')
cbt.set_active_iter(tree_iter) cbt.set_active_iter(tree_iter)
Sys.clear() Sys.clear()
Sys.dprint('INIT UI') Sys.dprint('INIT UI')
@ -135,7 +135,7 @@ class AppGui(Gui):
return thread return thread
cliargs = ['kirmah-cli.py', 'split', '-df', '/media/Hermes/webbakup/The Raven.avi', '-z', '-r', '-m', '-o', '/home/dev/git_repos/kirmah2.15/The Raven.avi.kmh'] cliargs = ['kirmah-cli.py', 'split', '-df', '/media/Hermes/webbakup/The Raven.avi', '-z', '-r', '-m', '-o', '/home/dev/git_repos/kirmah2.15/The Raven.avi.kmh']
cliargs = self.app.getCall() cliargs = self.app.getCall()
self.thkmh = getKmhThread(self.thread_finished, self.thread_interrupted, self.thread_progress, None, cliargs) self.thkmh = getKmhThread(self.thread_finished, self.thread_interrupted, self.thread_progress, None, cliargs, Sys.g.MPEVENT)
self.thkmh.start() self.thkmh.start()

7
kirmah/ui.py
View File

@ -37,6 +37,7 @@ from gi.repository.Gtk import AboutDialog, Builder, main as main_enter,
from gi.repository.GdkPixbuf import Pixbuf from gi.repository.GdkPixbuf import Pixbuf
from gi.repository.GObject import threads_init, GObject, idle_add, SIGNAL_RUN_LAST, TYPE_NONE, TYPE_STRING, TYPE_FLOAT, TYPE_BOOLEAN from gi.repository.GObject import threads_init, GObject, idle_add, SIGNAL_RUN_LAST, TYPE_NONE, TYPE_STRING, TYPE_FLOAT, TYPE_BOOLEAN
from threading import Thread, current_thread, enumerate as thread_enum from threading import Thread, current_thread, enumerate as thread_enum
from multiprocessing import Event
from psr.sys import Sys, Io, Const from psr.sys import Sys, Io, Const
from psr.log import Log from psr.log import Log
from kirmah import conf from kirmah import conf
@ -317,17 +318,18 @@ class CliThread(Thread, IdleObject):
@Log(Const.LOG_DEBUG) @Log(Const.LOG_DEBUG)
def __init__(self, rwargs): def __init__(self, rwargs, event):
Thread.__init__(self) Thread.__init__(self)
IdleObject.__init__(self) IdleObject.__init__(self)
self.setName('CliThread') self.setName('CliThread')
self.cliargs = rwargs self.cliargs = rwargs
self.event = event
@Log(Const.LOG_DEBUG) @Log(Const.LOG_DEBUG)
def run(self): def run(self):
"""""" """"""
self.cancelled = False self.cancelled = False
Sys.g.MPEVENT.clear()
print(Sys.g.LOG_LEVEL) print(Sys.g.LOG_LEVEL)
Cli('./', Sys.getpid(), self.cliargs, self, Sys.g.LOG_LEVEL) Cli('./', Sys.getpid(), self.cliargs, self, Sys.g.LOG_LEVEL)
self.emit("completed") self.emit("completed")
@ -346,6 +348,7 @@ class CliThread(Thread, IdleObject):
cancellation logic cancellation logic
""" """
self.cancelled = True self.cancelled = True
self.event.set()
@Log(Const.LOG_NEVER) @Log(Const.LOG_NEVER)

224
psr/cli.py Normal file
View File

@ -0,0 +1,224 @@
# !/usr/bin/env python
# -*- coding: utf-8 -*-
# kirmah.cli.py
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
#
# software : Kirmah <http://kirmah.sourceforge.net/>
# version : 2.17
# date : 2013
# licence : GPLv3.0 <http://www.gnu.org/licenses/>
# author : a-Sansara <[a-sansara]at[clochardprod]dot[net]>
# copyright : pluie.org <http://www.pluie.org/>
#
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
#
# This file is part of Kirmah.
#
# Kirmah is free software (free as in speech) : you can redistribute it
# and/or modify it under the terms of the GNU General Public License as
# published by the Free Software Foundation, either version 3 of the License,
# or (at your option) any later version.
#
# Kirmah is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
# more details.
#
# You should have received a copy of the GNU General Public License
# along with Kirmah. If not, see <http://www.gnu.org/licenses/>.
#
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# ~~ module cli ~~
from optparse import OptionParser, OptionGroup
from psr.sys import Sys, Io, Const, init
from psr.log import Log
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# ~~ class TinyParser ~~
class TinyParser(OptionParser):
def format_description(self, formatter):
""""""
return self.description
def format_epilog(self, formatter):
""""""
return self.epilog
def error(self, errMsg, errData=None):
""""""
self.print_usage('')
AbstractCli.error_cmd((errMsg,))
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# ~~ class AbstractConf ~~
class YourConf():
PRG_NAME = 'your-program'
PRG_VERS = '1.0'
PRG_AUTHOR = 'you'
PRG_LICENSE = 'GNU GPL v3'
PRG_COPY = 'company'
PRG_CLI_NAME = 'your-cli-program'
PRG_DESC = 'your desc'
# you must provide a global conf object
prgconf = YourConf()
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# ~~ class AbstractCli ~~
class AbstractCli():
conf = YourConf()
def __init__(self, prgconf=None, *args, **kwargs):
""""""
if not Sys.isUnix : Const.LINE_SEP_CHAR = '-'
AbstractCli.conf = prgconf
self.parser = TinyParser()
self.parser.print_help = AbstractCli.print_help
self.parser.print_usage = AbstractCli.print_usage
self.parser.add_option('-v', '--version' , action='store_true', default=False)
self.parser.add_option('-d', '--debug' , action='store_true', default=False)
self.parser.add_option('-f', '--force' , action='store_true', default=False)
self.parser.add_option('-q', '--quiet' , action='store_true', default=False)
self.parser.add_option('--no-color' , action='store_true' , default=False)
@staticmethod
def error_cmd(data):
""""""
AbstractCli.print_usage('')
Sys.dprint()
Sys.pwarn(data, True)
AbstractCli.exit(1)
@staticmethod
def exit(code):
""""""
if Sys.isUnix() : Sys.exit(code)
@staticmethod
def print_header():
""""""
a = AbstractCli.printLineSep(Const.LINE_SEP_CHAR,Const.LINE_SEP_LEN)
b = AbstractCli.printHeaderTitle(AbstractCli.conf.PRG_CLI_NAME)
c = AbstractCli.printHeaderPart('version' ,AbstractCli.conf.PRG_VERS)
d = AbstractCli.printHeaderPart('author' ,AbstractCli.conf.PRG_AUTHOR)
e = AbstractCli.printHeaderPart('license' ,AbstractCli.conf.PRG_LICENSE)
f = AbstractCli.printHeaderPart('copyright',AbstractCli.conf.PRG_COPY)
Sys.print(' ', Sys.Clz.OFF)
AbstractCli.printLineSep(Const.LINE_SEP_CHAR,Const.LINE_SEP_LEN)
Sys.wlog(a)
Sys.wlog(b + c + d + e + f )
Sys.wlog(a)
Sys.wlog(Sys.dprint())
@staticmethod
def printLineSep(sep,lenSep):
""""""
s = sep*lenSep
Sys.print(s, Sys.CLZ_HEAD_LINE)
return [(s, Const.CLZ_HEAD_SEP)]
@staticmethod
def printHeaderTitle(title):
""""""
s = ' == '+title+' == '
Sys.print(s, Sys.CLZ_HEAD_APP, False, True)
return [(s, Const.CLZ_HEAD_APP)]
@staticmethod
def printHeaderPart(label,value):
""""""
a, b, c = ' [',':' ,'] '
Sys.print(a , Sys.CLZ_HEAD_SEP, False)
Sys.print(label, Sys.CLZ_HEAD_KEY, False)
Sys.print(b , Sys.CLZ_HEAD_SEP, False)
Sys.print(value, Sys.CLZ_HEAD_VAL, False)
Sys.print(c , Sys.CLZ_HEAD_SEP, False)
return [(a,Const.CLZ_HEAD_SEP),(label,Const.CLZ_HEAD_KEY),(b,Const.CLZ_HEAD_SEP),(value,Const.CLZ_HEAD_VAL),(c,Const.CLZ_HEAD_SEP)]
@staticmethod
def print_version(data):
""""""
AbstractCli.print_header()
@staticmethod
def print_options():
""""""
Sys.dprint('\n')
AbstractCli.printLineSep(Const.LINE_SEP_CHAR,Const.LINE_SEP_LEN)
Sys.print(' MAIN OPTIONS :\n' , Sys.CLZ_HELP_CMD)
Sys.print(' '*4+'-v'.ljust(13,' ')+', --version' , Sys.CLZ_HELP_ARG)
Sys.print(' '*50+'display programm version' , Sys.CLZ_HELP_ARG_INFO)
Sys.print(' '*4+'-d'.ljust(13,' ')+', --debug' , Sys.CLZ_HELP_ARG)
Sys.print(' '*50+'enable debug mode' , Sys.CLZ_HELP_ARG_INFO)
Sys.print(' '*4+'-f'.ljust(13,' ')+', --force' , Sys.CLZ_HELP_ARG)
Sys.print(' '*50+'force rewriting existing files without alert' , Sys.CLZ_HELP_ARG_INFO)
Sys.print(' '*4+'-q'.ljust(13,' ')+', --quiet' , Sys.CLZ_HELP_ARG)
Sys.print(' '*50+'don\'t print status messages to stdout' , Sys.CLZ_HELP_ARG_INFO)
Sys.print(' '*4+'-h'.ljust(13,' ')+', --help' , Sys.CLZ_HELP_ARG)
Sys.print(' '*50+'display help' , Sys.CLZ_HELP_ARG_INFO)
Sys.dprint('\n')
Sys.print(' KEY OPTIONS :\n' , Sys.CLZ_HELP_CMD)
Sys.print(' '*4+'-a ' , Sys.CLZ_HELP_ARG, False)
Sys.print('VALUE'.ljust(10,' ') , Sys.CLZ_HELP_PARAM, False)
Sys.print(', --bind_opt_a'.ljust(18,' ') , Sys.CLZ_HELP_ARG, False)
Sys.print('VALUE'.ljust(10,' ') , Sys.CLZ_HELP_PARAM)
Sys.print(' '*50+'description option a' , Sys.CLZ_HELP_ARG_INFO)
Sys.print(' '*4+'-b ' , Sys.CLZ_HELP_ARG, False)
Sys.print('VALUE'.ljust(10,' ') , Sys.CLZ_HELP_PARAM, False)
Sys.print(', --bind_opt_b'.ljust(18,' ') , Sys.CLZ_HELP_ARG, False)
Sys.print('VALUE'.ljust(10,' ') , Sys.CLZ_HELP_PARAM)
Sys.print(' '*50+'description option b' , Sys.CLZ_HELP_ARG_INFO)
@staticmethod
def print_usage(data, withoutHeader=False):
""""""
if not withoutHeader : AbstractCli.print_header()
Sys.print(' USAGE :\n' , Sys.CLZ_HELP_CMD)
Sys.print(' '+AbstractCli.conf.PRG_CLI_NAME+' ' , Sys.CLZ_HELP_PRG, False)
Sys.print('help ' , Sys.CLZ_HELP_CMD)
Sys.print(' '+AbstractCli.conf.PRG_CLI_NAME+' ' , Sys.CLZ_HELP_PRG, False)
Sys.print('cmd ' , Sys.CLZ_HELP_CMD, False)
Sys.print('[ -a ' , Sys.CLZ_HELP_ARG, False)
Sys.print('{' , Sys.CLZ_HELP_PARAM, False)
Sys.print('param_a' , Sys.CLZ_HELP_PARAM, False)
Sys.print('}' , Sys.CLZ_HELP_PARAM, False)
Sys.print(' -b ' , Sys.CLZ_HELP_ARG, False)
Sys.print('{' , Sys.CLZ_HELP_PARAM, False)
Sys.print('param_b' , Sys.CLZ_HELP_PARAM, False)
Sys.print('}' , Sys.CLZ_HELP_PARAM, False)
Sys.print(']' , Sys.CLZ_HELP_ARG)
@staticmethod
def print_help():
""""""

2
psr/log.py
View File

@ -102,7 +102,7 @@ class Log:
if t is not None : if t is not None :
bind_data += Sys.pdate(t.timetuple() if enter else Sys.datetime.now().timetuple(), isChildProc) bind_data += Sys.pdate(t.timetuple() if enter else Sys.datetime.now().timetuple(), isChildProc)
a, b, c, d, e = ('=> ' if enter else '<= '), '['+str(Sys.getpid())+']', ' '+sign+'(', Log._formatArgs(args), ') ' a, b, c, d, e = ('=> ' if enter else '<= '), '['+str(Sys.getpid()).rjust(5,' ')+']', ' '+sign+'(', Log._formatArgs(args), ') '
if not isChildProc : if not isChildProc :
Sys.print(a , Sys.CLZ_IO , False) Sys.print(a , Sys.CLZ_IO , False)
Sys.print(b , Sys.CLZ_PID if not isChildProc else Sys.CLZ_CPID, False) Sys.print(b , Sys.CLZ_PID if not isChildProc else Sys.CLZ_CPID, False)

22
psr/mproc.py
View File

@ -31,7 +31,7 @@
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# ~~ module mproc ~~ # ~~ module mproc ~~
from multiprocessing import Process, current_process, Pipe, Lock from multiprocessing import Process, current_process, Pipe
from multiprocessing.connection import wait from multiprocessing.connection import wait
from threading import current_thread from threading import current_thread
from psr.sys import Sys, Const, init from psr.sys import Sys, Const, init
@ -43,22 +43,22 @@ from psr.log import Log
class Worker: class Worker:
@Log(Const.LOG_BUILD) @Log(Const.LOG_BUILD)
def __init__(self, appname, debug, gui, color, loglvl, ppid, lock, id, wp, delay, task, *args, **kwargs): def __init__(self, appname, debug, gui, color, loglvl, ppid, event, id, wp, delay, task, *args, **kwargs):
def mptask(id, *args, **kwargs): def mptask(id, *args, **kwargs):
Sys.sendMainProcMsg(Manager.MSG_INIT, None) Sys.sendMainProcMsg(Manager.MSG_INIT, None)
otask = task(id=id, lock=lock, *args, **kwargs) otask = task(id=id, event=event, *args, **kwargs)
Sys.sendMainProcMsg(Manager.MSG_END, None) Sys.sendMainProcMsg(Manager.MSG_END, None)
return otask return otask
init(appname, debug, ppid, color, loglvl) init(appname, debug, ppid, color, loglvl)
Sys.g.WPIPE = wp Sys.g.WPIPE = wp
Sys.g.CPID = id Sys.g.CPID = id
Sys.g.GUI = gui Sys.g.GUI = gui
Sys.g.RLOCK = lock # initialize child process event with parent process event
Sys.g.MPEVENT = event
if delay : Sys.sleep(delay) if delay : Sys.sleep(delay)
mptask(id, *args, **kwargs) mptask(id, *args, **kwargs)
# don't directly close pipe 'cause of eventual loging # don't directly close pipe 'cause of eventual logging
# pipe will auto close on terminating child process # pipe will auto close on terminating child process
@ -81,7 +81,7 @@ class Manager:
checktime = None checktime = None
@Log(Const.LOG_UI) @Log(Const.LOG_UI)
def __init__(self, task, nproc=2, delay=None, lock=None, *args, **kwargs): def __init__(self, task, nproc=2, delay=None, event=None, *args, **kwargs):
"""""" """"""
self.readers = [] self.readers = []
self.plist = [] self.plist = []
@ -92,7 +92,7 @@ class Manager:
r, w = Pipe(duplex=False) r, w = Pipe(duplex=False)
self.readers.append(r) self.readers.append(r)
# (process, wpipe) # (process, wpipe)
p = Process(target=Worker, args=tuple([Sys.g.PRJ_NAME, Sys.g.DEBUG, Sys.g.GUI, Sys.g.COLOR_MODE, Sys.g.LOG_LEVEL, Sys.getpid(), lock, id, w, delay, task])+tuple(args), kwargs=kwargs) p = Process(target=Worker, args=tuple([Sys.g.PRJ_NAME, Sys.g.DEBUG, Sys.g.GUI, Sys.g.COLOR_MODE, Sys.g.LOG_LEVEL, Sys.getpid(), event, id, w, delay, task])+tuple(args), kwargs=kwargs)
self.plist.append((p, w)) self.plist.append((p, w))
@Log(Const.LOG_APP) @Log(Const.LOG_APP)

39
psr/sys.py
View File

@ -34,7 +34,7 @@
from psr.io import Io from psr.io import Io
from psr.const import Const from psr.const import Const
from threading import RLock from threading import RLock
from multiprocessing import RLock as MPRLock from multiprocessing import Event
from queue import Queue from queue import Queue
def init(name, debug, remote=False, color=True, loglvl=Const.LOG_DEFAULT): def init(name, debug, remote=False, color=True, loglvl=Const.LOG_DEFAULT):
@ -64,8 +64,9 @@ class Sys:
g.LOG_TIME = False g.LOG_TIME = False
g.LOG_LIM_ARG_LENGTH = Const.LOG_LIM_ARG_LENGTH g.LOG_LIM_ARG_LENGTH = Const.LOG_LIM_ARG_LENGTH
g.QUIET = False g.QUIET = False
g.RLOCK = None g.COLOR_MODE = True
g.MPRLOCK = None g.RLOCK = None
g.MPRLOCK = None
g.WPIPE = None g.WPIPE = None
g.THREAD_CLI = None g.THREAD_CLI = None
g.UI_AUTO_SCROLL = True g.UI_AUTO_SCROLL = True
@ -75,7 +76,7 @@ class Sys:
g.SIGNAL_RUN = 2 g.SIGNAL_RUN = 2
g.GUI = False g.GUI = False
g.GUI_PRINT_STDOUT = True g.GUI_PRINT_STDOUT = True
g.MPRLOCK = MPRLock() g.MPEVENT = Event()
@staticmethod @staticmethod
@ -129,19 +130,11 @@ class Sys:
@staticmethod @staticmethod
def is_cli_cancel(mprlock=None): def is_cli_cancel(event=None):
"""""" """"""
if mprlock is None : c = Sys.g.THREAD_CLI is not None and Sys.g.THREAD_CLI.cancelled
return Sys.g.THREAD_CLI is not None and Sys.g.THREAD_CLI.cancelled return c or (event is not None and event.is_set())
else :
with mprlock :
try:
print(Sys.g.THREAD_CLI)
print(Sys.g.THREAD_CLI.cancelled)
except:
pass
return Sys.g.THREAD_CLI is not None and Sys.g.THREAD_CLI.cancelled
@staticmethod @staticmethod
def isUnix(): def isUnix():
@ -228,7 +221,7 @@ class Sys:
@staticmethod @staticmethod
# never log this func -> maximum recursion # never log this func -> maximum recursion
def wlog(data): def wlog(data=[('','default')]):
"""""" """"""
if not Sys.is_cli_cancel(): if not Sys.is_cli_cancel():
if Sys.g.LOG_QUEUE is not None : if Sys.g.LOG_QUEUE is not None :
@ -237,7 +230,7 @@ class Sys:
Sys.cli_emit_progress() Sys.cli_emit_progress()
except Exception as e: except Exception as e:
Sys.pwarn((('wlog exception ',(str(e),Sys.CLZ_ERROR_PARAM), ' !'),), True) Sys.pwarn((('wlog exception ',(str(e),Sys.CLZ_ERROR_PARAM), ' !'),), True)
else : else :
Sys.g.THREAD_CLI.stop() Sys.g.THREAD_CLI.stop()
@ -269,8 +262,12 @@ class Sys:
"""""" """"""
if not dbcall : if not dbcall :
if not Sys.g.GUI or Sys.g.GUI_PRINT_STDOUT : if not Sys.g.GUI or Sys.g.GUI_PRINT_STDOUT :
with Sys.g.RLOCK : if Sys.g.RLOCK is not None :
if not Sys.g.QUIET : print(d,end=end) with Sys.g.RLOCK :
if not Sys.g.QUIET : print(d,end=end)
else :
if not Sys.g.QUIET :
print(d,end=end)
bdata = [(d,Const.CLZ_DEFAULT)] bdata = [(d,Const.CLZ_DEFAULT)]
return bdata return bdata
@ -435,7 +432,7 @@ class Sys:
Sys.wlog(bdata) Sys.wlog(bdata)
if not noelf : if not noelf :
Sys.wlog(Sys.dprint()) Sys.wlog(Sys.dprint())
if exitOnFailed and not done: if exitOnFailed and not done:
Sys.exit(1) Sys.exit(1)

12
resources/kirmah/glade/kirmah.glade
View File

@ -21,17 +21,17 @@
<property name="step_increment">1</property> <property name="step_increment">1</property>
<property name="page_increment">10</property> <property name="page_increment">10</property>
</object> </object>
<object class="GtkFileFilter" id="filefilter1">
<patterns>
<pattern>*.key</pattern>
</patterns>
</object>
<object class="GtkFileFilter" id="filefilter2"> <object class="GtkFileFilter" id="filefilter2">
<patterns> <patterns>
<pattern>*.kmh</pattern> <pattern>*.kmh</pattern>
<pattern>*</pattern> <pattern>*</pattern>
</patterns> </patterns>
</object> </object>
<object class="GtkFileFilter" id="filefilter1">
<patterns>
<pattern>*.key</pattern>
</patterns>
</object>
<object class="GtkFileFilter" id="filefilter3"> <object class="GtkFileFilter" id="filefilter3">
<patterns> <patterns>
<pattern>*.*</pattern> <pattern>*.*</pattern>
@ -520,7 +520,6 @@
<item translatable="yes">DISABLED</item> <item translatable="yes">DISABLED</item>
<item translatable="yes">LOG_ALL</item> <item translatable="yes">LOG_ALL</item>
<item translatable="yes">LOG_DEBUG</item> <item translatable="yes">LOG_DEBUG</item>
<item translatable="yes">LOG_WARN</item>
<item translatable="yes">LOG_UI</item> <item translatable="yes">LOG_UI</item>
<item translatable="yes">LOG_DEFAULT</item> <item translatable="yes">LOG_DEFAULT</item>
</items> </items>
@ -845,7 +844,6 @@
<child> <child>
<object class="GtkButton" id="button3"> <object class="GtkButton" id="button3">
<property name="label" translatable="yes">show log</property> <property name="label" translatable="yes">show log</property>
<property name="visible">True</property>
<property name="can_focus">True</property> <property name="can_focus">True</property>
<property name="receives_default">True</property> <property name="receives_default">True</property>
<property name="no_show_all">True</property> <property name="no_show_all">True</property>