def Main():
cgiEnv = lib_common.ScriptEnvironment(can_process_remote=True)
entity_host = cgiEnv.GetHost()
logging.debug("entity_host=%s", entity_host)
entity_host = lib_wmi.NormalHostName(entity_host)
cimom_url = entity_host
logging.debug("cimom_url=%s", cimom_url)
grph = cgiEnv.GetGraph()
# There is no consensus on the WMI class for namespaces,
# so we have ours which must be correctly mapped.
namespace_class = "wmi_namespace"
# root_node = lib_util.EntityUri(namespace_class,"")
root_node = lib_util.EntityUri(namespace_class)
for nskey in _hardcoded_namespaces:
# _sub_namespace( root_node, grph, nskey )
try: # "root\\" +
# _sub_namespace( root_node, grph, nskey, cimom_url )
_sub_namespace(root_node, grph, nskey, cimom_url)
except Exception as exc:
lib_common.ErrorMessageHtml("namespaces_wmi.py cimom_url=%s nskey=%s Caught:%s" % ( cimom_url, nskey , str(exc) ) )
cgiEnv.OutCgiRdf("LAYOUT_RECT", [pc.property_cim_subnamespace])
def Main():
cgiEnv = lib_common.ScriptEnvironment(can_process_remote=True)
cimom_url = cgiEnv.GetHost()
grph = cgiEnv.GetGraph()
# There is no consensus on the WBEM class for namespaces,
# so we have ours which must be correctly mapped.
namespace_class = "wbem_namespace"
root_node = lib_util.EntityUri(namespace_class, "")
try:
conn_wbem = lib_wbem.WbemConnection(cimom_url)
nsd = lib_wbem.EnumNamespacesCapabilities(conn_wbem)
except Exception as exc:
lib_common.ErrorMessageHtml("Namespaces from :" + cimom_url +
" Caught:" + str(exc))
# TODO: We should draw a namespaces tree but more examples needed.
for nskey in nsd:
cnt = nsd[nskey]
wbem_url = lib_wbem.NamespaceUrl(nskey, cimom_url)
wbem_node = lib_common.NodeUrl(wbem_url)
grph.add((root_node, pc.property_cim_subnamespace, wbem_node))
grph.add(
(wbem_node, pc.property_information, lib_util.NodeLiteral(nskey)))
grph.add(
(wbem_node, pc.property_information, lib_util.NodeLiteral(cnt)))
cgiEnv.OutCgiRdf("LAYOUT_RECT")
def Main():
cgiEnv = lib_common.ScriptEnvironment()
entity_type = "dbus/connection"
Main.busAddr = cgiEnv.m_entity_id_dict["Bus"]
Main.connectName = cgiEnv.m_entity_id_dict["Connect"]
try:
Main.theBus = lib_dbus.MakeBusFromAddress(Main.busAddr)
except Exception as exc:
lib_common.ErrorMessageHtml("busAddr=%s Caught:%s" % (Main.busAddr, str(exc)))
connectNode = lib_util.EntityUri(entity_type, Main.busAddr, Main.connectName)
grph = cgiEnv.GetGraph()
Main.localPropDbusPath = lib_util.NodeLiteral("dbus-path")
try:
_recursive_obj_walk(grph, "/", connectNode)
except dbus.exceptions.DBusException as exc:
lib_common.ErrorMessageHtml("Caught DBusException busAddr=%s %s" % (Main.busAddr, str(exc)))
except dbus.proxies as exc:
lib_common.ErrorMessageHtml("Caught proxies busAddr=%s %s" % (Main. busAddr, str(exc)))
cgiEnv.OutCgiRdf()
def GetConnectNode(busAddr, connectName):
try:
return Main.connectNameToNode[connectName]
except KeyError:
connectNode = lib_util.EntityUri("dbus/connection", busAddr,
connectName)
Main.connectNameToNode[connectName] = connectNode
return connectNode
def Main():
cgiEnv = lib_common.ScriptEnvironment()
grph = cgiEnv.GetGraph()
listBuses = ["system", "session"]
for busName in listBuses:
uriBus = lib_util.EntityUri("dbus/bus", busName)
grph.add((lib_common.nodeMachine, lib_common.MakeProp("DBus"), uriBus))
cgiEnv.OutCgiRdf()
def Main():
cgiEnv = lib_common.ScriptEnvironment()
fname = cgiEnv.GetId()
grph = cgiEnv.GetGraph()
fname_mystery_node = lib_uris.gUriGen.ComTypeLibUri(fname)
# TODO: Difficulty, many entries.
HLITypeKinds = {
pythoncom.TKIND_ENUM : 'Enumeration',
pythoncom.TKIND_RECORD : 'Record',
pythoncom.TKIND_MODULE : 'Module',
pythoncom.TKIND_INTERFACE : 'Interface',
pythoncom.TKIND_DISPATCH : 'Dispatch',
pythoncom.TKIND_COCLASS : 'CoClass',
pythoncom.TKIND_ALIAS : 'Alias',
pythoncom.TKIND_UNION : 'Union'
}
try:
tlb = pythoncom.LoadTypeLib(fname)
except pythoncom.com_error:
lib_common.ErrorMessageHtml("Cannot load:" + fname)
for idx in range(tlb.GetTypeInfoCount()):
try:
info_typ = tlb.GetTypeInfoType(idx)
typ_nam = HLITypeKinds[info_typ]
sub_entity_type = lib_util.ComposeTypes("com", "type_lib_entry", typ_nam.lower())
name_com_entry_uri = "%s_(%d)" % (fname, idx)
# TODO: Maybe this will be cleaner. Quick and dirty solution for the moment.
# UriNodeCreatorName = "ComTypeLibEntry" + typ_nam + "Uri"
# funcCreate = getattr( lib_common, UriNodeCreatorName )
# entry_node = funcCreate( "%s_(%d)" % ( fname, idx ) )
entry_node = lib_util.EntityUri(sub_entity_type, name_com_entry_uri)
name, doc, ctx, helpFile = tlb.GetDocumentation(idx)
grph.add((entry_node, pc.property_information, lib_util.NodeLiteral("name=%s" % name)))
grph.add((entry_node, pc.property_information, lib_util.NodeLiteral("type=%s" % typ_nam)))
grph.add((fname_mystery_node, pc.property_com_entry, entry_node))
except pythoncom.com_error as exc:
lib_common.ErrorMessageHtml("Caught:" + exc)
cgiEnv.OutCgiRdf("LAYOUT_RECT")
def Main():
cgiEnv = lib_common.CgiEnv(can_process_remote = True)
# See differences and similarities between these.
# entity_host = cgiEnv.GetHost()
# entity_host = cgiEnv.GetParameters("xid")
entity_host = cgiEnv.GetHost()
sys.stderr.write("entity_host=%s\n" % entity_host)
entity_host = lib_wmi.NormalHostName(entity_host)
cimomUrl = entity_host
sys.stderr.write("namespaces_wmi.py cimomUrl=%s\n" % cimomUrl)
grph = cgiEnv.GetGraph()
# There is no consensus on the WMI class for namespaces,
# so we have ours which must be correctly mapped.
namespace_class = "wmi_namespace"
rootNode = lib_util.EntityUri(namespace_class,"")
########## test seulement
# Unexpected COM Error (-2147023174, 'The RPC server is unavailable.', None, None)
# Erreur possible si on se connecte a l adresse courante:
# 'SWbemLocator', u'User credentials cannot be used for local connections '
# http://timgolden.me.uk/python/wmi/tutorial.html
# connWMI = lib_wmi.WmiConnect(cimomUrl,"Microsoft")
# connWMI = wmi.WMI("192.168.1.67",user="******", password="******") # The RPC server is unavailable
# connWMI = wmi.WMI("192.168.1.78",user="******", password="******") # The RPC server is unavailable
# c = wmi.WMI(namespace="WMI")
#
# c = wmi.WMI("MachineB", user=r"MachineB\fred", password="******")
for nskey in hardcodedNamespaces:
# SubNamespace( rootNode, grph, nskey )
try: # "root\\" +
# SubNamespace( rootNode, grph, nskey, cimomUrl )
SubNamespace( rootNode, grph, nskey, cimomUrl )
#except wmi.x_wmi:
# exc = sys.exc_info()[1]
# lib_common.ErrorMessageHtml("EXCEPT WMI nskey=%s Caught:%s" % ( nskey , str(exc) ) )
except Exception:
exc = sys.exc_info()[1]
lib_common.ErrorMessageHtml("namespaces_wmi.py cimomUrl=%s nskey=%s Caught:%s" % ( cimomUrl, nskey , str(exc) ) )
cgiEnv.OutCgiRdf("LAYOUT_RECT", [pc.property_cim_subnamespace])
def Main():
cgiEnv = lib_common.CgiEnv()
busAddr = cgiEnv.GetId()
grph = cgiEnv.GetGraph()
try:
theBus = lib_dbus.MakeBusFromAddress(busAddr)
except Exception:
exc = sys.exc_info()[1]
lib_common.ErrorMessageHtml("busAddr=%s Caught:%s" %
(busAddr, str(exc)))
nodeBus = lib_util.EntityUri("dbus/bus", busAddr)
# This property should maybe stored at the central file.
localPropDbusConnect = lib_common.MakeProp("dbus connect")
localPropDbusWellKnown = lib_common.MakeProp("well known")
Main.connectNameToNode = dict()
def GetConnectNode(busAddr, connectName):
try:
return Main.connectNameToNode[connectName]
except KeyError:
connectNode = lib_util.EntityUri("dbus/connection", busAddr,
connectName)
Main.connectNameToNode[connectName] = connectNode
return connectNode
for connectName in theBus.list_names():
connectNode = GetConnectNode(busAddr, connectName)
try:
ownrNam = theBus.get_name_owner(connectName)
sys.stderr.write("connectName=%s ownr=%s\n" %
(connectName, ownrNam))
if connectName != ownrNam:
ownrNode = GetConnectNode(busAddr, ownrNam)
sys.stderr.write("TO CONNECT %s\n" % (connectName))
# TODO: BUG, Display does not work if "Well Known" property.
# grph.add( (ownrNode, localPropDbusWellKnown, connectNode ) )
grph.add((ownrNode, localPropDbusConnect, connectNode))
except ValueError:
sys.stderr.write("22 CONNECT %s\n" % (connectName))
grph.add((nodeBus, localPropDbusConnect, connectNode))
# TODO: The ordering is: 1.1,1.11,1.2, so we should have a special sort function.
cgiEnv.OutCgiRdf("LAYOUT_RECT",
[localPropDbusConnect, localPropDbusWellKnown])
def Main():
cgiEnv = lib_common.ScriptEnvironment()
bus_addr = cgiEnv.GetId()
grph = cgiEnv.GetGraph()
try:
the_bus = lib_dbus.MakeBusFromAddress(bus_addr)
except Exception as exc:
lib_common.ErrorMessageHtml("bus_addr=%s Caught:%s" %
(bus_addr, str(exc)))
node_bus = lib_util.EntityUri("dbus/bus", bus_addr)
# This property should maybe stored at the central file.
local_prop_dbus_connect = lib_common.MakeProp("dbus connect")
local_prop_dbus_well_known = lib_common.MakeProp("well known")
Main.connectNameToNode = dict()
def get_connect_node(bus_addr, connect_name):
try:
return Main.connectNameToNode[connect_name]
except KeyError:
connectNode = lib_util.EntityUri("dbus/connection", bus_addr,
connect_name)
Main.connectNameToNode[connect_name] = connectNode
return connectNode
for connect_name in the_bus.list_names():
connect_node = get_connect_node(bus_addr, connect_name)
try:
ownr_nam = the_bus.get_name_owner(connect_name)
logging.debug("connect_name=%s ownr=%s", connect_name, ownr_nam)
if connect_name != ownr_nam:
ownr_node = get_connect_node(bus_addr, ownr_nam)
logging.debug("TO CONNECT %s", connect_name)
# TODO: BUG, Display does not work if "Well Known" property.
# grph.add((ownr_node, local_prop_dbus_well_known, connect_node))
grph.add((ownr_node, local_prop_dbus_connect, connect_node))
except ValueError:
logging.debug("22 CONNECT %s", connect_name)
grph.add((node_bus, local_prop_dbus_connect, connect_node))
# TODO: The ordering is: 1.1,1.11,1.2, so we should use natsort.
cgiEnv.OutCgiRdf("LAYOUT_RECT",
[local_prop_dbus_connect, local_prop_dbus_well_known])
def RecursiveObjWalk(grph,object_path, rootNode):
DEBUG("RecursiveObjWalk %s", object_path)
objNode = lib_util.EntityUri( "dbus/object", Main.busAddr, Main.connectName, object_path )
grph.add( (rootNode, Main.localPropDbusPath, objNode ) )
obj = Main.theBus.get_object(Main.connectName, object_path)
iface = dbus.Interface(obj, 'org.freedesktop.DBus.Introspectable')
xml_string = iface.Introspect()
if object_path == '/':
object_path = ''
for child in ElementTree.fromstring(xml_string):
if child.tag == 'node':
new_path = '/'.join((object_path, child.attrib['name']))
RecursiveObjWalk( grph, new_path, objNode)
def _get_daemons_data():
"""
This returns in a dictionary, the list of deamons.
These daemons can then be displayed in plain HTML or in a Jinja2 template.
Some control is also provided by the interface of supervisord library, so its link is displayed.
Some CGI scripts can run in two modes: "web" mode (CGI or WSGI), as usual, but also in daemon mode:
their daemon process runs endlessly and instead of returning their events to the caller of the CGI script,
these events are inserted into a RDF triplestore.
This RDF triplestore is defined as an URL in the credentials: Any type of triplestore
is allowed as long as it is supported by rdflib persistence API,
see details here: https://rdflib.readthedocs.io/en/stable/persistence.html .
Then, when the script is later run in "normal", CGI mode, the events are returned from this triplestore database.
This allows to accumulate a complete history of events stored as RDF triples.
Each of these daemons is associated with a CGI script and also an object, defined with its class and the values
of the attributes listes in the ontology of the class.
Of course, if this is a top-level script not associated with a class, there are no arguments.
"""
urls_daemons_dict = lib_daemon.get_running_daemons()
for daemon_url, daemon_object in urls_daemons_dict.items():
logging.debug("daemon_url=%s" % daemon_url)
url_label, entity_type, entity_id = lib_naming.ParseEntityUri(
daemon_url, long_display=True)
logging.debug("url_label=%s" % url_label)
logging.debug("entity_type=%s" % entity_type)
logging.debug("entity_id=%s" % entity_id)
daemon_object['url_title'] = url_label
# Now that we have the class and the key-value pairs of the object related to the script, builds its url.
# TODO: Simplify this, because it splits the id path to join it afterwards.
# It might help to reorder properly the key-value pairs.
entity_ids_arr = lib_util.EntityIdToArray(entity_type, entity_id)
entity_url = lib_util.EntityUri(entity_type, *entity_ids_arr)
logging.debug("entity_url=%s" % entity_url)
daemon_object['object_url'] = entity_url
entity_label = lib_naming.entity_to_label(entity_type, entity_id,
lib_util.HostName())
logging.debug("entity_label=%s" % entity_label)
daemon_object['object_title'] = entity_label
daemon_object['triples_number'] = lib_kbase.context_events_count(
daemon_url)
daemon_object['start_time'] = datetime.datetime.fromtimestamp(
daemon_object['start']).strftime("%m/%d/%Y, %H:%M:%S")
return urls_daemons_dict
def Main():
cgiEnv = lib_common.CgiEnv(can_process_remote=True)
cimomUrl = cgiEnv.GetHost()
grph = cgiEnv.GetGraph()
# There is no consensus on the WBEM class for namespaces,
# so we have ours which must be correctly mapped.
namespace_class = "wbem_namespace"
rootNode = lib_util.EntityUri(namespace_class, "")
connWbem = lib_wbem.WbemConnection(cimomUrl)
try:
nsd = lib_wbem.EnumNamespacesCapabilities(connWbem)
except Exception:
exc = sys.exc_info()[1]
lib_common.ErrorMessageHtml("Namespaces from :" + cimomUrl +
" Caught:" + str(exc))
# TODO: We should draw a namespaces tree but more examples needed.
for nskey in nsd:
cnt = nsd[nskey]
# Special case because it is not displayed like a normal entity.
# Oui mais ca marche aussi avec wmi ?
# Pourrait-on combiner namespace+classe ? entity_type="root/cim_v2/CIM_Process" ?
# Si l'entity_type termine par un slash, donc c'est un namespace ?
# Ca nous permettrait de creer des namespaces dans notre ontologie,
# par exemple pour Oracle. Ce serait simplement un directory.
# ATTENTION: Avoir la liste de nos entity_types sera moins immediat.
wbemUrl = lib_wbem.NamespaceUrl(nskey, cimomUrl)
wbemNode = lib_common.NodeUrl(wbemUrl)
grph.add((rootNode, pc.property_cim_subnamespace, wbemNode))
grph.add(
(wbemNode, pc.property_information, lib_common.NodeLiteral(nskey)))
grph.add(
(wbemNode, pc.property_information, lib_common.NodeLiteral(cnt)))
cgiEnv.OutCgiRdf("LAYOUT_RECT")
def Main():
cgiEnv = lib_common.CgiEnv()
entity_type = "dbus/connection"
# entity_id = cgiEnv.m_entity_id
# entity_ids_arr = lib_util.EntityIdToArray( entity_type, entity_id )
# entity_ids_dict = lib_util.SplitMoniker(entity_id)
# busAddr = entity_ids_arr[0]
# connectName = entity_ids_arr[1]
Main.busAddr = cgiEnv.m_entity_id_dict["Bus"]
Main.connectName = cgiEnv.m_entity_id_dict["Connect"]
try:
Main.theBus = lib_dbus.MakeBusFromAddress(Main.busAddr)
except Exception:
exc = sys.exc_info()[1]
lib_common.ErrorMessageHtml("busAddr=%s Caught:%s" %
(Main.busAddr, str(exc)))
connectNode = lib_util.EntityUri(entity_type, Main.busAddr,
Main.connectName)
grph = cgiEnv.GetGraph()
Main.localPropDbusPath = lib_common.NodeLiteral("dbus-path")
try:
RecursiveObjWalk(grph, "/", connectNode)
except dbus.exceptions.DBusException as exc:
exc = sys.exc_info()[1]
lib_common.ErrorMessageHtml("Caught DBusException busAddr=%s %s" %
(Main.busAddr, str(exc)))
except dbus.proxies as exc:
exc = sys.exc_info()[1]
lib_common.ErrorMessageHtml("Caught proxies busAddr=%s %s" %
(Main.busAddr, str(exc)))
cgiEnv.OutCgiRdf()
def Main():
cgiEnv = lib_common.CgiEnv()
fname = cgiEnv.GetId()
grph = cgiEnv.GetGraph()
fnameMysteryNode = lib_common.gUriGen.ComTypeLibUri(fname)
# TODO: Difficulte: On se retrouve qvec des dizaines d'entries,
# qui correspondent a ces types, et on ne sait pas comment
# les afficher differemment: C'est le meme probleme que les fichiers
# qui sont des sous-classes.
# DONC:
# - Dans l'affichages des listes, prevoir des types de children:
# Le type du fichier, ou bien [Enumeration,CoClass,Dispatch] etc...
# - Il faut que les sous-classes puissent etre definies par defaut.
# - Pourquoi ne pas definir "file/dll", "file/exe" d'une part,
# "com_type_lib_entry/dispatch", "com_type_lib_entry/coclass" etc...
# Et dans la foulee, on remplace "BY_hostname" par "entities/hostname"
# - L'affichage en liste HTML va detecter les entity_type dans les children
# d'un meme parent pour une propriete donnee, et va segmenter
# par entity_type et donc entity_subtype.
HLITypeKinds = {
pythoncom.TKIND_ENUM: 'Enumeration',
pythoncom.TKIND_RECORD: 'Record',
pythoncom.TKIND_MODULE: 'Module',
pythoncom.TKIND_INTERFACE: 'Interface',
pythoncom.TKIND_DISPATCH: 'Dispatch',
pythoncom.TKIND_COCLASS: 'CoClass',
pythoncom.TKIND_ALIAS: 'Alias',
pythoncom.TKIND_UNION: 'Union'
}
try:
tlb = pythoncom.LoadTypeLib(fname)
except pythoncom.com_error:
lib_common.ErrorMessageHtml("Cannot load:" + fname)
for idx in range(tlb.GetTypeInfoCount()):
try:
infoTyp = tlb.GetTypeInfoType(idx)
typNam = HLITypeKinds[infoTyp]
sub_entity_type = lib_util.ComposeTypes("com/type_lib_entry",
typNam.lower())
nameComEntryUri = "%s_(%d)" % (fname, idx)
# TODO: Maybe this will be cleaner. Quick and dirty solution for the moment.
# UriNodeCreatorName = "ComTypeLibEntry" + typNam + "Uri"
# funcCreate = getattr( lib_common, UriNodeCreatorName )
# entryNode = funcCreate( "%s_(%d)" % ( fname, idx ) )
entryNode = lib_util.EntityUri(sub_entity_type, nameComEntryUri)
name, doc, ctx, helpFile = tlb.GetDocumentation(idx)
grph.add((entryNode, pc.property_information,
lib_common.NodeLiteral("name=%s" % name)))
grph.add((entryNode, pc.property_information,
lib_common.NodeLiteral("type=%s" % typNam)))
grph.add((fnameMysteryNode, pc.property_com_entry, entryNode))
except pythoncom.com_error:
ret.append(browser.MakeHLI("The type info can not be loaded!"))
cgiEnv.OutCgiRdf("LAYOUT_RECT")
def MakeUri(self, entity_type, **kwArgs):
return lib_util.EntityUri(entity_type, {"Db": self.m_oraDatabase},
**kwArgs)
