def Main():
cgiEnv = lib_common.ScriptEnvironment()
config_nam = cgiEnv.m_entity_id_dict["Url"]
nam_connection = cgiEnv.m_entity_id_dict["Connection"]
node_manager = survol_rabbitmq_manager.MakeUri(config_nam)
creds = lib_credentials.GetCredentials("RabbitMQ", config_nam)
cl = Client(config_nam, creds[0], creds[1])
grph = cgiEnv.GetGraph()
logging.debug("nam_connection=%s", nam_connection)
nod_connection = survol_rabbitmq_connection.MakeUri(config_nam, nam_connection)
grph.add((node_manager, lib_common.MakeProp("Connection"), nod_connection))
try:
connect_list = cl.get_connection(nam_connection)
except Exception as exc:
lib_common.ErrorMessageHtml("Caught:" + str(exc))
for connect_key in connect_list:
connect_val = connect_list[connect_key]
if connect_key == "vhost":
nod_v_host = survol_rabbitmq_vhost.MakeUri(config_nam, connect_val)
grph.add((nod_connection, lib_common.MakeProp("Virtual host"), nod_v_host))
elif connect_key == "user":
nod_user = survol_rabbitmq_user.MakeUri(config_nam, connect_val)
grph.add((nod_connection, lib_common.MakeProp("User"), nod_user))
elif connect_key == "host":
nod_host = lib_uris.gUriGen.HostnameUri(connect_val)
grph.add((nod_connection, lib_common.MakeProp("Host"), nod_host))
elif connect_key in ["name", "peer_host", "peer_port"]:
pass
else:
if isinstance(connect_val, six.string_types):
connect_val = connect_val.replace(">", "@")
logging.debug("connect_key=%s connect_val=%s", connect_key, connect_val)
elif isinstance(connect_val, dict):
pass
elif isinstance(connect_val, tuple):
pass
elif isinstance(connect_val, list):
pass
else:
pass
logging.debug("Literal=%s", lib_util.NodeLiteral(connect_val))
grph.add((nod_connection, lib_common.MakeProp(connect_key), lib_util.NodeLiteral(connect_val)))
survol_rabbitmq_connection.AddSockets(grph, nod_connection, nam_connection)
cgiEnv.OutCgiRdf()
def _add_info_from_import(grph, package_node, package_key):
"""Displays general information about the module."""
try:
the_module = importlib.import_module(package_key)
except ImportError:
lib_common.ErrorMessageHtml("Importing %s: Error %s" %
(package_key, str(sys.exc_info())))
try:
init_fil_nam = the_module.__file__
fil_node = lib_uris.gUriGen.FileUri(init_fil_nam)
grph.add((package_node, prop_python_package, fil_node))
except AttributeError:
pass
try:
txt_doc = the_module.__doc__
if txt_doc:
txt_doc = txt_doc.strip()
grph.add((package_node, pc.property_information,
lib_util.NodeLiteral(txt_doc)))
except AttributeError:
pass
props_package = {"Author": "__author__", "Version": "__version__"}
for key_prop in props_package:
val_prop = props_package[key_prop]
try:
txt_val = getattr(the_module, val_prop)
if txt_val:
grph.add((package_node, lib_common.MakeProp(key_prop),
lib_util.NodeLiteral(txt_val)))
except AttributeError:
pass
def Main():
cgiEnv = lib_common.ScriptEnvironment()
grph = cgiEnv.GetGraph()
for lin_cg in open("/proc/cgroups"):
# Just in case there would be a comment.
lin_cg = lin_cg.strip()
if lin_cg.startswith("#"):
continue
split_cg = lin_cg.split('\t')
subsys_name = split_cg[0]
hierarchy = split_cg[1]
num_cgroups = split_cg[2]
enabled = split_cg[3]
cgrp_node = survol_cgroup.MakeUri(subsys_name)
grph.add((cgrp_node, lib_common.MakeProp("Hierarchy"),
lib_util.NodeLiteral(hierarchy)))
grph.add((cgrp_node, lib_common.MakeProp("Num CGroups"),
lib_util.NodeLiteral(num_cgroups)))
grph.add((cgrp_node, lib_common.MakeProp("Enabled"),
lib_util.NodeLiteral(enabled)))
cgiEnv.OutCgiRdf()
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 DictServiceToNode(grph, service_dict, machine_name=None):
# TODO: This is a process but not only. How to display that?
service_name = service_dict['ServiceName']
# NOTE: SOON, ALL ENTITIES WILL HAVE THEIR HOSTNAME.
if machine_name in [None, ""]:
node_service = lib_uris.gUriGen.ServiceUri(service_name)
else:
node_service = lib_common.RemoteBox(machine_name).ServiceUri(service_name)
try:
current_state_idx = service_dict['CurrentState']
current_state_nam = _state_dictionary[current_state_idx]
except KeyError:
current_state_nam = "Unknown state key"
except IndexError:
current_state_nam = "Unknown state index"
grph.add((node_service, pc.property_information, lib_util.NodeLiteral(service_dict['DisplayName'])))
# TODO: Change color with the state. ASSOCIATE COLOR TO PAIRS (Property + Literal value) ? SPECIALLY CODED VALUE WITH HTML TAGS ?
service_pid = service_dict['ProcessId']
# Display is as compact as possible to help routing. Informaitonal only.
if service_pid != 0:
# TODO: Plutot mettre un lien vers le process mais afficher comme un literal.
state_string = str(service_pid) + "/" + current_state_nam
# grph.add((node_service, pc.property_pid, lib_util.NodeLiteral(service_pid)))
grph.add((node_service, pc.property_pid, lib_util.NodeLiteral(state_string)))
else:
# grph.add((node_service, pc.property_service_state, lib_util.NodeLiteral(current_state_nam)))
grph.add((node_service, pc.property_service_state, lib_util.NodeLiteral(current_state_nam)))
return node_service
def Main():
cgiEnv = lib_common.CgiEnv()
grph = cgiEnv.GetGraph()
try:
procid = int(cgiEnv.GetId())
except Exception:
lib_common.ErrorMessageHtml("Must provide a pid")
objProc = CIM_Process.PsutilGetProcObj(procid)
envProp = lib_common.MakeProp("environment")
try:
# Psutil version after 4.0.0
envsDict = objProc.environ()
except:
exc = sys.exc_info()[1]
lib_common.ErrorMessageHtml("Error:" + str(exc))
node_process = lib_common.gUriGen.PidUri(procid)
for envKey in envsDict:
envVal = envsDict[envKey]
DEBUG("envKey=%s envVal=%s", envKey, envVal)
nodeEnvNam = lib_util.NodeLiteral(envKey)
# When a file or a directory displayed with a node,
# its name is shortened so it can fit into the table.,
# so it is less visible.
# Some are probably for Windows only.
if envKey in ["PATH", "PSMODULEPATH", "PYPATH"]:
valSplit = envVal.split(os.pathsep)
nodFilArr = [
lib_common.gUriGen.DirectoryUri(filNam) for filNam in valSplit
]
nodFilArrNod = lib_util.NodeLiteral(nodFilArr)
#for filNam in valSplit:
# nodFil = lib_common.gUriGen.DirectoryUri(filNam)
grph.add((nodeEnvNam, pc.property_rdf_data_nolist2, nodFilArrNod))
elif os.path.isdir(envVal):
nodFil = lib_common.gUriGen.DirectoryUri(envVal)
#grph.add((nodeEnvNam,pc.property_directory,nodFil))
grph.add((nodeEnvNam, pc.property_rdf_data_nolist2, nodFil))
elif os.path.exists(envVal):
nodFil = lib_common.gUriGen.FileUri(envVal)
grph.add((nodeEnvNam, pc.property_rdf_data_nolist2, nodFil))
#grph.add((nodeEnvNam,pc.property_directory,nodFil))
else:
# TODO: Beware that "\L" is transformed into "<TABLE>" by Graphviz !!!
envValClean = envVal.replace(">", "_").replace("<", "_").replace(
"&", "_").replace("\\", "_")
nodeEnvValue = lib_util.NodeLiteral(envValClean)
grph.add((nodeEnvNam, pc.property_rdf_data_nolist2, nodeEnvValue))
grph.add((node_process, envProp, nodeEnvNam))
# cgiEnv.OutCgiRdf("LAYOUT_RECT", [pc.property_directory,envProp])
cgiEnv.OutCgiRdf("LAYOUT_RECT", [envProp])
def Main():
paramkey_extensive_scan = "Extensive scan"
# Beware that unchecked checkboxes are not posted, i.e. boolean variables set to False.
# http://stackoverflow.com/questions/1809494/post-the-checkboxes-that-are-unchecked
cgiEnv = lib_common.ScriptEnvironment(
parameters={paramkey_extensive_scan: False})
pidint = int(cgiEnv.GetId())
grph = cgiEnv.GetGraph()
paramExtensiveScan = cgiEnv.get_parameters(paramkey_extensive_scan)
# By default, uses a small map of possible connection strings keyword.
# Otherwise it is very slow to scan the whole process memory.
if paramExtensiveScan:
rgx_dsn = survol_odbc.regex_odbc_heavy
else:
rgx_dsn = survol_odbc.regex_odbc_light
aggreg_dsns = _get_aggreg_dsns(pidint, rgx_dsn)
node_process = lib_uris.gUriGen.PidUri(pidint)
# TODO: Add a parameter to choose between light and heavy connection string definition.
# TODO: Eliminate aggregated strings containing one or two tokens,
# because they cannot be genuine DSNs.
# 29812569: SERVER=\MYMACHINE
# 34515016: Driver={SQL Server};Server=.\SQLEXPRESS;Database=ExpressDB;Trusted_Connection=yes
# 34801013: SERVER=\MYMACHINE
# 35634904: Driver={SQL Server};Server=.\SQLEXPRESS;Database=ExpressDB;Trusted_Connection=yes
for aggreg_offset in aggreg_dsns:
# Do not take the character before the keyword.
aggreg_dsn_raw = aggreg_dsns[aggreg_offset]
# Replaces all non-printable characters by spaces.
# This should be done now by the regular expressions, but better be sure.
aggreg_dsn = re.sub(b'[\x00-\x1f\x7f-\xff]+', b' ', aggreg_dsn_raw)
# This should contain Ascii, convertible to UTF-8, but if the regular expression catch something else,
# this decode throw: 'utf-8' codec can't decode bytes in position 3768-3769: invalid continuation byte.
aggreg_dsn = aggreg_dsn.decode("utf-8", "ignore")
dsn_full = str(aggreg_offset) + ": " + aggreg_dsn
logging.debug("aggreg_offset=%s dsn_full=%s", aggreg_offset, dsn_full)
grph.add((node_process, pc.property_information,
lib_util.NodeLiteral(dsn_full)))
### NO! Confusion between DSN and connection string.
# All the existing code does: ODBC_ConnectString = survol_odbc_dsn.MakeOdbcConnectionString(dsnNam)
# which basically creates "DSN=dsvNam;PWD=..." but here we already have the connection string.
# TODO: Should we assimilate both ???
node_dsn = survol_odbc_dsn.MakeUri(aggreg_dsn)
grph.add((node_process, pc.property_odbc_dsn, node_dsn))
# Fix this message.
grph.add((node_dsn, pc.property_odbc_driver,
lib_util.NodeLiteral("ODBC driver")))
cgiEnv.OutCgiRdf()
def WbemKeyValues(key_value_items, display_none_values=False):
"""This is conceptually similar to WmiKeyValues"""
dict_key_values = {}
for wbem_key_name, wbem_value_literal in key_value_items:
wbem_property = lib_properties.MakeProp(wbem_key_name)
if isinstance(wbem_value_literal, lib_util.scalar_data_types):
wbem_value_node = lib_util.NodeLiteral(wbem_value_literal)
elif isinstance(wbem_value_literal, (tuple)):
tuple_joined = " ; ".join(wbem_value_literal)
wbem_value_node = lib_util.NodeLiteral(tuple_joined)
elif wbem_value_literal is None:
if display_none_values:
wbem_value_node = lib_util.NodeLiteral("None")
else:
wbem_value_node = lib_util.NodeLiteral(
"type=" + str(type(wbem_value_literal)) + ":" +
str(wbem_value_literal))
#try:
# refMoniker = str(wbem_value_literal.path())
# instance_url = lib_util.EntityUrlFromMoniker(refMoniker)
# wbem_value_node = lib_common.NodeUrl(instance_url)
#except AttributeError as exc:
# wbem_value_node = lib_util.NodeLiteral(str(exc))
dict_key_values[wbem_property] = wbem_value_node
return dict_key_values
def _add_info_from_pip(grph, node, package_key):
"""Each entity can have such a file with its name as file name.
Then in its file, by convention adds information to a node."""
try:
# TODO: What about several Python versions ?
installed_packages = lib_python.PipGetInstalledDistributions()
# TODO: Maybe the version should be part of the key.
for pckg in installed_packages:
if package_key == pckg.key:
_fill_one_package(grph, node, pckg)
else:
for sub_req in pckg.requires():
if sub_req.key == package_key:
subNode = MakeUri(pckg.key)
# [('>=', '4.0.0')]+[]+[('>=','4.0')]+[]
a_specs = sub_req.specs
if a_specs:
# TODO: This should be displayed on the edge !!!
grph.add(
(node,
lib_common.MakeProp("Condition " + pckg.key),
lib_util.NodeLiteral(str(a_specs))))
grph.add((subNode, prop_python_requires, node))
break
except Exception as exc:
grph.add(
(node, pc.property_information, lib_util.NodeLiteral(str(exc))))
def AddFileProperties(grph, current_node, current_filename):
try:
import win32api
import lib_win32
prop_dict = lib_win32.getFileProperties(current_filename)
for prp, val in prop_dict.items():
val = prop_dict[prp]
if val is None:
continue
if isinstance(val, dict):
val = json.dumps(val)
# TODO: Unicode error encoding=ascii
# 169 251 A9 10101001 "Copyright" © © Copyright sign
# Might contain this: "LegalCopyright Copyright \u00a9 2010"
val = val.replace("\\", "\\\\")
grph.add((current_node, lib_common.MakeProp(prp), lib_util.NodeLiteral(val)))
except ImportError:
pass
file_mime_type = lib_mime.filename_to_mime(current_filename)
if file_mime_type:
if file_mime_type[0]:
grph.add((current_node, lib_common.MakeProp("Mime type"), lib_util.NodeLiteral(str(file_mime_type))))
def Main():
# If this flag is set, the script uses SLP to discover WBEM Agents.
paramkey_slp = "Service Location Protocol"
cgiEnv = lib_common.ScriptEnvironment(
parameters={paramkey_slp: False}
)
flag_slp = bool(cgiEnv.get_parameters(paramkey_slp))
grph = cgiEnv.GetGraph()
_wbem_servers_display(grph)
if flag_slp:
dict_services = survol_neighborhood.GetSLPServices("survol")
for key_service in dict_services:
wbem_node = _add_from_wbem_cimom(grph, key_service)
if not wbem_node:
continue
grph.add((wbem_node, pc.property_information, lib_util.NodeLiteral("Service Location Protocol")))
attrs_service = dict_services[key_service]
for key_attr in attrs_service:
prop_attr = lib_common.MakeProp(key_attr)
val_attr = attrs_service[key_attr]
grph.add((wbem_node, prop_attr, lib_util.NodeLiteral(val_attr)))
cgiEnv.OutCgiRdf()
def Main():
cgiEnv = lib_common.ScriptEnvironment()
configNam = cgiEnv.GetId()
nodeManager = survol_rabbitmq_manager.MakeUri(configNam)
creds = lib_credentials.GetCredentials("RabbitMQ", configNam)
# cl = Client('localhost:12345', 'guest', 'guest')
cl = Client(configNam, creds[0], creds[1])
grph = cgiEnv.GetGraph()
# >>> cl.get_all_vhosts()
# http://localhost:12345/api/vhosts
# [{u'name': u'/', u'tracing': False, u'messages_details': {u'rate': 0.0}, u'messages': 0, u'message_stats': {u'deliver_no_ack': 0, u'
# publish_out': 0, u'get_no_ack': 13, u'return_unroutable': 0, u'confirm': 0, u'deliver_get': 13, u'publish': 13, u'confirm_details':
# {u'rate': 0.0}, u'ack_details': {u'rate': 0.0}, u'get': 0, u'deliver': 0, u'publish_out_details': {u'rate': 0.0}, u'redeliver_detail
# s': {u'rate': 0.0}, u'deliver_details': {u'rate': 0.0}, u'deliver_get_details': {u'rate': 0.0}, u'publish_details': {u'rate': 0.0},
# u'publish_in_details': {u'rate': 0.0}, u'ack': 0, u'publish_in': 0, u'return_unroutable_details': {u'rate': 0.0}, u'get_details': {u
# 'rate': 0.0}, u'get_no_ack_details': {u'rate': 0.0}, u'deliver_no_ack_details': {u'rate': 0.0}, u'redeliver': 0}, u'messages_unackno
# wledged_details': {u'rate': 0.0}, u'messages_ready_details': {u'rate': 0.0}, u'messages_unacknowledged': 0, u'messages_ready': 0}]
try:
#
listVHosts = cl.get_all_vhosts()
except Exception as exc:
lib_common.ErrorMessageHtml("Caught:" + str(exc))
for objVHost in listVHosts:
namVHost = objVHost["name"]
logging.debug("q=%s", namVHost)
nodeVHost = survol_rabbitmq_vhost.MakeUri(configNam, namVHost)
try:
grph.add((nodeVHost, lib_common.MakeProp("tracing"),
lib_util.NodeLiteral(objVHost["tracing"])))
except KeyError:
pass
try:
grph.add((nodeVHost, lib_common.MakeProp("messages"),
lib_util.NodeLiteral(objVHost["messages"])))
except KeyError:
pass
# http://127.0.0.1:12345/#/vhosts//
managementUrl = rabbitmq.ManagementUrlPrefix(configNam, "vhosts",
namVHost)
grph.add((nodeVHost, lib_common.MakeProp("Management"),
lib_common.NodeUrl(managementUrl)))
grph.add((nodeManager, lib_common.MakeProp("Virtual host"), nodeVHost))
cgiEnv.OutCgiRdf()
def Main():
cgiEnv = lib_common.ScriptEnvironment()
grph = cgiEnv.GetGraph()
for part in psutil.disk_partitions():
# partition(device='D:\\\\', mountpoint='D:\\\\', fstype='NTFS', opts='rw,fixed')
logging.debug("device=%s fstype=%s", part.device, part.fstype)
logging.debug("All=%s", str(part))
# BEWARE: This is not very clear.
if lib_util.isPlatformWindows:
# sdiskpart(device='C:\\', mountpoint='C:\\', fstype='NTFS', opts='rw,fixed')
# DeviceID : X:
# DriveType : 4
# ProviderName : \\192.168.1.81\jsmith
# FreeSpace : 170954825728
# Size : 2949169561600
# VolumeName : jsmith
#
# WMI does not want a backslash at the end: "C:".
# Replacing backslashes is necessary on Windows.
partition_name = part.device.replace('\\', '')
# We could as well take "Win32_LogicalDisk" because it inherits from "CIM_LogicalDisk"
node_partition = lib_uris.gUriGen.node_from_args(
"CIM_LogicalDisk", partition_name)
else:
# The class CIM_LogicalDisk represents a contiguous range of logical blocks
# that is identifiable by a FileSystem via the Disk's DeviceId (key) field.
# Each storage extent with the capability of or already hosting a file system
# is represented as a sub-class of CIM_LogicalDisk.
# The class CIM_LogicalDisk is the connector between File Systems and Storage Extents
# [sdiskpart(device='/dev/vda1', mountpoint='/var/lib/docker/containers',
# fstype='ext4', opts='rw,seclabel,relatime,data=ordered'),]
# This does not really work on Windows because WMI expects
# something like 'Win32_DiskPartition.DeviceID="Disk #0.Partition #0"'
partition_name = part.device
node_partition = lib_uris.gUriGen.DiskPartitionUri(partition_name)
mount_point = part.mountpoint.replace('\\', '/')
node_mount = lib_uris.gUriGen.DirectoryUri(mount_point)
# TODO: Check this list.
if part.fstype != "":
# partition(device='T:\\\\', mountpoint='T:\\\\', fstype='', opts='cdrom')
grph.add((node_partition, pc.property_file_system_type,
lib_util.NodeLiteral(part.fstype)))
grph.add((node_mount, pc.property_mount, node_partition))
if part.opts != "":
grph.add((node_mount, pc.property_mount_options,
lib_util.NodeLiteral(part.opts)))
cgiEnv.OutCgiRdf()
def Main():
cgiEnv = lib_common.ScriptEnvironment()
grph = cgiEnv.GetGraph()
dsn_nam = cgiEnv.m_entity_id_dict["Dsn"]
logging.debug("dsn=(%s)", dsn_nam)
odbc_connect_string = survol_odbc_dsn.MakeOdbcConnectionString(dsn_nam)
try:
cnxn = pyodbc.connect(odbc_connect_string)
logging.debug("Connected: %s", dsn_nam)
cursor_queries = cnxn.cursor()
qry_queries = """
SELECT sqltext.TEXT,
req.session_id,
req.status,
sess.host_process_id,
sess.host_name
FROM sys.dm_exec_requests req
CROSS APPLY sys.dm_exec_sql_text(sql_handle) AS sqltext
, sys.dm_exec_sessions sess
where sess.session_id = req.session_id
"""
prop_sql_server_sql_query = lib_common.MakeProp("Sql query")
prop_sql_server_host_process = lib_common.MakeProp("Host process")
prop_sql_server_status = lib_common.MakeProp("Status")
for row_qry in cursor_queries.execute(qry_queries):
logging.debug("row_qry.session_id=(%s)", row_qry.session_id)
node_session = session.MakeUri(dsn_nam, row_qry.session_id)
# A bit of cleanup.
query_clean = row_qry.TEXT.replace("\n", " ").strip()
# TODO: Must add connection information so we can go from the tables to sqlserver itself.
node_sql_query = sql_query_module.MakeUri(query_clean, dsn_nam)
grph.add((node_session, prop_sql_server_sql_query, node_sql_query))
node_process = lib_common.RemoteBox(row_qry.host_name).PidUri(
row_qry.host_process_id)
grph.add((node_process, pc.property_pid,
lib_util.NodeLiteral(row_qry.host_process_id)))
grph.add(
(node_session, prop_sql_server_host_process, node_process))
grph.add((node_session, prop_sql_server_status,
lib_util.NodeLiteral(row_qry.status)))
except Exception as exc:
lib_common.ErrorMessageHtml("nodeDsn=%s Unexpected error:%s" %
(dsn_nam, str(exc)))
cgiEnv.OutCgiRdf()
def add_file_owner_windows():
try:
import win32api
import win32con
import win32security
except ImportError:
return
from sources_types import Win32_UserAccount
from sources_types import Win32_Group
def SID_CodeToName(typeSID):
mapSIDList = {
win32security.SidTypeUser: "******",
win32security.SidTypeGroup: "Group SID",
win32security.SidTypeDomain: "Domain SID",
win32security.SidTypeAlias: "Alias SID",
win32security.SidTypeWellKnownGroup: "Well-known group",
win32security.SidTypeDeletedAccount: "Deleted account",
win32security.SidTypeInvalid: "Invalid SID",
win32security.SidTypeUnknown: "Unknown type SID",
win32security.SidTypeComputer: "Computer SID",
# win32security.SidTypeLabel: "Mandatory integrity label SID" # NOT DEFINED
}
try:
return mapSIDList[typeSID]
except:
return "Unknown SID"
try:
sd = win32security.GetFileSecurity (file_name, win32security.OWNER_SECURITY_INFORMATION)
except Exception as exc:
msg = str(exc)
grph.add((file_node, pc.property_owner, lib_util.NodeLiteral(msg)))
return
owner_sid = sd.GetSecurityDescriptorOwner ()
account_name, domain_name, typeCode = win32security.LookupAccountSid(None, owner_sid)
typ_nam = SID_CodeToName(typeCode)
logging.debug("Domain=%s Name=%s Type=%s", domain_name, account_name, typ_nam)
if typeCode == win32security.SidTypeUser:
account_node = Win32_UserAccount.MakeUri(account_name, domain_name)
elif typeCode == win32security.SidTypeGroup:
account_node = Win32_Group.MakeUri(account_name, domain_name)
elif typeCode == win32security.SidTypeWellKnownGroup:
account_node = Win32_Group.MakeUri(account_name, domain_name)
else:
# What else can we do ?
account_node = Win32_UserAccount.MakeUri(account_name, domain_name)
# TODO: What can we do with the domain ?
grph.add((account_node, lib_common.MakeProp("Domain"), lib_util.NodeLiteral(domain_name)))
grph.add((account_node, lib_common.MakeProp("SID"), lib_util.NodeLiteral(typ_nam)))
grph.add((file_node, pc.property_owner, account_node))
def DisplayMappedProcesses(grph, file_name):
"""This displays all processes mapping a given filename.
This simply iterates on processes, then on mapped files of each process.
This is not very efficient but there is no other way."""
grph.add((lib_common.nodeMachine, pc.property_hostname,
lib_util.NodeLiteral(lib_util.currentHostname)))
# This is also a file mapped into memory.
uri_mapped_file = lib_uris.gUriGen.FileUri(file_name)
uri_mem_map = None
try:
statinfo = os.stat(file_name)
except Exception as exc:
grph.add((uri_mapped_file, lib_common.MakeProp("Error"),
lib_util.NodeLiteral(str(exc))))
return
file_size = lib_util.AddSIUnit(statinfo.st_size, "B")
grph.add((uri_mapped_file, pc.property_file_size,
lib_util.NodeLiteral(file_size)))
prop_memory_rss = lib_common.MakeProp("Resident Set Size")
for proc in psutil.process_iter():
pid = proc.pid
try:
all_maps = proc.memory_maps()
except Exception as exc:
# Probably psutil.AccessDenied
continue
for the_map in all_maps:
# This, because all Windows paths are "standardized" by us.
same_fil = lib_util.standardized_file_path(
the_map.path) == lib_util.standardized_file_path(file_name)
if same_fil:
# Maybe this is the first mapping we have found.
if uri_mem_map == None:
uri_mem_map = lib_uris.gUriGen.MemMapUri(file_name)
grph.add(
(uri_mapped_file, pc.property_mapped, uri_mem_map))
node_process = lib_uris.gUriGen.PidUri(pid)
# The property is reversed because of display.
grph.add((uri_mem_map, pc.property_memmap, node_process))
grph.add(
(node_process, pc.property_pid, lib_util.NodeLiteral(pid)))
# Displays the RSS only if different from the file size.
if the_map.rss != statinfo.st_size:
grph.add((node_process, prop_memory_rss,
lib_util.NodeLiteral(the_map.rss)))
def Main():
cgiEnv = lib_common.ScriptEnvironment(can_process_remote=True)
machine_name = cgiEnv.GetId()
grph = cgiEnv.GetGraph()
if lib_util.is_local_address(machine_name):
mach_name_or_none = None
server_box = lib_uris.gUriGen
else:
mach_name_or_none = machine_name
server_box = lib_uris.RemoteBox(machine_name)
try:
login_implicit = False # IF FACT, WHY SHOULD IT BE SET ????????
if login_implicit or mach_name_or_none is None:
cnnct = wmi.WMI(machine_name)
else:
# persistent net connection
# This works:
# >>> c = wmi.WMI(wmi=wmi.connect_server(server='Titi', namespace="/root/cimv2", user='******', password='******'))
logging.debug("Explicit WMI connection machine_name=%s",
machine_name)
cnnct = lib_wmi.WmiConnect(machine_name, "/root/cimv2")
except Exception as exc:
lib_common.ErrorMessageHtml("WMI " + machine_name + " partitions:" +
str(exc))
for physical_disk in cnnct.Win32_DiskDrive():
node_disk = server_box.DiskUri(physical_disk.Name.replace('\\', '/'))
grph.add((node_disk, pc.property_information,
lib_util.NodeLiteral(physical_disk.MediaType)))
for partition in physical_disk.associators(
"Win32_DiskDriveToDiskPartition"):
for logical_disk in partition.associators(
"Win32_LogicalDiskToPartition"):
# BEWARE: What we call partition is in fact a logical disk.
# This is not really important for this application,
# as long as there are two levels in a disk description.
node_partition = server_box.DiskPartitionUri(logical_disk.Name)
grph.add((node_partition, pc.property_information,
lib_util.NodeLiteral(logical_disk.Description)))
grph.add((node_partition, pc.property_file_system_type,
lib_util.NodeLiteral(logical_disk.FileSystem)))
# The logical disk name is the same as the mount point.
grph.add((node_partition, pc.property_partition, node_disk))
grph.add((server_box.DirectoryUri(logical_disk.Name),
pc.property_mount, node_partition))
cgiEnv.OutCgiRdf()
def Main():
cgiEnv = lib_common.ScriptEnvironment()
# "NtOpenObjectAuditAlarm%40C%3A\windows\system32\ntdll.dll"
# Filename is optional.
# The symbol is already demangled.
symbol_nam = cgiEnv.m_entity_id_dict["Name"]
fil_nam = cgiEnv.m_entity_id_dict["File"]
logging.debug("symbol=%s fil_nam=%s", symbol_nam, fil_nam)
grph = cgiEnv.GetGraph()
sym_node = lib_uris.gUriGen.SymbolUri(symbol_nam, fil_nam)
if fil_nam:
fil_node = lib_uris.gUriGen.FileUri( fil_nam )
grph.add((fil_node, pc.property_symbol_defined, sym_node))
vers_str = lib_win32.VersionString(fil_nam)
grph.add((fil_node, pc.property_information, lib_util.NodeLiteral(vers_str)))
sym = FindPESymbol(fil_nam, symbol_nam)
if sym is not None:
# Non-breaking space: A0 10100000  
doc_txt = getattr(sym, "__doc__")
# This string is filled with spaces and CR which are translated into " ".
doc_txt = re.sub(r'\s+', ' ', doc_txt).strip()
grph.add((sym_node, pc.property_information,lib_util.NodeLiteral(doc_txt)))
# Possible values are "name","offset","ordinal","forwarder"
try:
fwrd = getattr(sym, "forwarder")
grph.add((sym_node, lib_common.MakeProp("Forwarder"), lib_util.NodeLiteral(fwrd)))
except:
pass
try:
fwrd = getattr(sym,"ordinal")
grph.add((sym_node, lib_common.MakeProp("Ordinal"), lib_util.NodeLiteral(fwrd)))
except:
pass
ful_nam, lst_args = lib_symbol.SymToArgs(symbol_nam)
if lst_args:
for arg in lst_args:
# TODO: Order of arguments must not be changed.
arg_node = lib_uris.gUriGen.ClassUri(arg, fil_nam)
grph.add((sym_node, pc.property_argument, arg_node))
cgiEnv.OutCgiRdf("LAYOUT_RECT", [pc.property_argument])
def _create_wbem_node(grph, root_node, entity_host, name_space, class_name,
entity_id):
wbem_namespace = name_space.replace("\\", "/")
wbem_servers_desc_list = lib_wbem.GetWbemUrls(entity_host, wbem_namespace,
class_name, entity_id)
# If there are no servers.
pair_name_node = None
for url_server in wbem_servers_desc_list:
wbem_node = lib_common.NodeUrl(url_server[0])
grph.add((root_node, pc.property_wbem_data, wbem_node))
wbemHostNode = lib_uris.gUriGen.HostnameUri(url_server[1])
grph.add((wbem_node, pc.property_host, wbemHostNode))
# TODO: Add a Yawn server ??
grph.add((wbem_node, pc.property_wbem_server,
lib_util.NodeLiteral(url_server[1])))
# Now adds the description of the class.
try:
conn_wbem = lib_wbem.WbemConnection(entity_host)
except Exception as exc:
logging.error("WbemConnection throw:%s" % str(exc))
continue
kla_descrip = lib_wbem.WbemClassDescription(conn_wbem, class_name,
wbem_namespace)
ok_wbem_class = True
if not kla_descrip:
ok_wbem_class = False
kla_descrip = "Undefined class %s %s" % (wbem_namespace,
class_name)
grph.add((wbem_node, pc.property_information,
lib_util.NodeLiteral(kla_descrip)))
# Maybe this class is not Known in WBEM.
try:
pair_name_node = _wbem_add_all_base_classes(
grph, conn_wbem, wbem_node, entity_host, name_space,
class_name)
except:
pair_name_node = None
if ok_wbem_class and wbem_ok and name_space != "" and entity_host != "":
namespace_url = lib_wbem.NamespaceUrl(name_space, entity_host,
class_name)
namespace_node = lib_common.NodeUrl(namespace_url)
grph.add((wbem_node, pc.property_information, namespace_node))
# TODO: This is a bit absurd because we return just one list.
return pair_name_node
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.ScriptEnvironment()
grph = cgiEnv.GetGraph()
dsn_nam = cgiEnv.m_entity_id_dict["Dsn"]
logging.debug("dsn=(%s)", dsn_nam)
node_dsn = survol_odbc_dsn.MakeUri(dsn_nam)
odbc_connect_string = survol_odbc_dsn.MakeOdbcConnectionString(dsn_nam)
try:
cnxn = pyodbc.connect(odbc_connect_string)
logging.debug("Connected: %s", dsn_nam)
for prmstr in dir(pyodbc):
if not prmstr.startswith("SQL_"):
continue
# Some keywords are not interesting. This is a bit arbitrary.
if prmstr in ["SQL_KEYWORDS"]:
continue
nicestr = prmstr[4:].replace("_", " ").capitalize()
prop = lib_common.MakeProp(nicestr)
try:
prm = getattr(pyodbc, prmstr)
except:
grph.add((node_dsn, prop, lib_util.NodeLiteral("Unavailable")))
continue
try:
prm_value = cnxn.getinfo(prm)
except:
continue
try:
grph.add((node_dsn, prop, lib_util.NodeLiteral(prm_value)))
except Exception as exc:
txt = str(exc)
grph.add((node_dsn, prop, lib_util.NodeLiteral(txt)))
continue
except Exception as exc:
lib_common.ErrorMessageHtml("node_dsn=%s Unexpected error:%s" %
(dsn_nam, str(exc)))
cgiEnv.OutCgiRdf()
def Main():
cgiEnv = lib_common.ScriptEnvironment()
user_name_with_host = cgiEnv.GetId()
# Usernames have the syntax user@host
user_split = user_name_with_host.split('@')
user_name = user_split[0]
if len(user_split) > 1:
user_host = user_split[1]
if user_host != lib_util.currentHostname:
# TODO: Should interrogate other host with "finger" protocol.
lib_common.ErrorMessageHtml(
"Cannot get user properties on different host:" + user_host)
if not user_name:
lib_common.ErrorMessageHtml(
"Linux username should not be an empty string")
grph = cgiEnv.GetGraph()
user_node = lib_uris.gUriGen.UserUri(user_name)
# It runs this Linux command which returns a single line.
id_cmd = ["id", user_name]
id_pipe = lib_common.SubProcPOpen(id_cmd)
id_last_output, id_err = id_pipe.communicate()
lines = id_last_output.split(b'\n')
logging.debug("id=" + user_name + " lines=" + str(lines))
# $ id my_user
# uid=500(my_user) gid=500(guest) groupes=500(guest),81(audio)
first_line = lines[0]
first_split = split_id(first_line)
user_id = parse_id_name(first_split[0])[0]
grph.add((user_node, pc.property_userid, lib_util.NodeLiteral(user_id)))
for grp_str in first_split[2].split(b','):
group_id, group_name = parse_id_name(grp_str)
grp_node = lib_uris.gUriGen.GroupUri(group_name)
grph.add(
(grp_node, pc.property_groupid, lib_util.NodeLiteral(group_id)))
grph.add((user_node, pc.property_group, grp_node))
cgiEnv.OutCgiRdf()
def Main():
cgiEnv = lib_common.ScriptEnvironment()
configNam = cgiEnv.GetId()
nodeManager = survol_rabbitmq_manager.MakeUri(configNam)
creds = lib_credentials.GetCredentials( "RabbitMQ", configNam )
# cl = Client('localhost:12345', 'guest', 'guest')
cl = Client(configNam, creds[0], creds[1])
grph = cgiEnv.GetGraph()
# cl.is_alive()
#>>> cl.get_users()
#[{u'hashing_algorithm': u'rabbit_password_hashing_sha256', u'name': u'guest', u'tags': u'administrator', u'password_hash': u'xxxxxx'}]
try:
#
listUsers = cl.get_users()
except:
#
exc = sys.exc_info()[1]
lib_common.ErrorMessageHtml("Caught:"+str(exc))
for objUser in listUsers:
namUser = objUser["name"]
logging.debug("q=%s",namUser)
nodeUser = survol_rabbitmq_user.MakeUri(configNam,namUser)
try:
grph.add( ( nodeUser, lib_common.MakeProp("Tags"), lib_util.NodeLiteral(objUser["tags"]) ) )
except KeyError:
pass
try:
grph.add( ( nodeUser, lib_common.MakeProp("Hashing algorithm"), lib_util.NodeLiteral(objUser["hashing_algorithm"]) ) )
except KeyError:
pass
# http://127.0.0.1:12345/#/users/guest
managementUrl = rabbitmq.ManagementUrlPrefix(configNam,"users",namUser)
grph.add( ( nodeUser, lib_common.MakeProp("Management"), lib_common.NodeUrl(managementUrl) ) )
grph.add( ( nodeManager, lib_common.MakeProp("User"), nodeUser ) )
cgiEnv.OutCgiRdf()
def DoRemote(grph, cimomSrv):
import wmi
# TODO: Add the host address to the connection.
# TODO: Cache for the connection ?
# wmi_cnnct = wmi.WMI(cimomSrv)
wmi_cnnct = wmi.WMI()
# TODO: This works but is very slow (About 30 seconds).
for win_prod in wmi_cnnct.Win32_Product():
# instance of Win32_Product
# {
# AssignmentType = 1;
# Caption = "Microsoft Web Deploy 3.5";
# Description = "Microsoft Web Deploy 3.5";
# IdentifyingNumber = "{69A998C5-00A9-42CA-AB4E-C31CFFCD9251}";
# InstallDate = "20150709";
# InstallSource = "C:\\ProgramData\\Package Cache\\{69A998C5-00A9-42CA-AB4E-C31CFFCD9251}v3.1237.1763\\packages\\WebDeploy\\";
#
# InstallState = 5;
# Language = "1033";
# LocalPackage = "C:\\windows\\Installer\\8a43794.msi";
# Name = "Microsoft Web Deploy 3.5";
# PackageCache = "C:\\windows\\Installer\\8a43794.msi";
# PackageCode = "{28DAC33F-DD0E-4293-9BB0-5585B4D89CB9}";
# PackageName = "WebDeploy_x64.msi";
# Vendor = "Microsoft Corporation";
# Version = "3.1237.1763";
# WordCount = 2;
# };
# {69A998C5-00A9-42CA-AB4E-C31CFFCD9251}
# Product(Language=u'1033', ProductName=u'Microsoft Web Deploy 3.5', PackageCode=u'{28DAC33F-DD0E-4293-9BB0-5585B4D89CB9}', Transforms
# =u'', AssignmentType=u'1', PackageName=u'WebDeploy_x64.msi', InstalledProductName=u'Microsoft Web Deploy 3.5', VersionString=u'3.123
# 7.1763', RegCompany=u'', RegOwner=u'', ProductID=u'', ProductIcon=u'C:\\windows\\Installer\\{69A998C5-00A9-42CA-AB4E-C31CFFCD9251}\\
# MSDeployIcon.exe', InstallLocation=u'', InstallSource=u'C:\\ProgramData\\Package Cache\\{69A998C5-00A9-42CA-AB4E-C31CFFCD9251}v3.123
# 7.1763\\packages\\WebDeploy\\', InstallDate=u'20150709', Publisher=u'Microsoft Corporation', LocalPackage=u'C:\\windows\\Installer\\
# 8a43794.msi', HelpLink=u'', HelpTelephone=u'', URLInfoAbout=u'', URLUpdateInfo=u'')
try:
product_node = Win32_Product.MakeUri(win_prod.Caption)
grph.add((product_node, pc.property_information,
lib_util.NodeLiteral(win_prod.Description)))
grph.add((product_node, lib_common.MakeProp("IdentifyingNumber"),
lib_util.NodeLiteral(win_prod.IdentifyingNumber)))
Win32_Product.AddInstallSource(grph, product_node, win_prod)
grph.add((lib_common.nodeMachine,
lib_common.MakeProp("Win32_Product"), product_node))
except Exception as exc:
lib_common.ErrorMessageHtml("Caught:%s" % str(exc))
def Main():
cgiEnv = lib_common.ScriptEnvironment()
grph = cgiEnv.GetGraph()
try:
procid = int(cgiEnv.GetId())
except Exception:
lib_common.ErrorMessageHtml("Must provide a pid")
obj_proc = CIM_Process.PsutilGetProcObj(procid)
env_prop = lib_common.MakeProp("environment")
try:
envs_dict = obj_proc.environ()
except Exception as exc:
lib_common.ErrorMessageHtml("Caught:%s" % exc)
node_process = lib_uris.gUriGen.PidUri(procid)
for env_key in envs_dict :
env_val = envs_dict[env_key]
logging.debug("env_key=%s env_val=%s", env_key, env_val)
node_env_nam = lib_util.NodeLiteral(env_key)
# When a file or a directory displayed with a node,
# its name is shortened so it can fit into the table.,
# so it is less visible.
# Some are probably for Windows only.
if env_key in ["PATH", "PSMODULEPATH", "PYPATH"]:
val_split = env_val.split(os.pathsep)
nod_fil_arr = [lib_uris.gUriGen.DirectoryUri(fil_nam) for fil_nam in val_split]
nod_fil_arr_nod = lib_util.NodeLiteral(nod_fil_arr)
grph.add((node_env_nam, pc.property_rdf_data_nolist2, nod_fil_arr_nod))
elif os.path.isdir(env_val):
nod_fil = lib_uris.gUriGen.DirectoryUri(env_val)
grph.add((node_env_nam, pc.property_rdf_data_nolist2, nod_fil))
elif os.path.exists(env_val):
nod_fil = lib_uris.gUriGen.FileUri(env_val)
grph.add((node_env_nam, pc.property_rdf_data_nolist2, nod_fil))
else:
# TODO: Beware that "\L" is transformed into "<TABLE>" by Graphviz !!!
env_val_clean = env_val.replace(">", "_").replace("<", "_").replace("&", "_").replace("\\", "_")
node_env_value = lib_util.NodeLiteral(env_val_clean)
grph.add((node_env_nam, pc.property_rdf_data_nolist2, node_env_value))
grph.add((node_process, env_prop, node_env_nam))
cgiEnv.OutCgiRdf("LAYOUT_RECT", [env_prop])
def _add_default_nodes(grph, root_node, entity_host):
logging.debug("_add_default_nodes entity_host=%s", entity_host)
current_node_hostname = lib_uris.gUriGen.HostnameUri(
lib_util.currentHostname)
grph.add(
(current_node_hostname, pc.property_information,
lib_util.NodeLiteral("Current host:" + lib_util.currentHostname)))
grph.add((root_node, pc.property_rdf_data_nolist2, current_node_hostname))
curr_username = FunctionGetUser()
current_node_user = lib_uris.gUriGen.UserUri(curr_username)
grph.add((current_node_user, pc.property_information,
lib_util.NodeLiteral("Current user:" + curr_username)))
grph.add((root_node, pc.property_rdf_data_nolist2, current_node_user))
def Main():
cgiEnv = lib_common.ScriptEnvironment()
grph = cgiEnv.GetGraph()
prop_pid_path = lib_common.MakeProp("Process")
prop_type = lib_common.MakeProp("Type")
prop_state = lib_common.MakeProp("State")
prop_inode = lib_common.MakeProp("INode")
args = [
"netstat",
'-a',
'--unix',
'-p',
]
pOpNetstat = lib_common.SubProcPOpen(args)
netstat_last_output, netstat_err = pOpNetstat.communicate()
asstr = netstat_last_output.decode("utf-8")
# Do not read the header on the first four lines.
for lin in asstr.split('\n')[4:]:
try:
sock_type = lin[25:36].strip()
sock_state = lin[36:50].strip()
sock_inode = lin[50:59].strip()
sock_path = lin[80:].strip()
except:
logging.warning("Cannot parse:%s", lin)
continue
if sock_path:
node_path = lib_uris.gUriGen.FileUri(sock_path)
grph.add((node_path, prop_type, lib_util.NodeLiteral(sock_type)))
grph.add((node_path, prop_state, lib_util.NodeLiteral(sock_state)))
grph.add((node_path, prop_inode, lib_util.NodeLiteral(sock_inode)))
sock_pid_prog = lin[59:80].strip()
if sock_pid_prog not in ["-", ""]:
sock_pid_prog_split = sock_pid_prog.split("/")
sock_pid = sock_pid_prog_split[0]
node_proc = lib_uris.gUriGen.PidUri(sock_pid)
if sock_path:
grph.add((node_path, prop_pid_path, node_proc))
cgiEnv.OutCgiRdf()
def Main():
cgiEnv = lib_common.ScriptEnvironment()
pid_int = int(cgiEnv.GetId())
pid_m_bean = cgiEnv.m_entity_id_dict["Handle"]
# TODO: Not convenient.
mbean_obj_nam = cgiEnv.m_entity_id_dict["Name"]
mbean_obj_nam = mbean_obj_nam.replace("*", ",").replace("-", "=")
grph = cgiEnv.GetGraph()
node_process = lib_uris.gUriGen.PidUri(pid_int)
jmx_data = survol_java.GetJavaDataFromJmx(pid_int, mbean_obj_nam)
jmx_data_m_beans = jmx_data["allMBeans"]
prop_m_bean = lib_common.MakeProp("MBean")
# There should be only one.
for jmx_m_bean in jmx_data_m_beans:
cls_nam = jmx_m_bean["className"]
obj_nam = jmx_m_bean["objectName"]
if obj_nam != mbean_obj_nam:
logging.error("THIS SHOULD NOT HAPPEN: %s != %s", obj_nam,
mbean_obj_nam)
# "=sun.management.ManagementFactoryHelper$1[java.nio:type=BufferPool,name=mapped]"
logging.debug("jmx_m_bean=%s", jmx_m_bean)
# Not sure about the file name
node_class = survol_mbean.MakeUri(pid_int, cls_nam)
grph.add((node_class, lib_common.MakeProp("Object name"),
lib_util.NodeLiteral(obj_nam)))
dict_m_bean_info = jmx_m_bean["info"]
for keyInfo in dict_m_bean_info:
val_info = dict_m_bean_info[keyInfo]
grph.add((node_class, lib_common.MakeProp(keyInfo),
lib_util.NodeLiteral(val_info)))
grph.add((node_class, lib_common.MakeProp("Attributes"),
lib_util.NodeLiteral(jmx_m_bean["attrs"])))
grph.add((node_process, prop_m_bean, node_class))
cgiEnv.OutCgiRdf()
def Main():
cgiEnv = lib_common.ScriptEnvironment()
pid_int = int(cgiEnv.GetId())
grph = cgiEnv.GetGraph()
node_process = lib_uris.gUriGen.PidUri(pid_int)
jmx_data = survol_java.GetJavaDataFromJmx(pid_int)
try:
jmx_data_m_beans = jmx_data["allMBeans"]
except KeyError:
jmx_data_m_beans = []
prop_m_bean = lib_common.MakeProp("MBean")
for jmx_m_bean in jmx_data_m_beans:
cls_nam = jmx_m_bean["className"]
obj_nam = jmx_m_bean["objectName"]
# "=sun.management.ManagementFactoryHelper$1[java.nio:type=BufferPool,name=mapped]"
logging.debug("jmx_m_bean=%s", jmx_m_bean)
# Not sure about the file name
node_class = survol_mbean.MakeUri(pid_int, obj_nam)
grph.add((node_class, lib_common.MakeProp("Class name"),
lib_util.NodeLiteral(cls_nam)))
grph.add((node_process, prop_m_bean, node_class))
cgiEnv.OutCgiRdf("LAYOUT_RECT", [prop_m_bean])
def Main():
cgiEnv = lib_common.ScriptEnvironment()
try:
the_pid = int(cgiEnv.GetId())
except Exception:
lib_common.ErrorMessageHtml("Must provide a pid")
grph = cgiEnv.GetGraph()
node_process = lib_uris.gUriGen.PidUri(the_pid)
CIM_Process.AddInfo(grph, node_process, [str(the_pid)])
fil_cgroups = "/proc/%d/cgroup" % the_pid
for lin_cg in open(fil_cgroups):
split_cg = lin_cg.split(':')
hierarchy = split_cg[0]
subsys_name_list = split_cg[1]
mount_path = split_cg[2]
mount_path = mount_path[:-1] # Strip trailing backslash-N
mount_path_node = lib_uris.gUriGen.DirectoryUri(mount_path)
for subsys_name in subsys_name_list.split(","):
if subsys_name:
cgrp_node = survol_cgroup.MakeUri(subsys_name)
grph.add(
(node_process, lib_common.MakeProp("CGroup"), cgrp_node))
grph.add((cgrp_node, lib_common.MakeProp("Hierarchy"),
lib_util.NodeLiteral(hierarchy)))
grph.add((cgrp_node, lib_common.MakeProp("Control group path"),
mount_path_node))
cgiEnv.OutCgiRdf()
