def __init__(self): Script.__init__(self, "open") self.loader = loader.loader() self.cm = ConfigManager.Get() self.vtreeprinter = VariantTreePrinter() self.lmodules = self.loader.modules self.taskmanager = TaskManager()
class Open(Script):
def __init__(self):
Script.__init__(self, "open")
self.loader = loader.loader()
self.cm = ConfigManager.Get()
self.vtreeprinter = VariantTreePrinter()
self.lmodules = self.loader.modules
self.taskmanager = TaskManager()
def start(self, args):
node = args["file"].value()
self.open(node)
def open(self, node):
try:
mod = node.compatibleModules()[0]
conf = self.cm.configByName(mod)
argsnode = conf.argumentsByFlags(typeId.Node|Argument.Required)
if len(argsnode) == 1:
argnode = argsnode[0]
margs = {argnode.name(): node}
args = conf.generate(margs)
self.taskmanager.add(mod, args, ["thread", "gui"])
else:
print "There are more than 1 file to provides"
print "applying module " + mod + " on " + node.absolute()
except IndexError:
typeattr = node.attributesByName("type")
print type(typeattr)
if typeattr != None:
if typeattr.type() == typeId.Map:
res = self.vtreeprinter.fillMap(1, typeattr.value())
print "No module registered to handle following types " + res
elif typeattr.type() == typeId.List:
res = self.vtreeprinter.fillList(1, typeattr.value())
print "No module registered to handle following types " + res
elif typeattr.type() == typeId.Node:
print "No module registered to handle node " + str(typeattr.value().absolute())
else:
print "No module registered to handle " + str(typeattr.toString())
else:
print "No type attributes setted for node " + str(node.absolute())
class FG(Script):
def __init__(self):
Script.__init__(self, "fg")
self.tm = TaskManager()
self.vtreeprinter = VariantTreePrinter()
def start(self, args):
self.lprocessus = self.tm.lprocessus
jobs = args["pid"].value()
for proc in self.lprocessus:
if jobs == proc.pid:
print "Displaying processus: " + str(proc.pid) + " name: " + str(proc.name) + " state: " + str(proc.state) + "\n"
try :
text = self.lprocessus[jobs].stream.get(0)
while text:
print text
text = self.lprocessus[jobs].stream.get(0)
except Empty:
pass
print self.vtreeprinter.fillMap(0, proc.res)
def __init__(self, mod, pid, args, exec_flags): self.vfs = vfs.vfs() self.mod = mod self.inst = mod.create() self.exec_flags = exec_flags self.state = "wait" self.pid = pid self.args = args self.stream = Queue() self.event = threading.Event() self.vtreeprinter = VariantTreePrinter() self.timestart = 0 self.timeend = 0 self.streamOut = None
def __init__(self):
Script.__init__(self, "show_db")
self.cm = ConfigManager.Get()
self.tm = TaskManager()
self.ti = typeId.Get()
self.vtreeprinter = VariantTreePrinter()
class SHOW_DB(Script):
def __init__(self):
Script.__init__(self, "show_db")
self.cm = ConfigManager.Get()
self.tm = TaskManager()
self.ti = typeId.Get()
self.vtreeprinter = VariantTreePrinter()
def processesByModuleName(self, modname):
processes = []
for proc in self.tm.lprocessus:
if proc.name == modname:
processes.append(proc)
return processes
def keyInConfigArguments(self, config, key):
res = ""
argument = config.argumentByName(key)
if argument:
if argument.type() == 0:
res += "\n\targument switch"
else:
res += "\n\t\targument of type < " + self.ti.typeToName(argument.type()) + " >"
count = argument.parametersCount()
if count:
res += "\n\t\tpredefined parameters: "
parameters = argument.parameters()
for parameter in parameters:
if argument.type() == typeId.Node:
res += str(parameter.value().absolute())
else:
res += str(parameter.toString())
count -= 1
if count:
res += ", "
return res
def keyInConfigConstants(self, config, key):
res = ""
constant = config.constantByName(key)
if constant:
res += "\n\t\tconstant of type < " + self.ti.typeToName(constant.type()) + " >"
items = constant.values()
count = len(items)
res += "\n\t\tdefined constants: "
for item in items:
if constant.type() == typeId.Node:
res += str(item.value().absolute())
else:
res += str(item.toString())
count -= 1
if count:
res += ", "
return res
def keyInProcessArguments(self, processes, key):
res = ""
for proc in processes:
if proc.args.has_key(key):
res += "\n\t\tparameters provided to process id " + str(proc.pid) + ":\n\t\t\t"
arg = proc.args[key]
if arg.type() == typeId.List:
vlist = arg.value()
lenvlist = len(vlist)
for item in vlist:
lenvlist -= 1
if item.type() == typeId.Node:
res += str(item.value().absolute())
else:
res += str(item.toString())
if lenvlist:
res += ", "
elif arg.type() == typeId.Node:
res += str(arg.value().absolute())
else:
res += str(arg.toString())
return res
def keyInVMap(self, vmap, key):
res = ""
for ikey in vmap.keys():
vval = vmap[ikey]
if vval.type() == typeId.Map:
res += self.keyInVMap(vval.value(), key)
elif vval.type() == typeId.List:
res += self.keyInVList(vval.value(), key)
elif ikey == key:
if vval.type() == typeId.Node:
res += "\n\t\t\t" + str(vval.value().absolute())
elif vval.type() == typeId.List:
res += self.vtreeprinter.fillList(3, vval.value())
elif vval.type() == typeId.Map:
res += self.vtreeprinter.fillMap(3, vval.value())
else:
res += "\n\t\t\t" + str(vval.toString())
res += " (type < " + self.ti.typeToName(vval.type()) + " >)"
return res
def keyInVList(self, vlist, key):
res = ""
for item in vlist:
if item.type() == typeId.Map:
res += self.keyInVMap(item.value(), key)
elif item.type() == typeId.List:
res += self.keyInVList(item.value(), key)
return res
def keyInProcessResults(self, processes, key):
res = ""
for proc in processes:
match = ""
if len(proc.res):
results = proc.res
for ikey in results.keys():
item = results[ikey]
if ikey == key:
if item.type() == typeId.Node:
match += "\n\t\t\t" + str(item.value().absolute())
elif item.type() == typeId.List:
match += self.vtreeprinter.fillList(3, item.value())
elif item.type() == typeId.Map:
match += self.vtreeprinter.fillMap(3, item.value())
else:
match += "\n\t\t\t" + str(item.toString())
match += " (type < " + self.ti.typeToName(item.type()) + " >)"
elif item.type() == typeId.Map:
match += self.keyInVMap(item.value(), key)
elif item.type() == typeId.List:
match += self.keyInVList(item.value(), key)
if match:
res += "\n\t\tresults of process id " + str(proc.pid) + ":"
res += match
return res
def get_dbinfo(self, key):
res = ""
configs = self.cm.configs()
for config in configs:
if config.origin() != "show_db":
processes = self.processesByModuleName(config.origin())
match = self.keyInConfigArguments(config, key)
if match:
res += "\n\tmodule: " + config.origin()
res += match
res += self.keyInProcessArguments(processes, key)
match = self.keyInConfigConstants(config, key)
if match:
res += "\n\tmodule: " + config.origin()
res += match
match = self.keyInProcessResults(processes, key)
if match:
res += "\n\tmodule: " + config.origin()
res += match
return res
def fillProcessArgumentsKeys(self, keymap):
for proc in self.tm.lprocessus:
args = proc.args
if args and proc.name != "show_db":
for key in args.keys():
if not keymap.has_key(key):
keymap[key] = []
arg = args[key]
if arg.type() == 0:
res = "\n\tswitch argument"
else:
res = "\n\targument of type " + self.ti.typeToName(arg.type())
res += " from " + proc.mod.conf.origin() + " in processus " + str(proc.pid)
if arg.type() == typeId.List:
res += "\n\t\t"
vlist = arg.value()
lenvlist = len(vlist)
for item in vlist:
lenvlist -= 1
if item.type() == typeId.Node:
res += str(item.value().absolute())
else:
res += str(item.toString())
if lenvlist:
res += ", "
elif arg.type() == typeId.Node:
res += "\n\t\t"
res += str(arg.value().absolute())
elif arg.type() != 0:
res += "\n\t\t"
res += str(arg.toString())
keymap[key].append(res)
return keymap
def fillKeyInList(self, vlist, keymap, cname, pid):
for item in vlist:
if item.type() == typeId.Map:
keymap = self.fillKeyInMap(item.value(), keymap, cname, pid)
return keymap
def fillKeyInMap(self, vmap, keymap, cname, pid):
for key in vmap.keys():
if not keymap.has_key(key):
keymap[key] = []
val = vmap[key]
if val.type() == typeId.List:
res = "\n\tresult of type " + self.ti.typeToName(val.type())
res += " from " + cname + " in processus " + str(pid)
keymap[key].append(res)
keymap = self.fillKeyInList(val.value(), keymap, cname, pid)
elif val.type() == typeId.Map:
res = "\n\tresult of type " + self.ti.typeToName(val.type())
res += " from " + cname + " in processus " + str(pid)
keymap[key].append(res)
keymap = self.fillKeyInMap(val.value(), keymap, cname, pid)
else:
res = "\n\tresult of type " + self.ti.typeToName(val.type())
res += " from " + cname + " in processus " + str(pid)
if val.type() == typeId.Node:
res += "\n\t\t" + str(val.value().absolute())
else:
res += "\n\t\t" + val.toString()
keymap[key].append(res)
return keymap
def fillProcessResultsKeys(self, keymap):
for proc in self.tm.lprocessus:
results = proc.res
if results and proc.name != "show_db":
for key in results.keys():
if not keymap.has_key(key):
keymap[key] = []
item = results[key]
res = "\n\tresult of type " + self.ti.typeToName(item.type())
res += " from " + proc.mod.conf.origin() + " in processus " + str(proc.pid)
if item.type() == typeId.Node:
res += "\n\t\t" + str(item.value().absolute())
keymap[key].append(res)
elif item.type() == typeId.List:
keymap[key].append(res)
keymap = self.fillKeyInList(item.value(), keymap, proc.mod.conf.origin(), proc.pid)
elif item.type() == typeId.Map:
keymap[key].append(res)
keymap = self.fillKeyInMap(item.value(), keymap, proc.mod.conf.origin(), proc.pid)
else:
res += "\n\t\t" + str(item.toString())
keymap[key].append(res)
return keymap
def fillAllArgumentsKey(self, keymap):
configs = self.cm.configs()
for config in configs:
if config.origin() != "show_db":
arguments = config.arguments()
for argument in arguments:
argname = argument.name()
if not keymap.has_key(argname):
keymap[argname] = []
if argument.type() == 0:
stres = "\n\tswitch argument"
else:
stres = "\n\targument of type " + self.ti.typeToName(argument.type())
stres += " from " + config.origin()
pcount = argument.parametersCount()
if pcount != 0:
parameters = argument.parameters()
stres += "\n\t\t"
for parameter in parameters:
if argument.type() == typeId.Node:
stres += str(parameter.value().absolute())
else:
stres += parameter.toString()
pcount -= 1
if pcount != 0:
stres += ", "
keymap[argname].append(stres)
return keymap
def fillAllConstantsKey(self, keymap):
configs = self.cm.configs()
for config in configs:
if config.origin() != "show_db":
constants = config.constants()
for constant in constants:
cname = constant.name()
if not keymap.has_key(cname):
keymap[cname] = []
stres = "\n\tconstant of type " + self.ti.typeToName(constant.type()) + " from " + config.origin()
items = constant.values()
pcount = len(items)
stres += "\n\t\t"
for item in items:
if item.type() == typeId.Node:
stres += str(item.value().absolute())
else:
stres += item.toString()
pcount -= 1
if pcount != 0:
stres += ", "
keymap[cname].append(stres)
return keymap
def get_alldbinfo(self):
keymap = {}
keymap = self.fillAllArgumentsKey(keymap)
keymap = self.fillAllConstantsKey(keymap)
keymap = self.fillProcessArgumentsKeys(keymap)
keymap = self.fillProcessResultsKeys(keymap)
res = ""
for key in keymap.keys():
res += "\n\n" + key
for item in keymap[key]:
res += item
return res
def start(self, args):
res = "Variable DB\n"
if args.has_key("key"):
key = args["key"].value()
res += "key <" + key + ">"
match = self.get_dbinfo(key)
if match:
res += match
else:
res += " not found in db"
else:
res += self.get_alldbinfo()
print res
class Processus(Script):
def __init__(self, mod, pid, args, exec_flags):
self.vfs = vfs.vfs()
self.mod = mod
self.inst = mod.create()
self.exec_flags = exec_flags
self.state = "wait"
self.pid = pid
self.args = args
self.stream = Queue()
self.event = threading.Event()
self.vtreeprinter = VariantTreePrinter()
self.timestart = 0
self.timeend = 0
self.streamOut = None
def launch(self, args):
self.state = "exec"
self.timestart = time.time()
try :
self.args = args
args.thisown = False
self.start(args)
try :
if "gui" in self.exec_flags:
if "gui" in self.mod.flags:
for func in sched.event_func["add_qwidget"]:
func(self)
if "console" in self.exec_flags:
if "console" in self.mod.flags:
self.c_display()
except AttributeError:
pass
except :
error = sys.exc_info()
self.error(error)
self.error()
self.event.set()
if not "thread" in self.exec_flags:
self.result()
def result(self):
if self.res and len(self.res):
buff = self.vtreeprinter.fillMap(0, self.res)
print buff
def error(self, trace = None):
if trace:
err_type, err_value, err_traceback = trace
res = "\n\nWhat:\n"
res += "----------\n"
err_typeval = traceback.format_exception_only(err_type, err_value)
for err in err_typeval:
res += err
res += "\nWhere:\n"
res += "-----------\n"
err_trace = traceback.format_tb(err_traceback)
for err in err_trace:
res += err
print res
verr = Variant(res)
verr.thisown = False
self.res["error"] = verr
self.state = "fail"
return
if "gui" in self.exec_flags and "gui" in self.mod.flags:
self.state = "wait"
else:
self.timeend = time.time()
self.state = "finish"
def __getattr__(self, attr):
return getattr(self.inst, attr)
def __init__(self): Script.__init__(self, "info") VariantTreePrinter.__init__(self) self.loader = loader.loader() self.tm = TaskManager() self.cm = ConfigManager.Get()
def __init__(self):
Script.__init__(self, "fileinfo")
self.vtreeprinter = VariantTreePrinter()
class FILEINFO(Script):
def __init__(self):
Script.__init__(self, "fileinfo")
self.vtreeprinter = VariantTreePrinter()
def start(self, args):
buff = ""
node = args["file"].value()
if args.has_key("max-items"):
self.vtreeprinter.setMaxItemListToExpand(args["max-items"].value())
else:
self.vtreeprinter.setMaxItemListToExpand(-1)
if args.has_key("max-depth"):
self.vtreeprinter.setMaxDepth(args["max-depth"].value())
else:
self.vtreeprinter.setMaxDepth(-1)
buff += self.fillBase(node)
buff += self.fillAttributes(node)
vbuff = Variant(buff)
vbuff.thisown = False
self.res["result"] = vbuff
def fillBase(self, node):
buff = ""
fsobj = node.fsobj()
fsobjname = ""
if fsobj != None:
fsobjname = fsobj.name
buff += "name :\t\t" + str(node.name()) + "\n"
buff += "node type :\t\t"
if node.isFile():
buff += "file"
if node.hasChildren():
buff += " " + "with module(s) applied on it"
if node.isDir():
buff += "folder"
if not node.hasChildren():
buff += " " + "empty"
if node.isDeleted():
buff += " " + "deleted"
buff += "\n"
buff += self.fillCompatModule(node)
if node.hasChildren():
buff += self.fillChildren(node)
buff += "generated by:\t\t"
buff += fsobjname + "\n"
buff += "size:\t\t\t"
buff += str(node.size())
buff += "\n"
return buff
def fillCompatModule(self, node):
buff = ""
l = node.compatibleModules()
if len(l) > 0:
buff += "relevant module(s) :\t"
for i in l:
buff += str(i) + " "
buff += "\n"
return buff
def fillChildren(self, node):
buff = "children\t\t"
children = node.children()
filessize = 0
filecount = 0
dircount = 0
for child in children:
if child.size():
filessize += child.size()
filecount += 1
elif child.isDir() or child.hasChildren():
dircount += 1
if filecount > 0:
buff += "file(s)"
buff += str(filecount) + " totalizing " + str(filessize) + " bytes\n"
if dircount > 0:
buff += "folder(s) "
buff += str(dircount) + "\n"
return buff
def fillAttributes(self, node):
buff = ""
vmap = node.attributes()
if len(vmap) > 0:
buff = self.vtreeprinter.fillMap(1, vmap, "attributes:\n")
return buff
def __init__(self): Script.__init__(self, "fg") self.tm = TaskManager() self.vtreeprinter = VariantTreePrinter()
