683 lines
26 KiB
Python
683 lines
26 KiB
Python
|
|
import os,sys
|
|
from collections import deque
|
|
import string
|
|
import argparse
|
|
import cStringIO,operator
|
|
import cPickle as pickle
|
|
from collections import deque
|
|
import math
|
|
import re
|
|
import cmd
|
|
import readline
|
|
try:
|
|
from gluon import DAL
|
|
except ImportError as err:
|
|
print('gluon path not found')
|
|
|
|
class refTable(object):
|
|
def __init__(self):
|
|
self.columns = None
|
|
self.rows = None
|
|
|
|
def getcolHeader(self,colHeader):
|
|
return "{0}".format(' | '.join([string.join(string.strip('**{0}**'.format(item)),
|
|
'') for item in colHeader]))
|
|
|
|
|
|
def wrapTable(self,rows, hasHeader=False, headerChar='-', delim=' | ', justify='left',
|
|
separateRows=False, prefix='', postfix='', wrapfunc=lambda x:x):
|
|
|
|
def rowWrapper(row):
|
|
|
|
'''---
|
|
newRows is returned like
|
|
[['w'], ['x'], ['y'], ['z']]
|
|
---'''
|
|
newRows = [wrapfunc(item).split('\n') for item in row]
|
|
self.rows = newRows
|
|
'''---
|
|
rowList gives like newRows but
|
|
formatted like [[w, x, y, z]]
|
|
---'''
|
|
rowList = [[substr or '' for substr in item] for item in map(None,*newRows)]
|
|
return rowList
|
|
|
|
logicalRows = [rowWrapper(row) for row in rows]
|
|
|
|
columns = map(None,*reduce(operator.add,logicalRows))
|
|
self.columns = columns
|
|
|
|
maxWidths = [max(\
|
|
[len(str\
|
|
(item)) for \
|
|
item in column]\
|
|
) for column \
|
|
in columns]
|
|
|
|
rowSeparator = headerChar * (len(prefix) + len(postfix) + sum(maxWidths) + \
|
|
len(delim)*(len(maxWidths)-1))
|
|
|
|
justify = {'center'\
|
|
:str\
|
|
.center,
|
|
'right'\
|
|
:str\
|
|
.rjust,
|
|
'left'\
|
|
:str.\
|
|
ljust\
|
|
}[justify\
|
|
.lower(\
|
|
)]
|
|
|
|
output=cStringIO.StringIO()
|
|
|
|
if separateRows:
|
|
print >> output, rowSeparator
|
|
|
|
for physicalRows in logicalRows:
|
|
for row in physicalRows:
|
|
print >> output,\
|
|
prefix + delim.join([\
|
|
justify(str(item),width) for (\
|
|
item,width) in zip(row,maxWidths)]\
|
|
) + postfix
|
|
|
|
if separateRows or hasHeader:
|
|
print >> output, rowSeparator; hasHeader=False
|
|
return output.getvalue()
|
|
|
|
def wrap_onspace(self,text,width):
|
|
return reduce(lambda line, word, width=width: '{0}{1}{2}'\
|
|
.format(line\
|
|
,' \n'[(len(\
|
|
line[line.rfind('\n'\
|
|
) + 1:]) + len(\
|
|
word.split('\n',1)[0]) >=\
|
|
width)],word),text.split(' '))
|
|
|
|
def wrap_onspace_strict(self,text,width):
|
|
wordRegex = re.compile(r'\S{'+str(width)+r',}')
|
|
return self.wrap_onspace(\
|
|
wordRegex.sub(\
|
|
lambda m: self.\
|
|
wrap_always(\
|
|
m.group(),width),text\
|
|
),width)
|
|
|
|
def wrap_always(self,text,width):
|
|
return '\n'.join(\
|
|
[ text[width*i:width*(i+1\
|
|
)] for i in xrange(\
|
|
int(math.ceil(1.*len(\
|
|
text)/width))) ])
|
|
|
|
class tableHelper():
|
|
def __init__(self):
|
|
self.oTable = refTable()
|
|
|
|
def getAsRows(self,data):
|
|
return [row.strip().split(',') for row in data.splitlines()]
|
|
|
|
def getTable_noWrap(self,data,header=None):
|
|
rows = self.getAsRows(data)
|
|
if header is not None:hRows = [header]+rows
|
|
else:hRows = rows
|
|
table = self.oTable.wrapTable(hRows, hasHeader=True)
|
|
return table
|
|
|
|
def getTable_Wrap(self,data,wrapStyle,header=None,width=65):
|
|
wrapper = None
|
|
if len(wrapStyle) > 1:
|
|
rows = self.getAsRows(data)
|
|
if header is not None:hRows = [header]+rows
|
|
else:hRows = rows
|
|
|
|
for wrapper in (self.oTable.wrap_always,
|
|
self.oTable.wrap_onspace,
|
|
self.oTable.wrap_onspace_strict):
|
|
return self.oTable.wrapTable(hRows\
|
|
,hasHeader=True\
|
|
,separateRows=True\
|
|
,prefix='| '\
|
|
,postfix=' |'\
|
|
,wrapfunc\
|
|
=lambda x:\
|
|
wrapper(x,width))
|
|
else:
|
|
return self.getTable_noWrap(data,header)
|
|
|
|
def getAsErrorTable(self,err):
|
|
return self.getTable_Wrap(err,None)
|
|
|
|
|
|
class console:
|
|
def __init__(self,prompt,banner=None):
|
|
self.prompt=prompt
|
|
self.banner=banner
|
|
self.commands={}
|
|
self.commandSort=[]
|
|
self.db=None
|
|
|
|
for i in dir(self):
|
|
if "cmd_"==i[:4]:
|
|
cmd=i.split("cmd_")[1].lower()
|
|
self.commands[cmd]=getattr(self,i)
|
|
try:self.commandSort.append((int(self\
|
|
.commands[cmd].__doc__.split(\
|
|
"|")[0]),cmd))
|
|
except:pass
|
|
|
|
self.commandSort.sort()
|
|
self.commandSort=[i[1] for i in self.commandSort]
|
|
|
|
self.var_DEBUG=False
|
|
self.var_tableStyle=''
|
|
|
|
self.configvars={}
|
|
for i in dir(self):
|
|
if "var_"==i[:4]:
|
|
var=i.split("var_")[1]
|
|
self.configvars[var]=i
|
|
|
|
def setBanner(self,banner):
|
|
self.banner=banner
|
|
|
|
def execCmd(self,db):
|
|
self.db=db
|
|
print self.banner
|
|
while True:
|
|
try:
|
|
command=raw_input(self.prompt)
|
|
try:
|
|
self.execCommand(command)
|
|
except:
|
|
self.execute(command)
|
|
except KeyboardInterrupt:break
|
|
except EOFError:break
|
|
except Exception,a:self.printError (a)
|
|
print ("\r\n\r\nBye!...")
|
|
sys.exit(0)
|
|
|
|
def printError(self,err):
|
|
sys.stderr.write("Error: {0}\r\n".format(str(err),))
|
|
if self.var_DEBUG:pass
|
|
|
|
def execute(self,cmd):
|
|
try:
|
|
if not '-table ' in cmd:
|
|
exec '{0}'.format(cmd)
|
|
else:
|
|
file=None
|
|
table=None
|
|
|
|
fields=[]
|
|
items=string.split(cmd,' ')
|
|
invalidParams=[]
|
|
table=self.getTable(items[1])
|
|
allowedParams=['fields','file']
|
|
for i in items:
|
|
if '=' in i and not string.split(i,'=')[0] in allowedParams:
|
|
try:
|
|
invalidParams.append(i)
|
|
except Exception, err:
|
|
raise Exception, 'invalid parameter\n{0}'.format(i)
|
|
else:
|
|
if 'file=' in i:
|
|
file=os.path.abspath(string.strip(string.split(i,'=')[1]))
|
|
if 'fields=' in i:
|
|
for field in string.split(string.split(i,'=')[1],','):
|
|
if field in self.db[table].fields:
|
|
fields.append(string.strip(field))
|
|
|
|
if len(invalidParams)>0:
|
|
print('the following parameter(s) is not valid\n{0}'.format(\
|
|
string.join(invalidParams,',')))
|
|
else:
|
|
try:
|
|
self.cmd_table(table,file,fields)
|
|
except Exception, err:
|
|
print('could not generate table for table {0}\n{1}'\
|
|
.format(table,err))
|
|
except Exception, err:
|
|
print('sorry, can not do that!\n{0}'.format(err))
|
|
|
|
def getTable(self,tbl):
|
|
for mTbl in db.tables:
|
|
if tbl in mTbl:
|
|
if mTbl.startswith(tbl):
|
|
return mTbl
|
|
|
|
def execCommand(self,cmd):
|
|
words=cmd.split(" ")
|
|
words=[i for i in words if i]
|
|
if not words:return
|
|
cmd,parameters=words[0].lower(),words[1:]
|
|
|
|
if not cmd in self.commands:
|
|
raise Exception("Command {0} not found. Try 'help'\r\n".format(cmd))
|
|
|
|
self.commands[cmd](*parameters)
|
|
|
|
'''---
|
|
DEFAULT COMMANDS (begins with cmd_)
|
|
---'''
|
|
def cmd_clear(self,numlines=100):
|
|
"""-5|clear|clear the screen"""
|
|
if os.name == "posix":
|
|
'''---
|
|
Unix/Linux/MacOS/BSD/etc
|
|
---'''
|
|
os.system('clear')
|
|
elif os.name in ("nt", "dos", "ce"):
|
|
'''---
|
|
Windows
|
|
---'''
|
|
os.system('CLS')
|
|
else:
|
|
'''---
|
|
Fallback for other operating systems.
|
|
---'''
|
|
print '\n'*numlines
|
|
|
|
def cmd_table(self,tbl,file=None,fields=[]):
|
|
"""-4|-table [TABLENAME] optional[file=None] [fields=None]|\
|
|
the default tableStyle is no_wrap - use the 'set x y' command to change the style\n\
|
|
style choices:
|
|
\twrap_always
|
|
\twrap_onspace
|
|
\twrap_onspace_strict
|
|
\tno_wrap (value '')\n
|
|
\t the 2nd optional param is a path to a file where the table will be written
|
|
\t the 3rd optional param is a list of fields you want displayed\n"""
|
|
table=None
|
|
for mTbl in db.tables:
|
|
if tbl in mTbl:
|
|
if mTbl.startswith(tbl):
|
|
table=mTbl
|
|
break
|
|
oTable=tableHelper()
|
|
'''---
|
|
tablestyle:
|
|
wrap_always
|
|
wrap_onspace
|
|
wrap_onspace_strict
|
|
or set set to "" for no wrapping
|
|
---'''
|
|
tableStyle=self.var_tableStyle
|
|
filedNotFound=[]
|
|
table_fields=None
|
|
if len(fields)==0:
|
|
table_fields=self.db[table].fields
|
|
else:
|
|
table_fields=fields
|
|
|
|
for field in fields:
|
|
if not field in self.db[table].fields:
|
|
filedNotFound.append(field)
|
|
if len(filedNotFound)==0:
|
|
rows=self.db(self.db[table].id>0).select()
|
|
rows_data=[]
|
|
for row in rows:
|
|
rowdata=[]
|
|
for f in table_fields:
|
|
rowdata.append('{0}'.format(row[f]))
|
|
rows_data.append(string.join(rowdata,','))
|
|
data=string.join(rows_data,'\n')
|
|
dataTable=oTable.getTable_Wrap(data,tableStyle,table_fields)
|
|
print('TABLE {0}\n{1}'.format(table,dataTable))
|
|
if file!=None:
|
|
try:
|
|
tail,head=os.path.split(file)
|
|
try:
|
|
os.makedirs(tail)
|
|
except:'do nothing, folders exist'
|
|
oFile=open(file,'w')
|
|
oFile.write('TABLE: {0}\n{1}'.format(table,dataTable))
|
|
oFile.close()
|
|
print('{0} has been created and populated with all available data from table {1}\n'.format(file,table))
|
|
except Exception, err:
|
|
print("EXCEPTION: could not create table {0}\n{1}".format(table,err))
|
|
else:
|
|
print('the following fields are not valid [{0}]'.format(string.join(filedNotFound,',')))
|
|
|
|
def cmd_help(self,*args):
|
|
'''-3|help|Show's help'''
|
|
alldata=[]
|
|
lengths=[]
|
|
|
|
for i in self.commandSort:alldata.append(\
|
|
self.commands[i].__doc__.split("|")[1:])
|
|
|
|
for i in alldata:
|
|
if len(i) > len(lengths):
|
|
for j in range(len(i)\
|
|
-len(lengths)):
|
|
lengths.append(0)
|
|
|
|
j=0
|
|
while j<len(i):
|
|
if len(i[j])>lengths[j]:
|
|
lengths[j]=len(i[j])
|
|
j+=1
|
|
|
|
print ("-"*(lengths[0]+lengths[1]+4))
|
|
for i in alldata:
|
|
print (("%-"+str(lengths[0])+"s - %-"+str(lengths[1])+"s") % (i[0],i[1]))
|
|
if len(i)>2:
|
|
for j in i[2:]:print (("%"+str(lengths[0]+9)+"s* %s") % (" ",j))
|
|
print
|
|
|
|
def cmd_vars(self,*args):
|
|
'''-2|vars|Show variables'''
|
|
print ("variables\r\n"+"-"*79)
|
|
for i,j in self.configvars.items():
|
|
value=self.parfmt(repr(getattr(self,j)),52)
|
|
print ("| %20s | %52s |" % (i,value[0]))
|
|
for k in value[1:]:print ("| %20s | %52s |" % ("",k))
|
|
if len(value)>1:print("| %20s | %52s |" % ("",""))
|
|
print ("-"*79)
|
|
|
|
def parfmt(self,txt,width):
|
|
res=[]
|
|
pos=0
|
|
while True:
|
|
a=txt[pos:pos+width]
|
|
if not a:break
|
|
res.append(a)
|
|
pos+=width
|
|
return res
|
|
|
|
def cmd_set(self,*args):
|
|
'''-1|set [variable_name] [value]|Set configuration variable value|Values are an expressions (100 | string.lower('ABC') | etc.'''
|
|
value=" ".join(args[1:])
|
|
if args[0] not in self.configvars:
|
|
setattr(self,"var_{0}".format(args[0]),eval(value))
|
|
setattr(self,"var_{0}".format(args[0]),eval(value))
|
|
|
|
def cmd_clearscreen(self,numlines=50):
|
|
'''---Clear the console.
|
|
---'''
|
|
if os.name == "posix":
|
|
'''---
|
|
Unix/Linux/MacOS/BSD/etc
|
|
---'''
|
|
os.system('clear')
|
|
elif os.name in ("nt", "dos", "ce"):
|
|
'''---
|
|
Windows
|
|
---'''
|
|
os.system('CLS')
|
|
else:
|
|
'''---
|
|
Fallback for other operating systems.
|
|
---'''
|
|
print '\n'*numlines
|
|
|
|
class dalShell(console):
|
|
def __init__(self):
|
|
pass
|
|
|
|
def shell(self,db):
|
|
console.__init__(self,prompt=">>> ",banner='dal interactive shell')
|
|
self.execCmd(db)
|
|
|
|
class setCopyDB():
|
|
def __init__(self):
|
|
'''---
|
|
non source or target specific vars
|
|
---'''
|
|
self.strModel=None
|
|
self.dalPath=None
|
|
self.db=None
|
|
'''---
|
|
source vars
|
|
---'''
|
|
self.sourceModel=None
|
|
self.sourceFolder=None
|
|
self.sourceConnectionString=None
|
|
self.sourcedbType=None
|
|
self.sourcedbName=None
|
|
'''---
|
|
target vars
|
|
---'''
|
|
self.targetdbType=None
|
|
self.targetdbName=None
|
|
self.targetModel=None
|
|
self.targetFolder=None
|
|
self.targetConnectionString=None
|
|
self.truncate=False
|
|
|
|
def _getDal(self):
|
|
mDal=None
|
|
if self.dalPath is not None:
|
|
global DAL
|
|
sys.path.append(self.dalPath)
|
|
mDal=__import__('dal',globals={},locals={},fromlist=['DAL'],level=0)
|
|
DAL=mDal.DAL
|
|
return mDal
|
|
|
|
def instDB(self,storageFolder,storageConnectionString,autoImport):
|
|
self.db=DAL(storageConnectionString,folder=os.path.abspath(storageFolder),auto_import=autoImport)
|
|
return self.db
|
|
|
|
def delete_DB_tables(self,storageFolder,storageType):
|
|
print 'delete_DB_tablesn\n\t{0}\n\t{1}'.format(storageFolder,storageType)
|
|
dataFiles=[storageType,"sql.log"]
|
|
try:
|
|
for f in os.listdir(storageFolder):
|
|
if ".table" in f:
|
|
fTable="{0}/{1}".format(storageFolder,f)
|
|
os.remove(fTable)
|
|
print('deleted {0}'.format(fTable))
|
|
for dFile in dataFiles:
|
|
os.remove("{0}/{1}".format(storageFolder,dFile))
|
|
print('deleted {0}'.format("{0}/{1}".format(storageFolder,dFile)))
|
|
except Exception, errObj:
|
|
print(str(errObj))
|
|
|
|
def truncatetables(self,tables=[]):
|
|
if len(tables)!=0:
|
|
try:
|
|
print 'table value: {0}'.format(tables)
|
|
for tbl in self.db.tables:
|
|
for mTbl in tables:
|
|
if mTbl.startswith(tbl):
|
|
self.db[mTbl].truncate()
|
|
except Exception, err:
|
|
print('EXCEPTION: {0}'.format(err))
|
|
else:
|
|
try:
|
|
for tbl in self.db.tables:
|
|
self.db[tbl].truncate()
|
|
except Exception, err:
|
|
print('EXCEPTION: {0}'.format(err))
|
|
|
|
def copyDB(self):
|
|
other_db=DAL("{0}://{1}".format(self.targetdbType,self.targetdbName),folder=self.targetFolder)
|
|
|
|
print 'creating tables...'
|
|
|
|
for table in self.db:
|
|
other_db.define_table(table._tablename,*[field for field in table])
|
|
'''
|
|
should there be an option to truncAte target DB?
|
|
if yes, then change args to allow for choice
|
|
and set self.trancate to the art value
|
|
|
|
if self.truncate==True:
|
|
other_db[table._tablename].truncate()
|
|
'''
|
|
|
|
print 'exporting data...'
|
|
self.db.export_to_csv_file(open('tmp.sql','wb'))
|
|
|
|
print 'importing data...'
|
|
other_db.import_from_csv_file(open('tmp.sql','rb'))
|
|
other_db.commit()
|
|
print 'done!'
|
|
print 'Attention: do not run this program again or you end up with duplicate records'
|
|
|
|
def createfolderPath(self,folder):
|
|
try:
|
|
if folder!=None:os.makedirs(folder)
|
|
except Exception, err:
|
|
pass
|
|
|
|
if __name__ == '__main__':
|
|
oCopy=setCopyDB()
|
|
db=None
|
|
targetDB=None
|
|
dbfolder=None
|
|
clean=False
|
|
model=None
|
|
truncate=False
|
|
|
|
parser=argparse.ArgumentParser(description='\
|
|
samplecmd line:\n\
|
|
-f ./blueLite/db_storage -i -y sqlite://storage.sqlite -Y sqlite://storage2.sqlite -d ./blueLite/pyUtils/sql/blueSQL -t True',
|
|
epilog = '')
|
|
reqGroup=parser.add_argument_group('Required arguments')
|
|
reqGroup.add_argument('-f','--sourceFolder'\
|
|
,required=True\
|
|
,help="path to the 'source' folder of the 'source' DB")
|
|
reqGroup.add_argument('-F','--targetFolder'\
|
|
,required=False\
|
|
,help="path to the 'target' folder of the 'target' DB")
|
|
reqGroup.add_argument('-y','--sourceConnectionString'\
|
|
,required=True\
|
|
,help="source db connection string ()\n\
|
|
------------------------------------------------\n\
|
|
\
|
|
sqlite://storage.db\n\
|
|
mysql://username:password@localhost/test\n\
|
|
postgres://username:password@localhost/test\n\
|
|
mssql://username:password@localhost/test\n\
|
|
firebird://username:password@localhost/test\n\
|
|
oracle://username/password@test\n\
|
|
db2://username:password@test\n\
|
|
ingres://username:password@localhost/test\n\
|
|
informix://username:password@test\n\
|
|
\
|
|
------------------------------------------------")
|
|
reqGroup.add_argument('-Y','--targetConnectionString'\
|
|
,required=True\
|
|
,help="target db type (sqlite,mySql,etc.)")
|
|
autoImpGroup=parser.add_argument_group('optional args (auto_import)')
|
|
autoImpGroup.add_argument('-a','--autoimport'\
|
|
,required=False\
|
|
,help='set to True to bypass loading of the model')
|
|
|
|
"""
|
|
|
|
*** removing -m/-M options for now --> i need a
|
|
better regex to match db.define('bla')...with optional db.commit()
|
|
|
|
modelGroup=parser.add_argument_group('optional args (create model)')
|
|
modelGroup.add_argument('-m','--sourcemodel'\
|
|
,required=False\
|
|
,help='to create a model from an existing model, point to the source model')
|
|
modelGroup.add_argument('-M','--targetmodel'\
|
|
,required=False\
|
|
,help='to create a model from an existing model, point to the target model')
|
|
|
|
"""
|
|
|
|
|
|
miscGroup=parser.add_argument_group('optional args/tasks')
|
|
miscGroup.add_argument('-i','--interactive'\
|
|
,required=False\
|
|
,action='store_true'\
|
|
,help='run in interactive mode')
|
|
miscGroup.add_argument('-d','--dal'\
|
|
,required=False\
|
|
,help='path to dal.py')
|
|
miscGroup.add_argument('-t','--truncate'\
|
|
,choices=['True','False']\
|
|
,help='delete the records but *not* the table of the SOURCE DB')
|
|
miscGroup.add_argument('-b','--tables'\
|
|
,required=False\
|
|
,type=list\
|
|
,help='optional list (comma delimited) of SOURCE tables to truncate, defaults to all')
|
|
miscGroup.add_argument('-c','--clean'\
|
|
,required=False\
|
|
,help='delete the DB,tables and the log file, WARNING: this is unrecoverable')
|
|
|
|
args=parser.parse_args()
|
|
db=None
|
|
mDal=None
|
|
|
|
try:
|
|
oCopy.sourceFolder=args.sourceFolder
|
|
oCopy.targetFolder=args.sourceFolder
|
|
sourceItems=string.split(args.sourceConnectionString,'://')
|
|
oCopy.sourcedbType=sourceItems[0]
|
|
oCopy.sourcedbName=sourceItems[1]
|
|
targetItems=string.split(args.targetConnectionString,'://')
|
|
oCopy.targetdbType=targetItems[0]
|
|
oCopy.targetdbName=targetItems[1]
|
|
except Exception, err:
|
|
print('EXCEPTION: {0}'.format(err))
|
|
|
|
if args.dal:
|
|
try:
|
|
autoImport=True
|
|
if args.autoimport:autoImport=args.autoimport
|
|
#sif not DAL in globals:
|
|
#if not sys.path.__contains__():
|
|
oCopy.dalPath=args.dal
|
|
mDal=oCopy._getDal()
|
|
db=oCopy.instDB(args.sourceFolder,args.sourceConnectionString,autoImport)
|
|
except Exception, err:
|
|
print('EXCEPTION: could not set DAL\n{0}'.format(err))
|
|
if args.truncate:
|
|
try:
|
|
if args.truncate:
|
|
if args.tables:tables=string.split(string.strip(args.tables),',')
|
|
else:oCopy.truncatetables([])
|
|
except Exception, err:
|
|
print('EXCEPTION: could not truncate tables\n{0}'.format(err))
|
|
try:
|
|
if args.clean:oCopy.delete_DB_tables(oCopy.targetFolder,oCopy.targetType)
|
|
except Exception, err:
|
|
print('EXCEPTION: could not clean db\n{0}'.format(err))
|
|
|
|
|
|
"""
|
|
*** goes with -m/-M options... removed for now
|
|
|
|
if args.sourcemodel:
|
|
try:
|
|
oCopy.sourceModel=args.sourcemodel
|
|
oCopy.targetModel=args.sourcemodel
|
|
oCopy.createModel()
|
|
except Exception, err:
|
|
print('EXCEPTION: could not create model\n\
|
|
source model: {0}\n\
|
|
target model: {1}\n\
|
|
{2}'.format(args.sourcemodel,args.targetmodel,err))
|
|
"""
|
|
|
|
if args.sourceFolder:
|
|
try:
|
|
oCopy.sourceFolder=os.path.abspath(args.sourceFolder)
|
|
oCopy.createfolderPath(oCopy.sourceFolder)
|
|
except Exception, err:
|
|
print('EXCEPTION: could not create folder path\n{0}'.format(err))
|
|
else:oCopy.dbStorageFolder=os.path.abspath(os.getcwd())
|
|
if args.targetFolder:
|
|
try:
|
|
oCopy.targetFolder=os.path.abspath(args.targetFolder)
|
|
oCopy.createfolderPath(oCopy.targetFolder)
|
|
except Exception, err:
|
|
print('EXCEPTION: could not create folder path\n{0}'.format(err))
|
|
if not args.interactive:
|
|
try:
|
|
oCopy.copyDB()
|
|
except Exception, err:
|
|
print('EXCEPTION: could not make a copy of the database\n{0}'.format(err))
|
|
else:
|
|
s=dalShell()
|
|
s.shell(db)
|