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(): cgiEnv = lib_common.CgiEnv() grph = cgiEnv.GetGraph() dsnNam = survol_odbc_dsn.GetDsnNameFromCgi(cgiEnv) sessionId = cgiEnv.m_entity_id_dict["SessionId"] sys.stderr.write("dsn=(%s) sessionId=%s\n" % (dsnNam, sessionId)) nodeSession = survol_sqlserver_dsn.MakeUri(dsnNam) ODBC_ConnectString = survol_odbc_dsn.MakeOdbcConnectionString(dsnNam) try: cnxn = pyodbc.connect(ODBC_ConnectString) sys.stderr.write("Connected: %s\n" % dsnNam) grph.add((nodeSession, lib_common.MakeProp("Session id"), lib_common.NodeLiteral(sessionId))) GetInfoConnections(grph, sessionId, nodeSession, cnxn) GetInfoSessions(grph, sessionId, nodeSession, cnxn) GetInfoRequests(grph, sessionId, nodeSession, cnxn, dsnNam) except Exception: exc = sys.exc_info()[0] lib_common.ErrorMessageHtml("nodeDsn=%s Unexpected error:%s" % (dsnNam, str(sys.exc_info()))) cgiEnv.OutCgiRdf()
def Main(): cgiEnv = lib_common.ScriptEnvironment() grph = cgiEnv.GetGraph() rpmProps = survol_rpm.rpm_properties() rpmPropName = lib_common.MakeProp("rpm") try: ts = rpm.TransactionSet() mi = ts.dbMatch() for h in mi: rpmName = h['name'] nodeRpm = survol_rpm.MakeUri(rpmName) # Unfortunately, it does not seem to work to force the type. # TODO: Maybe this is because we later try to convert to a number, # without checking the type of the data ??? for propKey in rpmProps: propRpm = rpmProps[propKey] # The value might be None. propVal = h[propKey] or "" grph.add((nodeRpm, propRpm, lib_util.NodeLiteral(propVal))) grph.add((lib_common.nodeMachine, rpmPropName, nodeRpm)) except Exception as exc: lib_common.ErrorMessageHtml("List of RPMs: Error %s" % str(exc)) cgiEnv.OutCgiRdf("LAYOUT_RECT", [rpmPropName])
def Main(): cgiEnv = lib_common.CgiEnv() grph = cgiEnv.GetGraph() listVMs = survol_java.ListJavaProcesses() #listVMs = jvPckVM.list() DEBUG("VirtualMachine.list=:") for thePid in listVMs: node_process = lib_common.gUriGen.PidUri(thePid) theProcObj = listVMs[thePid] for theKey in theProcObj: theVal = theProcObj[theKey] if theVal is None: strVal = "" else: try: strVal = str(theVal) except: strVal = "No value" DEBUG("%s = %s", theKey, strVal) grph.add((node_process, lib_common.MakeProp(theKey), lib_common.NodeLiteral(strVal))) cgiEnv.OutCgiRdf()
def Main(): cgiEnv = lib_common.CgiEnv() grph = cgiEnv.GetGraph() cgroupName = cgiEnv.GetId() cgroupNode = survol_cgroup.MakeUri(cgroupName) propCGroup = lib_common.MakeProp("cgroup") # This file contains all processes belonging to this cgroup. # Example "/sys/fs/cgroup/cpuset/cgroup.procs" # Read access might be forbidden. filNamCGroup = "/sys/fs/cgroup/%s/cgroup.procs" % cgroupName try: for lin_cg in open(filNamCGroup): procId = int(lin_cg) procNode = lib_common.gUriGen.PidUri(procId) grph.add((cgroupNode, propCGroup, procNode)) except: ERROR("Invalid cgroup:%s", cgroupName) lib_common.ErrorMessageHtml("Invalid cgroup:%s" % cgroupName) # This lists processes in a table instead of scattered nodes. # This is because there might be a lot of processes. cgiEnv.OutCgiRdf("LAYOUT_RECT", [propCGroup])
def Main(): cgiEnv = lib_common.ScriptEnvironment() grph = cgiEnv.GetGraph() dsn_nam = cgiEnv.m_entity_id_dict["Dsn"] session_id = cgiEnv.m_entity_id_dict["SessionId"] logging.debug("dsn=(%s) session_id=%s", dsn_nam, session_id) node_session = survol_sqlserver_dsn.MakeUri(dsn_nam) ODBC_ConnectString = survol_odbc_dsn.MakeOdbcConnectionString(dsn_nam) try: cnxn = pyodbc.connect(ODBC_ConnectString) logging.debug("Connected: %s", dsn_nam) grph.add((node_session, lib_common.MakeProp("Session id"), lib_util.NodeLiteral(session_id))) _get_info_connections(grph, session_id, node_session, cnxn) _get_info_sessions(grph, session_id, node_session, cnxn) _get_info_requests(grph, session_id, node_session, cnxn, dsn_nam) except Exception as exc: lib_common.ErrorMessageHtml("nodeDsn=%s Unexpected error:%s" % (dsn_nam, str(exc))) cgiEnv.OutCgiRdf()
def Main(): # If this flag is set, the script uses SLP to discover Survol 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() _survol_servers_display(grph) if flag_slp: dict_services = survol_neighborhood.GetSLPServices("survol") for key_service in dict_services: node_survol_url = _callback_node_adder(grph, key_service) grph.add((node_survol_url, 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((node_survol_url, prop_attr, lib_util.NodeLiteral(val_attr))) cgiEnv.OutCgiRdf()
def Main(): cgiEnv = lib_common.CgiEnv() pid = int(cgiEnv.GetId()) grph = cgiEnv.GetGraph() proc_obj = CIM_Process.PsutilGetProcObj(pid) nodeProcess = lib_common.gUriGen.PidUri(pid) try: all_maps = CIM_Process.PsutilProcMemmaps(proc_obj) except: exc = sys.exc_info()[1] lib_common.ErrorMessageHtml("get_memory_maps Pid=%d. Caught %s\n" % (pid, str(exc))) propMemoryRSS = lib_common.MakeProp("Resident Set Size") for map in all_maps: # This, because all Windows paths are "standardized" by us. cleanMapPath = map.path.replace("\\", "/") uriMemMap = lib_common.gUriGen.MemMapUri(cleanMapPath) grph.add((uriMemMap, propMemoryRSS, lib_common.NodeLiteral(map.rss))) grph.add((nodeProcess, pc.property_memmap, uriMemMap)) cgiEnv.OutCgiRdf("LAYOUT_SPLINE")
def Main(): cgiEnv = lib_oracle.OracleEnv() oraPackage = cgiEnv.m_entity_id_dict["Package"] oraSchema = cgiEnv.m_entity_id_dict["Schema"] grph = cgiEnv.GetGraph() node_oraPackage = oracle_package.MakeUri(cgiEnv.m_oraDatabase, oraSchema, oraPackage) node_oraSchema = oracle_schema.MakeUri(cgiEnv.m_oraDatabase, oraSchema) grph.add((node_oraSchema, pc.property_oracle_package, node_oraPackage)) # TODO: This is problematic as these could also be functions. # TODO: But when joining with ALL_OBJECTS, most rows are gone. So what to do ? sql_query = "select distinct procedure_name from all_procedures where object_type='PACKAGE' " \ "and owner='" + oraSchema + "' and object_name='" + oraPackage + "'" sys.stderr.write("sql_query=%s\n" % sql_query) result = lib_oracle.ExecuteQuery(cgiEnv.ConnectStr(), sql_query) propProcToPackage = lib_common.MakeProp("Package") for row in result: procedureName = row[0] procedureNode = oracle_procedure.MakeUri(cgiEnv.m_oraDatabase, oraSchema, procedureName) grph.add((node_oraPackage, propProcToPackage, procedureNode)) cgiEnv.OutCgiRdf("LAYOUT_SPLINE", [propProcToPackage])
def Main(): cgiEnv = lib_common.CgiEnv() grph = cgiEnv.GetGraph() #pidNum = cgiEnv.m_entity_id_dict["Pid"] #filNam = cgiEnv.m_entity_id_dict["File"] #sqlQuery_encode = cgiEnv.m_entity_id_dict["Query"] # sqlQuery_encode = cgiEnv.GetId() # TODO: This should be packaged in sql/__init__.py. #sqlQuery = lib_util.Base64Decode(sqlQuery_encode) sqlQuery = sql_query.GetEnvArgs(cgiEnv) nodeSqlQuery = sql_query.MakeUri(sqlQuery) propSheetToQuery = lib_common.MakeProp("Table dependency") list_of_tables = lib_sql.TableDependencies(sqlQuery) # Based on the pid and the filnam, find which database connection it is. for tabNam in list_of_tables: nodTab = sheet.MakeUri(tabNam) grph.add( ( nodeSqlQuery, propSheetToQuery, nodTab ) ) cgiEnv.OutCgiRdf()
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 _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.CgiEnv() pid_as_integer = int(cgiEnv.GetId()) grph = cgiEnv.GetGraph() node_process = lib_common.gUriGen.PidUri(pid_as_integer) dict_regex_sql = lib_sql.SqlRegularExpressions() arr_props = [] # TODO: Unfortunately it scans several times the memory process. for rgx_key in dict_regex_sql: rgx_sql = dict_regex_sql[rgx_key] regex_predicate = lib_common.MakeProp(rgx_key) arr_props.append(regex_predicate) try: # https://docs.python.org/3/library/re.html # re.MULTILINE | re.ASCII | re.IGNORECASE matched_sqls = memory_regex_search.GetRegexMatches(pid_as_integer, rgx_sql, re.IGNORECASE) except Exception as exc: lib_common.ErrorMessageHtml("Error:%s. Protection ?" % str(exc)) all_queries_set = set() for sql_idx in matched_sqls: sql_qry = matched_sqls[sql_idx] _process_scanned_sql_query(sql_qry, all_queries_set) _generate_from_sql_queries(grph, node_process, regex_predicate, all_queries_set, pid_as_integer) cgiEnv.OutCgiRdf("LAYOUT_RECT",arr_props)
def Main(): cgiEnv = lib_common.ScriptEnvironment() grph = cgiEnv.GetGraph() listVMs = survol_java.ListJavaProcesses() #listVMs = jvPckVM.list() logging.debug("VirtualMachine.list=:") for the_pid in listVMs: node_process = lib_uris.gUriGen.PidUri(the_pid) the_proc_obj = listVMs[the_pid] for the_key in the_proc_obj: theVal = the_proc_obj[the_key] if theVal is None: str_val = "" else: try: str_val = str(theVal) except: str_val = "No value" logging.debug("%s = %s", the_key, str_val) grph.add((node_process, lib_common.MakeProp(the_key), lib_util.NodeLiteral(str_val))) cgiEnv.OutCgiRdf()
def Main(): cgiEnv = lib_common.ScriptEnvironment() hostname = cgiEnv.GetId() node_host = lib_uris.gUriGen.HostnameUri(hostname) grph = cgiEnv.GetGraph() # Return the name of the computer, name of the user, and active and idle times for the session. # No special group membership is required for level 0 or level 10 calls. level = 10 try: lib_win32.WNetAddConnect(hostname) session_list = win32net.NetSessionEnum(level, hostname) except Exception as exc: lib_common.ErrorMessageHtml("Hostname=" + hostname + ". Exception:" + str(exc)) for elt_lst in session_list: for key_lst in elt_lst: val_lst = elt_lst[key_lst] grph.add((node_host, lib_common.MakeProp(key_lst), lib_util.NodeLiteral(val_lst))) cgiEnv.OutCgiRdf()
def Main(): # cgiEnv = lib_common.CgiEnv() cgiEnv = lib_oracle.OracleEnv() grph = cgiEnv.GetGraph() sqlQuery = sql_query.GetEnvArgs(cgiEnv) dbNam = cgiEnv.m_entity_id_dict["Db"] # This is simply the user. oraSchema = cgiEnv.OracleSchema() nodeSqlQuery = oracle_query.MakeUri(sqlQuery, dbNam) propSheetToQuery = lib_common.MakeProp("Table dependency") list_of_table_names = lib_sql.TableDependencies(sqlQuery) list_of_nodes = oracle_query.QueryToNodesList(sqlQuery, {"Db": dbNam}, list_of_table_names, oraSchema) for nodTab in list_of_nodes: grph.add((nodeSqlQuery, propSheetToQuery, nodTab)) cgiEnv.OutCgiRdf()
def Main(): cgiEnv = lib_common.CgiEnv() grph = cgiEnv.GetGraph() dsnNam = survol_odbc_dsn.GetDsnNameFromCgi(cgiEnv) sys.stderr.write("dsn=(%s)\n" % dsnNam) nodeDsn = survol_odbc_dsn.MakeUri(dsnNam) ODBC_ConnectString = survol_odbc_dsn.MakeOdbcConnectionString(dsnNam) try: cnxn = pyodbc.connect(ODBC_ConnectString) sys.stderr.write("Connected: %s\n" % dsnNam) # for prmstr in sqlgetinfo_params: for prmstr in dir(pyodbc): if not prmstr.startswith("SQL_"): continue #sys.stderr.write("prmstr: %s\n" % prmstr) # 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 AttributeError: except: grph.add( (nodeDsn, prop, lib_common.NodeLiteral("Unavailable"))) continue try: prm_value = cnxn.getinfo(prm) except: #txt = str( sys.exc_info()[1] ) #grph.add( (nodeDsn, prop, lib_common.NodeLiteral(txt) ) ) continue try: grph.add((nodeDsn, prop, lib_common.NodeLiteral(prm_value))) except: txt = str(sys.exc_info()[1]) grph.add((nodeDsn, prop, lib_common.NodeLiteral(txt))) continue except Exception: exc = sys.exc_info()[0] lib_common.ErrorMessageHtml("nodeDsn=%s Unexpected error:%s" % (dsnNam, str(sys.exc_info()))) cgiEnv.OutCgiRdf()
def Main(): cgiEnv = lib_common.CgiEnv() grph = cgiEnv.GetGraph() credNames = lib_credentials.GetCredentialsNames( "MySql" ) sys.stderr.write("Mysql servers\n") for instanceMySql in credNames: sys.stderr.write("WbemServersList instanceMySql=%s\n"%(instanceMySql)) # Do not use sources_types.mysql hostMySql = instanceMySql.split(":")[0] # TODO: Display the connection socket ? nodeHostMySql = lib_common.gUriGen.HostnameUri( hostMySql ) # Intentionaly, it does not use mysql package. # nodeInstance = lib_common.gUriGen.UriMakeFromDict("mysql/instance", { "Instance": instanceMySql } ) nodeInstance = survol_mysql_instance.MakeUri(instanceMySql) aCred = lib_credentials.GetCredentials( "MySql", instanceMySql ) grph.add( ( nodeInstance, pc.property_user, lib_common.NodeLiteral(aCred[0]) ) ) grph.add( ( nodeInstance, lib_common.MakeProp("Mysql instance"), nodeHostMySql ) ) try: pass except Exception: exc = sys.exc_info()[1] lib_common.ErrorMessageHtml("tnsnam="+tnsnam+" err="+str(exc)) cgiEnv.OutCgiRdf()
def Main(): # If this flag is set, the script uses SLP to discover WBEM Agents. paramkeySLP = "Service Location Protocol" cgiEnv = lib_common.CgiEnv(parameters={paramkeySLP: False}) flagSLP = bool(cgiEnv.get_parameters(paramkeySLP)) grph = cgiEnv.GetGraph() WbemServersDisplay(grph) if flagSLP: dictServices = survol_neighborhood.GetSLPServices("survol") for keyService in dictServices: wbemNode = AddFromWbemCimom(grph, keyService) if not wbemNode: continue grph.add((wbemNode, pc.property_information, lib_common.NodeLiteral("Service Location Protocol"))) attrsService = dictServices[keyService] for keyAttr in attrsService: propAttr = lib_common.MakeProp(keyAttr) valAttr = attrsService[keyAttr] grph.add((wbemNode, propAttr, lib_common.NodeLiteral(valAttr))) cgiEnv.OutCgiRdf()
def Main(): cgiEnv = lib_common.ScriptEnvironment() pidint = int(cgiEnv.GetId()) grph = cgiEnv.GetGraph() node_process = lib_uris.gUriGen.PidUri(pidint) try: rgx_http = r"\{[0-9A-F]{8}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{12}\}" resu_com_classes = memory_regex_search.GetRegexMatches( pidint, rgx_http) prop_com_class = lib_common.MakeProp("COM class") for class_idx in resu_com_classes: com_class_id = resu_com_classes[class_idx] # On Python3, this is a bytes which must be converted to str. com_class_id = str(com_class_id) # comClass = "{DB7A405D-208F-4E88-BA0A-132ACFA0B5B6}" for example. typelib_node = lib_uris.gUriGen.ComRegisteredTypeLibUri( com_class_id) grph.add((node_process, prop_com_class, typelib_node)) except Exception as exc: lib_common.ErrorMessageHtml("Error:%s. Protection ?" % str(exc)) cgiEnv.OutCgiRdf()
def Main(): cgiEnv = lib_common.CgiEnv() hostname = cgiEnv.GetId() nodeHost = lib_common.gUriGen.HostnameUri(hostname) grph = cgiEnv.GetGraph() # Return the name of the computer, name of the user, and active and idle times for the session. # No special group membership is required for level 0 or level 10 calls. level = 10 try: # hostname = "Titi" for example lib_win32.WNetAddConnect(hostname) sessionList = win32net.NetSessionEnum(level, hostname) except Exception: lib_common.ErrorMessageHtml("Hostname=" + hostname + ". Exception:" + str(sys.exc_info())) for eltLst in sessionList: for keyLst in eltLst: valLst = eltLst[keyLst] grph.add((nodeHost, lib_common.MakeProp(keyLst), lib_common.NodeLiteral(valLst))) cgiEnv.OutCgiRdf()
def Main(): cgiEnv = lib_common.CgiEnv() grph = cgiEnv.GetGraph() # subscriptionName=Azure.DefaultSubscription() subscriptionName = cgiEnv.m_entity_id_dict["Subscription"] (subscription_id, certificate_path) = lib_credentials.GetCredentials( "Azure", subscriptionName) sms = ServiceManagementService(subscription_id, certificate_path) subscriptionNode = subscription.MakeUri(subscriptionName) try: # This throws when running with Apache. OK with cgiserver.py lstLocations = sms.list_locations() except: lib_common.ErrorMessageHtml("Unexpected error:" + str(sys.exc_info())) result = lstLocations for loca in result: locaNode = location.MakeUri(loca.name, subscriptionName) grph.add((subscriptionNode, lib_common.MakeProp("Location"), locaNode)) cgiEnv.OutCgiRdf()
def AddNodesTablesViews(grph, fil_node, db_fil_nam): # This is imported here to avoid circular references of packages including themselves. from sources_types.sqlite import table as sqlite_table from sources_types.sqlite import view as sqlite_view logging.debug("db_fil_nam=%s", db_fil_nam) try: con = sqlite3.connect(db_fil_nam) cursor = con.cursor() # type TEXT, # name TEXT, # tbl_name TEXT, # rootpage INTEGER, # sql TEXT cursor.execute( "SELECT * FROM sqlite_master WHERE type='table' or type='view';") #[(u'table', u'tz_schema_version', u'tz_schema_version', 2, u'CREATE TABLE tz_schema_version (version INTEGER)'), for the_row in cursor.fetchall(): the_type = the_row[0] the_name = the_row[1] if the_type == 'table': name_nod = sqlite_table.MakeUri(db_fil_nam, the_name) grph.add((fil_node, lib_common.MakeProp("Table"), name_nod)) elif the_type == 'view': name_nod = sqlite_view.MakeUri(db_fil_nam, the_name) grph.add((fil_node, lib_common.MakeProp("View"), name_nod)) else: continue the_rootpage = the_row[3] grph.add((name_nod, lib_common.MakeProp("Root page"), lib_util.NodeLiteral(the_rootpage))) grph.add((name_nod, lib_common.MakeProp("Type"), lib_util.NodeLiteral(the_type))) # Do not print too much information in case there are too many tables. #theCmd = the_row[4] #grph.add( ( tabNod, pc.property_information, lib_util.NodeLiteral(theCmd) ) ) except sqlite3.DatabaseError as exc: lib_common.ErrorMessageHtml("Sqlite file:%s Caught:%s" % (db_fil_nam, str(exc))) except Exception as exc: lib_common.ErrorMessageHtml("Sqlite file:%s Unexpected error:%s" % (db_fil_nam, str(exc)))
def Main(): cgiEnv = lib_common.CgiEnv() 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() try: # listQueues = cl.get_queues() except: # exc = sys.exc_info()[1] lib_common.ErrorMessageHtml("Caught:" + str(exc)) for quList in listQueues: namQueue = quList["name"] DEBUG("q=%s", namQueue) namVHost = quList["vhost"] nodVHost = survol_rabbitmq_vhost.MakeUri(configNam, namVHost) nodeQueue = survol_rabbitmq_queue.MakeUri(configNam, namVHost, namQueue) grph.add((nodeQueue, lib_common.MakeProp("vhost"), lib_common.NodeLiteral(namVHost))) grph.add((nodeQueue, lib_common.MakeProp("vhost node"), nodVHost)) managementUrl = rabbitmq.ManagementUrlPrefix(configNam, "queues", namVHost, namQueue) grph.add((nodeQueue, lib_common.MakeProp("Management"), lib_common.NodeUrl(managementUrl))) grph.add((nodeManager, lib_common.MakeProp("Queue"), nodeQueue)) cgiEnv.OutCgiRdf()
def AddInfo(grph, node, entity_ids_arr): nam_config = entity_ids_arr[0] node_manager = survol_rabbitmq_manager.MakeUri(nam_config) # Inverted property for nicer display. grph.add( (node, lib_common.MakeProp("Configuration manager"), node_manager))
def AddNodesIpConfig(grph, rootNode, mapIpconfigs): prpNetAdapt = lib_common.MakeProp("Network adapter") for keyMap in mapIpconfigs: subMapIpconfigs = mapIpconfigs[keyMap] naNode = AddOneNodeIpConfig(grph, rootNode, keyMap, subMapIpconfigs) if naNode: grph.add((rootNode, prpNetAdapt, naNode))
def Main(): cgiEnv = lib_common.CgiEnv() configNam = cgiEnv.m_entity_id_dict["Url"] # namVHost = cgiEnv.m_entity_id_dict["VHost"] 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() try: # listExchanges = cl.get_exchanges() except: # exc = sys.exc_info()[1] lib_common.ErrorMessageHtml("Caught:" + str(exc)) for objExchange in listExchanges: namExchange = objExchange["name"] DEBUG("namExchange=%s", namExchange) namVHost = objExchange["vhost"] nodeExchange = survol_rabbitmq_exchange.MakeUri( configNam, namVHost, namExchange) nodVHost = survol_rabbitmq_vhost.MakeUri(configNam, namVHost) grph.add( (nodeExchange, lib_common.MakeProp("virtual host node"), nodVHost)) managementUrl = rabbitmq.ManagementUrlPrefix(configNam, "exchanges", namVHost, namExchange) grph.add((nodeExchange, lib_common.MakeProp("Management"), lib_common.NodeUrl(managementUrl))) grph.add((nodVHost, lib_common.MakeProp("Exchange"), nodeExchange)) cgiEnv.OutCgiRdf()
def Main(): cgiEnv = lib_common.CgiEnv() grph = cgiEnv.GetGraph() dsnNam = survol_odbc_dsn.GetDsnNameFromCgi(cgiEnv) DEBUG("dsn=(%s)", dsnNam) nodeDsn = survol_sqlserver_dsn.MakeUri(dsnNam) ODBC_ConnectString = survol_odbc_dsn.MakeOdbcConnectionString(dsnNam) try: cnxn = pyodbc.connect(ODBC_ConnectString) DEBUG("Connected: %s", dsnNam) cursorSessions = cnxn.cursor() qrySessions = """ SELECT host_name,host_process_id,session_id,program_name,client_interface_name,original_login_name,nt_domain,nt_user_name FROM sys.dm_exec_sessions """ propSqlServerSession = lib_common.MakeProp("SqlServer session") propSqlServerHostProcess = lib_common.MakeProp("Host process") propSqlServerProgramName = lib_common.MakeProp("Program name") propSqlServerClientInterface = lib_common.MakeProp("Client Interface") propSqlServerOriginalLoginName = lib_common.MakeProp("original_login_name") propSqlServerNTDomain = lib_common.MakeProp("nt_domain") propSqlServerNTUserName = lib_common.MakeProp("nt_user_name") for rowSess in cursorSessions.execute(qrySessions): DEBUG("rowSess.session_id=(%s)", rowSess.session_id) nodeSession = session.MakeUri(dsnNam, rowSess.session_id) grph.add((nodeDsn, propSqlServerSession, nodeSession)) if rowSess.host_process_id: node_process = lib_common.RemoteBox(rowSess.host_name).PidUri(rowSess.host_process_id) grph.add((node_process, pc.property_pid, lib_common.NodeLiteral(rowSess.host_process_id))) grph.add((nodeSession, propSqlServerHostProcess, node_process)) if rowSess.program_name: grph.add((nodeSession, propSqlServerProgramName, lib_common.NodeLiteral(rowSess.program_name))) if rowSess.client_interface_name: grph.add((nodeSession, propSqlServerClientInterface, lib_common.NodeLiteral(rowSess.client_interface_name))) # TODO: Make nodes with these: if rowSess.original_login_name: grph.add((nodeSession, propSqlServerOriginalLoginName, lib_common.NodeLiteral(rowSess.original_login_name))) if rowSess.nt_domain: grph.add((nodeSession, propSqlServerNTDomain, lib_common.NodeLiteral(rowSess.nt_domain))) if rowSess.nt_user_name: grph.add((nodeSession, propSqlServerNTUserName, lib_common.NodeLiteral(rowSess.nt_user_name))) except Exception: exc = sys.exc_info()[0] lib_common.ErrorMessageHtml( "nodeDsn=%s Unexpected error:%s" % (dsnNam, str(sys.exc_info()))) # cgiEnv.OutCgiRdf() cgiEnv.OutCgiRdf("LAYOUT_RECT",[propSqlServerSession,propSqlServerHostProcess])
def AddInfo(grph, node, entity_ids_arr): # TODO: SPECIAL. Imported here to avoid circular inclusions, see oracle/package_body/__init__.py from sources_types.oracle import schema as oracle_schema argDb = entity_ids_arr[0] argSchema = entity_ids_arr[1] node_oraschema = oracle_schema.MakeUri(argDb, argSchema) grph.add((node_oraschema, lib_common.MakeProp("Oracle synonym"), node))
def Main(): cgiEnv = lib_common.CgiEnv(can_process_remote=True) try: # Exception if local machine. hostName = cgiEnv.m_entity_id_dict["Domain"] except KeyError: hostName = None if not hostName or lib_util.IsLocalAddress(hostName): serverBox = lib_common.gUriGen serverNode = lib_common.nodeMachine servName_or_None = None else: serverBox = lib_common.RemoteBox(hostName) serverNode = lib_common.gUriGen.HostnameUri(hostName) servName_or_None = hostName # hostname = "Titi" for example # lib_win32.WNetAddConnect(hostName) userName = cgiEnv.m_entity_id_dict["Name"] grph = cgiEnv.GetGraph() nodeUser = survol_Win32_UserAccount.MakeUri(userName, hostName) try: infoList = win32net.NetUserGetInfo(servName_or_None, userName, 2) except: lib_common.ErrorMessageHtml("Error:" + str(sys.exc_info())) for infoKey in infoList: try: infoVal = infoList[infoKey] grph.add((nodeUser, lib_common.MakeProp(infoKey), lib_common.NodeLiteral(infoVal))) except: txtDisp = str(sys.exc_info()[1]) grph.add((nodeUser, lib_common.MakeProp(infoKey), lib_common.NodeLiteral(txtDisp))) cgiEnv.OutCgiRdf()