def CreateProcessWithLogonW(lpUsername=None, lpDomain=None, lpPassword=None, dwLogonFlags=0, lpApplicationName=None, lpCommandLine=None, dwCreationFlags=0, lpEnvironment=None, lpCurrentDirectory=None, lpStartupInfo=None): if not lpUsername: lpUsername = NULL else: lpUsername = ctypes.c_wchar_p(lpUsername) if not lpDomain: lpDomain = NULL else: lpDomain = ctypes.c_wchar_p(lpDomain) if not lpPassword: lpPassword = NULL else: lpPassword = ctypes.c_wchar_p(lpPassword) if not lpApplicationName: lpApplicationName = NULL else: lpApplicationName = ctypes.c_wchar_p(lpApplicationName) if not lpCommandLine: lpCommandLine = NULL else: lpCommandLine = ctypes.create_unicode_buffer(lpCommandLine) if not lpEnvironment: lpEnvironment = NULL else: lpEnvironment = ctypes.c_wchar_p(lpEnvironment) if not lpCurrentDirectory: lpCurrentDirectory = NULL else: lpCurrentDirectory = ctypes.c_wchar_p(lpCurrentDirectory) if not lpStartupInfo: lpStartupInfo = STARTUPINFO() lpStartupInfo.cb = ctypes.sizeof(STARTUPINFO) lpStartupInfo.lpReserved = 0 lpStartupInfo.lpDesktop = 0 lpStartupInfo.lpTitle = 0 lpStartupInfo.dwFlags = 0 lpStartupInfo.cbReserved2 = 0 lpStartupInfo.lpReserved2 = 0 lpStartupInfo.hStdInput = win32api.GetStdHandle( win32api.STD_INPUT_HANDLE) lpStartupInfo.hStdOutput = win32api.GetStdHandle( win32api.STD_OUTPUT_HANDLE) lpStartupInfo.hStdError = win32api.GetStdHandle( win32api.STD_ERROR_HANDLE) lpProcessInformation = PROCESS_INFORMATION() lpProcessInformation.hProcess = INVALID_HANDLE_VALUE lpProcessInformation.hThread = INVALID_HANDLE_VALUE lpProcessInformation.dwProcessId = 0 lpProcessInformation.dwThreadId = 0 dwCreationFlags |= win32process.CREATE_NEW_CONSOLE success = ctypes.windll.advapi32.CreateProcessWithLogonW( lpUsername, lpDomain, lpPassword, dwLogonFlags, lpApplicationName, ctypes.byref(lpCommandLine), dwCreationFlags, lpEnvironment, lpCurrentDirectory, ctypes.byref(lpStartupInfo), ctypes.byref(lpProcessInformation)) if success == FALSE: raise ctypes.WinError() win32event.WaitForSingleObject(lpProcessInformation.hProcess, win32event.INFINITE) ctypes.windll.kernel32.CloseHandle(lpProcessInformation.hProcess) ctypes.windll.kernel32.CloseHandle(lpProcessInformation.hThread) return lpProcessInformation
def assertSignaled(self, event): self.assertEqual(win32event.WaitForSingleObject(event, 0), win32event.WAIT_OBJECT_0)
def testWaitableFire(self): h = win32event.CreateWaitableTimer(None, 0, None) dt = -160 # 160 ns. win32event.SetWaitableTimer(h, dt, 0, None, None, 0) rc = win32event.WaitForSingleObject(h, 1000) self.assertEqual(rc, win32event.WAIT_OBJECT_0)
start_url1) crawl.inserttable_logging(cont_soure, str(datetime.datetime.now()), get_status, cont, time_send) get_status = 0 if cont != 0: crawl.inserttable(table, cont, '@'.join(picture_name), cont_soure, time_int) time.sleep(5) else: time.sleep(10) except Exception, e: a, b, c, d = 'error', 0, 'error', 'error', crawl.inserttable_logging(a, str(datetime.datetime.now()), b, c, d) print e, '调用函数' #logging.debug(e) continue finally: if Stop_py == 0: break if Stop_py == 0: break time.sleep(120) win32event.WaitForSingleObject(self.hWaitStop, win32event.INFINITE) if __name__ == '__main__': win32serviceutil.HandleCommandLine(SmallestPythonService)
def _WaitForShutdown(h): win32event.WaitForSingleObject(h, win32event.INFINITE) print "Shutdown requested" from twisted.internet import reactor reactor.callLater(0, reactor.stop)
def main(self): try: workdir = os.path.dirname(os.path.abspath(__file__)) monyze_config = "monyze_config.ini" config = os.path.join(workdir, monyze_config) #Проверяем версию системы. Копируем в системную папку конфигфайл. windir = os.environ['WINDIR'] is_64bits = platform.architecture()[0].find('64') != -1 if is_64bits: sys_directory = windir + r'\system32' else: sys_directory = windir + r'\sysWOW64' service_config = os.path.join(sys_directory, "monyze_config.ini" ) if not os.path.isfile(service_config): shutil.copy(config, sys_directory ) config = service_config url = 'https://monyze.ru/api_dev' with open(config) as f: id_user = f.readline().rstrip() id_computer = f.readline().rstrip() dll_path = f.readline().rstrip() #logging logConfig = { "version":1, "handlers":{ "fileHandler":{ "class":"logging.FileHandler", "formatter":"myFormatter", "filename":os.path.join(dll_path,"monyze-agent.log") } }, "loggers":{ "monyze":{ "handlers":["fileHandler"], "level":"INFO", "level":"DEBUG", } }, "formatters":{ "myFormatter":{ "format":"%(asctime)s - %(name)s - %(levelname)s - %(message)s" } } } logging.config.dictConfig(logConfig) logger = logging.getLogger("monyze.main") ohwm_dll = os.path.join(dll_path, 'OpenHardwareMonitorLib.dll') logger.info ('------------------------------------- ') logger.info ('Agent v0.0api-py starting') try: logger.info ("OpenHardwareMonitorLib.dll path: " + ohwm_dll) except: pass #pp = pprint.PrettyPrinter(indent=4) #system = platform.system() #win32_ver = platform.win32_ver() key = winreg.OpenKey(winreg.HKEY_LOCAL_MACHINE,r"Hardware\Description\System\CentralProcessor\0") winreg.CloseKey(key) adapters = ifaddr.get_adapters() logger.info ('Variables defined') driveinfo = [] cpu_load = {} openhardwaremonitor_hwtypes = ['Mainboard', 'SuperIO', 'CPU','RAM', 'GpuNvidia', 'GpuAti', 'TBalancer', 'Heatmaster', 'HDD'] openhardwaremonitor_sensortypes = ['Voltage', 'Clock', 'Temperature', 'Load','Fan', 'Flow', 'Control', 'Level', 'Factor', 'Power', 'Data', 'SmallData'] cpu_load_sensornames = ['CPU Total', 'CPU Core', 'CPU Core #1', 'CPU Core #2','CPU Core #3', 'CPU Core #4', 'CPU Core #5', 'CPU Core #6', 'CPU Core #7', 'CPU Core #8'] cpu_temperature_sensornames = ['CPU Package', 'CPU Core #1', 'CPU Core #2', 'CPU Core #3','CPU Core #4', 'CPU Core #5', 'CPU Core #6', 'CPU Core #7', 'CPU Core #8'] mb_temperature_sensornames = ['Temperature #1', 'Temperature #2', 'Temperature #3', 'Temperature #4','Temperature #5', 'Temperature #6', 'Temperature #7', 'Temperature #8'] mb_fan_sensornames = ['Fan #1', 'Fan #2', 'Fan #3', 'Fan #4','Fan #5', 'Fan #6', 'Fan #7', 'Fan #8','Fan #9', 'Fan #10', 'Fan #11', 'Fan #12'] logger.info ('OHWM initialization ') except: logger.warning(traceback.format_exc()) def initialize_openhardwaremonitor(): clr.AddReference(ohwm_dll) from OpenHardwareMonitor import Hardware handle = Hardware.Computer() handle.MainboardEnabled = True handle.CPUEnabled = True handle.RAMEnabled = True handle.GPUEnabled = True handle.HDDEnabled = True handle.Open() return handle try: HardwareHandle = initialize_openhardwaremonitor() logger.info ('OHWM initialized') except: logger.warning(traceback.format_exc()) def get_config_data(handle): try: logger.info ('Initialize device configuration') cpuinfo = {} c_count = 0 for i in handle.Hardware: i.Update() for sensor in i.Sensors: if sensor.Value: sensortypes = openhardwaremonitor_sensortypes hardwaretypes = openhardwaremonitor_hwtypes ###CPU'S### if sensor.Hardware.HardwareType == hardwaretypes.index('CPU'): if sensor.Index == 0 and sensor.SensorType == 3: c_count += 1 cpuinfo['cpu_'+str(c_count)] = sensor.Hardware.Name break if sensor.Index >= 0: c_count += 1 cpuinfo['cpu_'+str(c_count)] = sensor.Hardware.Name break net = {} net_stats = psutil.net_if_stats() for i, adapter in enumerate(adapters): try: model = adapter.nice_name nm = adapter.name.decode("utf-8") ip = "%s/%s" % (adapter.ips[0].ip, adapter.ips[0].network_prefix) reg = winreg.ConnectRegistry(None, winreg.HKEY_LOCAL_MACHINE) reg_key = winreg.OpenKey( reg, r"SYSTEM\CurrentControlSet\Control\Network\{4d36e972-e325-11ce-bfc1-08002be10318}") try: reg_subkey = winreg.OpenKey(reg_key, nm + r"\Connection") name = winreg.QueryValueEx(reg_subkey, "Name")[0] except FileNotFoundError: pass else: speed = net_stats[name][2] counters = psutil.net_io_counters(pernic=True) btx = counters[name][0] if btx > 0: net['net_'+str((i)+1)] = {'model': model,'name': name, 'speed': speed, 'addr': ip} except KeyError: continue c = wmi.WMI() logger.info ('Get disks data') hddpos = 0 for pdisk in c.query("SELECT * FROM Win32_DiskDrive"): lnames = [] if pdisk.Size: hddpos += 1 Size = round((int(pdisk.Size)/1024 ** 2), 2) for colpartition in c.query('ASSOCIATORS OF {Win32_DiskDrive.DeviceID="' + pdisk.deviceID + '"} WHERE AssocClass = Win32_DiskDriveToDiskPartition'): for logical_disk in c.query('ASSOCIATORS OF {Win32_DiskPartition.DeviceID="' + colpartition.DeviceID + '"} WHERE AssocClass = Win32_LogicalDiskToPartition'): lname = logical_disk.DeviceID if lname: lnames.append(lname) l = {'hdd_'+str(hddpos)+'': {'name': pdisk.Model,'size': Size, 'LOGICAL': lnames}} driveinfo.append(l) nodename = platform.node() oss = platform.platform() bits = platform.architecture()[0] mem = psutil.virtual_memory() swap = psutil.swap_memory() logger.info('Disks data recieved') logger.info('Device configuration initialized') config_data = { "id": { "user_id": id_user, "device_id": id_computer }, "state": "config", "device_config": { "device_name": nodename, "system": oss, "icon": "f17a", "cpu": cpuinfo, "ram": { "TotalPh": mem.total, "TotalVrt": 0, "TotalPF": swap.total, "bits": bits }, "hdd": driveinfo, "net": net } } #print(json.dumps(config_data, indent=4)) #logger.info(json.dumps(config_data, indent=4)) requests.post(url, json.dumps(config_data)) logger.info('Device configuration sent') except: logger.warning(traceback.format_exc()) def get_load_data(handle): try: memory = psutil.virtual_memory() cpu_count = 0 for i in handle.Hardware: sensortypes = openhardwaremonitor_sensortypes hardwaretypes = openhardwaremonitor_hwtypes load_sensornames = cpu_load_sensornames temp_sensornames = cpu_temperature_sensornames i.Update() ###CPU and Fans### if i.HardwareType == hardwaretypes.index('CPU'): if i.processorIndex == cpu_count: load_arr = {} temp_arr = {} cpu_load_widg_arr = [] cpu_temp_widg_arr = [] cpu_count += 1 cpu_load_data = {} for sensor in i.Sensors: if sensor.Value: #CPU Load Sensors if sensor.SensorType == sensortypes.index('Load'): if sensor.Name == load_sensornames[0] or sensor.Name == load_sensornames[1]: load_arr['total'] = round(sensor.Value) cpu_load_widg_arr.append(round(sensor.Value)) elif sensor.Name == load_sensornames[2]: load_arr['core_1'] = round(sensor.Value) elif sensor.Name == load_sensornames[3]: load_arr['core_2'] = round(sensor.Value) elif sensor.Name == load_sensornames[4]: load_arr['core_3'] = round(sensor.Value) elif sensor.Name == load_sensornames[5]: load_arr['core_4'] = round(sensor.Value) elif sensor.Name == load_sensornames[6]: load_arr['core_5'] = round(sensor.Value) elif sensor.Name == load_sensornames[7]: load_arr['core_6'] = round(sensor.Value) elif sensor.Name == load_sensornames[8]: load_arr['core_7'] = round(sensor.Value) elif sensor.Name == load_sensornames[9]: load_arr['core_8'] = round(sensor.Value) #CPU Temperature sensors elif sensor.SensorType == sensortypes.index('Temperature'): if sensor.Name == temp_sensornames[0]: temp_arr['total'] = round(sensor.Value) cpu_temp_widg_arr.append(round(sensor.Value)) elif sensor.Name == temp_sensornames[1]: temp_arr['core_1'] = round(sensor.Value) cpu_temp_widg_arr.append(round(sensor.Value)) elif sensor.Name == temp_sensornames[2]: temp_arr['core_2'] = round(sensor.Value) cpu_temp_widg_arr.append(round(sensor.Value)) elif sensor.Name == temp_sensornames[3]: temp_arr['core_3'] = round(sensor.Value) cpu_temp_widg_arr.append(round(sensor.Value)) elif sensor.Name == temp_sensornames[4]: temp_arr['core_4'] = round(sensor.Value) cpu_temp_widg_arr.append(round(sensor.Value)) elif sensor.Name == temp_sensornames[5]: temp_arr['core_5'] = round(sensor.Value) cpu_temp_widg_arr.append(round(sensor.Value)) elif sensor.Name == temp_sensornames[6]: temp_arr['core_6'] = round(sensor.Value) cpu_temp_widg_arr.append(round(sensor.Value)) elif sensor.Name == temp_sensornames[7]: temp_arr['core_7'] = round(sensor.Value) cpu_temp_widg_arr.append(round(sensor.Value)) elif sensor.Name == temp_sensornames[8]: temp_arr['core_8'] = round(sensor.Value) cpu_temp_widg_arr.append(round(sensor.Value)) elif sensor.SensorType == sensortypes.index('Clock'): continue cpu_load_data['load'] = load_arr cpu_load_data['temp'] = temp_arr cpu_pos = 'cpu_'+str(cpu_count)+'' cpu_load[cpu_pos] = cpu_load_data cpu_total_load_widg = round( sum(cpu_load_widg_arr)/len(cpu_load_widg_arr)) if len(cpu_temp_widg_arr) == 0: cpu_total_temp_widg = 'n/a' else: cpu_total_temp_widg = round( sum(cpu_temp_widg_arr)/len(cpu_temp_widg_arr)) ##Fans & MB Temperature if i.HardwareType == hardwaretypes.index('Mainboard'): mb_data = {} mb_temp_arr = {} mb_fan_arr = {} for SHardware in i.SubHardware: SHardware.Update() for sensor in SHardware.Sensors: if sensor.Value: if sensor.SensorType == sensortypes.index('Temperature'): if sensor.Name == mb_temperature_sensornames[0]: mb_temp_arr['temp_1'] = round(sensor.Value) elif sensor.Name == mb_temperature_sensornames[1]: mb_temp_arr['temp_2'] = round(sensor.Value) elif sensor.Name == mb_temperature_sensornames[2]: mb_temp_arr['temp_3'] = round(sensor.Value) elif sensor.Name == mb_temperature_sensornames[3]: mb_temp_arr['temp_4'] = round(sensor.Value) elif sensor.Name == mb_temperature_sensornames[4]: mb_temp_arr['temp_5'] = round(sensor.Value) elif sensor.Name == mb_temperature_sensornames[5]: mb_temp_arr['temp_6'] = round(sensor.Value) elif sensor.Name == mb_temperature_sensornames[6]: mb_temp_arr['temp_7'] = round(sensor.Value) elif sensor.Name == mb_temperature_sensornames[7]: mb_temp_arr['temp_8'] = round(sensor.Value) elif sensor.SensorType == sensortypes.index('Fan'): if sensor.Name == mb_fan_sensornames[0]: mb_fan_arr['fan_1'] = round(sensor.Value) elif sensor.Name == mb_fan_sensornames[1]: mb_fan_arr['fan_2'] = round(sensor.Value) elif sensor.Name == mb_fan_sensornames[2]: mb_fan_arr['fan_3'] = round(sensor.Value) elif sensor.Name == mb_fan_sensornames[3]: mb_fan_arr['fan_4'] = round(sensor.Value) elif sensor.Name == mb_fan_sensornames[4]: mb_fan_arr['fan_5'] = round(sensor.Value) elif sensor.Name == mb_fan_sensornames[5]: mb_fan_arr['fan_6'] = round(sensor.Value) elif sensor.Name == mb_fan_sensornames[6]: mb_fan_arr['fan_7'] = round(sensor.Value) elif sensor.Name == mb_fan_sensornames[7]: mb_fan_arr['fan_8'] = round(sensor.Value) elif sensor.Name == mb_fan_sensornames[8]: mb_fan_arr['fan_9'] = round(sensor.Value) elif sensor.Name == mb_fan_sensornames[9]: mb_fan_arr['fan_10'] = round(sensor.Value) mb_data['temp'] = mb_temp_arr mb_data['fans'] = mb_fan_arr ram = {"load": round(memory.percent), "AvailPh": memory.available} ##HDD### hdd = {} hdd_widgets = {} hddpos = 0 for disk in driveinfo: hddpos += 1 ldisks = [] ldisks_widgets = [] hdd_count = 'hdd_'+str(hddpos)+'' for ld in disk[hdd_count]['LOGICAL']: if ld: usage = psutil.disk_usage(ld) perc = usage.percent free = round((int(usage.free)/1024 ** 2), 2) used = round((int(usage.used)/1024 ** 2), 2) l = {'ldisk': ld, 'load': round(perc), 'free': free, 'used': used} lw = {'ldisk': ld, 'load': round(perc)} ldisks.append(l) ldisks_widgets.append(lw) x = {'ldisks': ldisks} xw = {'ldisks': ldisks_widgets} hdd[hdd_count] = x hdd_widgets[hdd_count] = xw ###NET### net = {} for i, adapter in enumerate(adapters): try: nm = adapter.name.decode("utf-8") reg = winreg.ConnectRegistry(None, winreg.HKEY_LOCAL_MACHINE) reg_key = winreg.OpenKey( reg, r"SYSTEM\CurrentControlSet\Control\Network\{4d36e972-e325-11ce-bfc1-08002be10318}") try: reg_subkey = winreg.OpenKey(reg_key, nm + r"\Connection") name = winreg.QueryValueEx(reg_subkey, "Name")[0] except FileNotFoundError: pass else: counters = psutil.net_io_counters(pernic=True) btx = counters[name][0] brx = counters[name][1] ptx = counters[name][2] prx = counters[name][3] if btx > 0 and brx > 0: netpos = 0 netpos = netpos+1 net_count = 'net_'+str(netpos) netname = name net_io = psutil.net_io_counters(pernic=True) time.sleep(1) net_io_1 = psutil.net_io_counters(pernic=True) rx = round((net_io_1[netname][1] -net_io[netname][1]) / 1024 ** 2., 4) tx = round((net_io_1[netname][0] -net_io[netname][0]) / 1024 ** 2., 4) n = {'btx': btx, 'brx': brx, 'ptx': ptx,'prx': prx, 'tx': tx, 'rx': rx} net[net_count] = (n) except KeyError: continue load_data = { "id": { "user_id": id_user, "device_id": id_computer }, "state": "load", "load": { "cpu": cpu_load, "ram": ram, "hdd": hdd, "net": net, "mb": mb_data }, "widgets": { "cpu_load": cpu_total_load_widg, "cpu_temp": cpu_total_temp_widg, "ram_load": round(memory.percent), "hdd_load": hdd_widgets, "mb_temp": mb_temp_arr, "mb_fans": mb_fan_arr } } try: #logger.info(json.dumps(load_data, indent=4)) requests.post(url, json.dumps(load_data)) #logger.info('System load sent') except: logger.warning('Error sending config data') logger.warning(traceback.format_exc()) except: logger.warning(traceback.format_exc()) rc = None try: get_config_data(HardwareHandle) except: logger.warning('Error sending config data') logger.warning(traceback.format_exc()) while rc != win32event.WAIT_OBJECT_0: try: get_load_data(HardwareHandle) except: logger.info('Error in the get_load_data function') rc = win32event.WaitForSingleObject(self.hWaitStop, 5000)
def threadLoop(): """main function for the working thread""" while True: win32event.WaitForSingleObject(event1, win32event.INFINITE) brain_turn() win32event.SetEvent(event2)
import win32security import win32event evt = win32event.CreateEvent(None, 0, 0, None) win32security.LsaRegisterPolicyChangeNotification( win32security.PolicyNotifyAuditEventsInformation, evt) print("Waiting for you change Audit policy in Management console ...") ret_code = win32event.WaitForSingleObject(evt, 1000000000) # should come back when you change Audit policy in Management console ... print(ret_code) win32security.LsaUnregisterPolicyChangeNotification( win32security.PolicyNotifyAuditEventsInformation, evt)
if o == "-p": bStartPython = 1 if o == "-r": bDumpRegistry = 1 if o == "-s": bDumpStatus = 0 if o == "-f": bDumpFolders = 1 if o == "-y": print "Doing asynch init of CE connection" async_init = 1 if async_init: event, rc = wincerapi.CeRapiInitEx() while 1: rc = win32event.WaitForSingleObject(event, 500) if rc == win32event.WAIT_OBJECT_0: # We connected. break else: print "Waiting for Initialize to complete (picture a Cancel button here :)" else: wincerapi.CeRapiInit() print "Connected to remote CE device." try: verinfo = wincerapi.CeGetVersionEx() print "The device is running windows CE version %d.%d - %s" % ( verinfo[0], verinfo[1], verinfo[4]) if bDumpStatus: print "Dumping remote machine status"
import win32process import win32event import sys args = '"{idaq_path}" "-Snothing.idc -f {connection_file}"' if __name__ == '__main__': hProcess, hThread, dwProcessId, dwThreadId = win32process.CreateProcess( None, args.format(idaq_path=sys.argv[1], connection_file=sys.argv[2]), None, None, 0, 0, None, None, win32process.STARTUPINFO()) while win32event.WAIT_OBJECT_0 != win32event.WaitForSingleObject( hProcess, win32event.INFINITE): pass
class TRCSService(win32serviceutil.ServiceFramework): '''TRCS: The Remote Control Software''' DEBUG = True _svc_name_ = "TRCSService" #服务名 _svc_display_name_ = "TRCSService" #服务在windows系统中显示的名称 _svc_description_ = "The Remote Control Software Service" #服务的描述 # 头部长度,2个字节+8个字节 HeaderSize = 10 EXEC_MY = 1 EXEC_MYC = 2 HTTP_EXEC_MY = 3 HTTP_EXEC_MYC = 4 def __init__(self, args): win32serviceutil.ServiceFramework.__init__(self, args) self.hWaitStop = win32event.CreateEvent(None, 0, 0, None) self.run = True self.listen_sock = None self.client = None self.databuf = None if self.DEBUG: self.init_debug() lexer = lex.lex(module=Mylex) self.parser = yacc.yacc(module=Myyacc) self.interpreter = MyInterpreter() def init_debug(self): self.logger = open('log.txt', 'w') def log(self, msg): if self.DEBUG: self.logger.write(msg + os.linesep) self.logger.flush() def deal_connection(self): if self.listen_sock == None: self.listen_sock = socket(AF_INET, SOCK_STREAM) # 保活两分钟 self.listen_sock.setsockopt(SOL_SOCKET, SO_KEEPALIVE, 120) # 超时5分钟,不设置超时,服务将停止不了 # self.listen_sock.settimeout(5*60) self.listen_sock.bind((gethostname(), 8140)) self.listen_sock.listen(1) self.client, addr = self.listen_sock.accept() self.log('new connection: ' + str(addr)) self.databuf = '' def exec_my(self, body): orders = self.parser.parse(body) self.interpreter.execute(orders) def exec_myc(self, body): orders = body.split(os.linesep) self.interpreter.execute(orders) def http_exec_my(self, body): f = urllib2.urlopen(body) self.exec_my(f.read()) def http_exec_myc(self, body): f = urllib2.urlopen(body) orders = f.read().split(os.linesep) self.interpreter.execute(orders) def deal_msg(self, msg_type, body): try: if msg_type == self.EXEC_MY: self.exec_my(body) elif msg_type == self.EXEC_MYC: self.exec_myc(body) elif msg_type == self.HTTP_EXEC_MY: self.http_exec_my(body) elif msg_type == self.HTTP_EXEC_MYC: self.http_exec_myc(body) else: raise Exception except Exception: self.client.sendall('Failure') else: self.client.sendall('Success') def SvcDoRun(self): while self.run: try: self.deal_connection() while True: data = self.client.recv(4096) if not data: self.client.close() break self.databuf += data while True: if self.HeaderSize > len(self.databuf): # 还没收到完整的数据包 break header = struct.unpack('!hq', self.databuf[:self.HeaderSize]) msg_type, bodysize = header if len(self.databuf) < self.HeaderSize + bodysize: # 还没收到完整的数据包 break self.log('new message: ' + str(header)) body = self.databuf[self.HeaderSize:self.HeaderSize + bodysize] body = base64.decodestring(body) self.log(body) self.deal_msg(msg_type, body) self.databuf = self.databuf[self.HeaderSize + bodysize:] except error, e: # socket出错 self.log(str(e)) if self.client: self.client.close() continue win32event.WaitForSingleObject(self.hWaitStop, win32event.INFINITE)
def main(self): self.runflag = True while self.runflag: # block for 24*60*60 seconds and wait for a stop event # it is used for a one-day loop rc = win32event.WaitForSingleObject(self.stop_event, 24 * 60 * 60) # Check to see if self.hWaitStop happened if rc == win32event.WAIT_OBJECT_0: self.log("Service has stopped") break else: try: #reading cofig.xml file, take tweet user information filepath = os.path.abspath( '../TwitterEmotionClassification/config.xml') tweetconfig = minidom.parse(filepath) consumKey = tweetconfig.getElementsByTagName( 'consumerKey')[0].childNodes[0].nodeValue comsumerSecret = tweetconfig.getElementsByTagName( 'comsumerSecret')[0].childNodes[0].nodeValue accessKey = tweetconfig.getElementsByTagName( 'accessKey')[0].childNodes[0].nodeValue accessSecret = tweetconfig.getElementsByTagName( 'accessSecret')[0].childNodes[0].nodeValue #searching topic information search_words = tweetconfig.getElementsByTagName( 'searchWords')[0].childNodes[0].nodeValue date_since = tweetconfig.getElementsByTagName( 'dateSince')[0].childNodes[0].nodeValue nb_tweets = tweetconfig.getElementsByTagName( 'nbTweets')[0].childNodes[0].nodeValue language = tweetconfig.getElementsByTagName( 'lang')[0].childNodes[0].nodeValue new_search = tweetconfig.getElementsByTagName( 'newSearch')[0].childNodes[0].nodeValue auth = tweepy.OAuthHandler(consumKey, comsumerSecret) auth.set_access_token(accessKey, accessSecret) api = tweepy.API(auth, wait_on_rate_limit=True) tweets = tweepy.Cursor(api.search, q=search_words, lang=language, since=date_since).items(nb_tweets) users_locs = [[ tweet.user.screen_name, tweet.user.location ] for tweet in tweets] users_infos = [[ tweet.user.screen_name, tweet.user.location, tweet.text, tweet.lang, tweet.favorite_count, tweet.retweet_count, tweet.created_at ] for tweet in tweets] df_tweets = pandas.DataFrame(data=users_infos, columns=[ 'user', "location", "tweet content", "language", "nb_favorite", "nb_retweet", "created_at" ]) df_tweets.to_csv( r'../TwitterEmotionClassification/tweetdata.csv', index=None, header=True) except Exception as e: self.log(str(e))
def SvcDoRun(self): """ Run the Service """ self.dispatcher = dispatcher() win32event.WaitForSingleObject(self.hWaitStop, win32event.INFINITE)
def communication_win(self, is_check): import win32event import win32file import win32api import pywintypes import winerror # event for the socket hEvent_sock = win32event.CreateEvent(None, 0, 0, None) win32file.WSAEventSelect(self.comms_socket, hEvent_sock, win32file.FD_READ) # event, overlapped struct for the pipe or tunnel hEvent_pipe = win32event.CreateEvent(None, 0, 0, None) # for reading from the pipe overlapped_pipe = pywintypes.OVERLAPPED() overlapped_pipe.hEvent = hEvent_pipe # buffer for the packets message_readfile = win32file.AllocateReadBuffer(4096) # showing if we already async reading or not not_reading_already = True first_run = True while not self._stop: try: if not self.tunnel_r: # user is not authenticated yet, so there is no pipe # only checking the socket for data rc = win32event.WaitForSingleObject( hEvent_sock, int(self.timeout * 1000)) else: # client mode so we have the socket and tunnel as well # or the client authenticated and the pipe was created if first_run or not_reading_already: # no ReadFile was called before or finished, so we # are calling it again hr, _ = win32file.ReadFile(self.tunnel_r, message_readfile, overlapped_pipe) not_reading_already = first_run = False if (hr == winerror.ERROR_IO_PENDING): # well, this was an async read, so we need to wait # until it happens rc = win32event.WaitForMultipleObjects( [hEvent_sock, hEvent_pipe], 0, int(self.timeout * 1000)) if rc == winerror.WAIT_TIMEOUT: # timed out, just rerun and wait continue else: if hr != 0: common.internal_print( "TCP ReadFile failed: {0}".format(hr), -1) raise if rc < 0x80: # STATUS_ABANDONED_WAIT_0 if rc == 0: # socket got signalled not_reading_already = False messages = self.recv() for message in messages: # looping through the messages from socket if len(message) == 0: # this could happen when the socket died or # partial message was read. continue if common.is_control_channel(message[0:1]): # parse control messages if self.controlchannel.handle_control_messages( self, message[len(common.CONTROL_CHANNEL_BYTE ):], None): continue else: self.stop() break if self.authenticated: try: # write packet to the tunnel self.packet_writer( message[len(common.CONTROL_CHANNEL_BYTE ):]) except OSError as e: print e # wut? except Exception as e: if e.args[0] == 995: common.internal_print( "Interface disappered, exiting thread: {0}" .format(e), -1) self.stop() continue if rc == 1: # pipe/tunnel got signalled not_reading_already = True if (overlapped_pipe.InternalHigh < 4) or (message_readfile[0:1] != "\x45"): #Only care about IPv4 # too small which should not happen or not IPv4, so we just drop it. continue # reading out the packet from the buffer and discarding the rest readytogo = message_readfile[0:overlapped_pipe. InternalHigh] self.send(common.DATA_CHANNEL_BYTE, readytogo, None) except win32api.error as e: common.internal_print("TCP Exception: {0}".format(e), -1) self.cleanup() return True
def runas(cmdLine, username, password=None, cwd=None): """ Run a command as another user. If the process is running as an admin or system account this method does not require a password. Other non privileged accounts need to provide a password for the user to runas. Commands are run in with the highest level privileges possible for the account provided. """ # Validate the domain and sid exist for the username try: _, domain, _ = win32security.LookupAccountName(None, username) username, _ = split_username(username) except pywintypes.error as exc: message = win32api.FormatMessage(exc.winerror).rstrip("\n") raise CommandExecutionError(message) # Elevate the token from the current process access = win32security.TOKEN_QUERY | win32security.TOKEN_ADJUST_PRIVILEGES th = win32security.OpenProcessToken(win32api.GetCurrentProcess(), access) salt.platform.win.elevate_token(th) # Try to impersonate the SYSTEM user. This process needs to be running as a # user who as been granted the SeImpersonatePrivilege, Administrator # accounts have this permission by default. try: impersonation_token = salt.platform.win.impersonate_sid( salt.platform.win.SYSTEM_SID, session_id=0, privs=["SeTcbPrivilege"], ) except OSError: log.debug("Unable to impersonate SYSTEM user") impersonation_token = None win32api.CloseHandle(th) # Impersonation of the SYSTEM user failed. Fallback to an un-privileged # runas. if not impersonation_token: log.debug("No impersonation token, using unprivileged runas") return runas_unpriv(cmdLine, username, password, cwd) if domain == "NT AUTHORITY": # Logon as a system level account, SYSTEM, LOCAL SERVICE, or NETWORK # SERVICE. user_token = win32security.LogonUser( username, domain, "", win32con.LOGON32_LOGON_SERVICE, win32con.LOGON32_PROVIDER_DEFAULT, ) elif password: # Login with a password. user_token = win32security.LogonUser( username, domain, password, win32con.LOGON32_LOGON_INTERACTIVE, win32con.LOGON32_PROVIDER_DEFAULT, ) else: # Login without a password. This always returns an elevated token. user_token = salt.platform.win.logon_msv1_s4u(username).Token # Get a linked user token to elevate if needed elevation_type = win32security.GetTokenInformation( user_token, win32security.TokenElevationType) if elevation_type > 1: user_token = win32security.GetTokenInformation( user_token, win32security.TokenLinkedToken) # Elevate the user token salt.platform.win.elevate_token(user_token) # Make sure the user's token has access to a windows station and desktop salt.platform.win.grant_winsta_and_desktop(user_token) # Create pipes for standard in, out and error streams security_attributes = win32security.SECURITY_ATTRIBUTES() security_attributes.bInheritHandle = 1 stdin_read, stdin_write = win32pipe.CreatePipe(security_attributes, 0) stdin_read = salt.platform.win.make_inheritable(stdin_read) stdout_read, stdout_write = win32pipe.CreatePipe(security_attributes, 0) stdout_write = salt.platform.win.make_inheritable(stdout_write) stderr_read, stderr_write = win32pipe.CreatePipe(security_attributes, 0) stderr_write = salt.platform.win.make_inheritable(stderr_write) # Run the process without showing a window. creationflags = (win32process.CREATE_NO_WINDOW | win32process.CREATE_NEW_CONSOLE | win32process.CREATE_SUSPENDED) startup_info = salt.platform.win.STARTUPINFO( dwFlags=win32con.STARTF_USESTDHANDLES, hStdInput=stdin_read.handle, hStdOutput=stdout_write.handle, hStdError=stderr_write.handle, ) # Create the environment for the user env = create_env(user_token, False) hProcess = None try: # Start the process in a suspended state. process_info = salt.platform.win.CreateProcessWithTokenW( int(user_token), logonflags=1, applicationname=None, commandline=cmdLine, currentdirectory=cwd, creationflags=creationflags, startupinfo=startup_info, environment=env, ) hProcess = process_info.hProcess hThread = process_info.hThread dwProcessId = process_info.dwProcessId dwThreadId = process_info.dwThreadId # We don't use these so let's close the handle salt.platform.win.kernel32.CloseHandle(stdin_write.handle) salt.platform.win.kernel32.CloseHandle(stdout_write.handle) salt.platform.win.kernel32.CloseHandle(stderr_write.handle) ret = {"pid": dwProcessId} # Resume the process psutil.Process(dwProcessId).resume() # Wait for the process to exit and get its return code. if (win32event.WaitForSingleObject( hProcess, win32event.INFINITE) == win32con.WAIT_OBJECT_0): exitcode = win32process.GetExitCodeProcess(hProcess) ret["retcode"] = exitcode # Read standard out fd_out = msvcrt.open_osfhandle(stdout_read.handle, os.O_RDONLY | os.O_TEXT) with os.fdopen(fd_out, "r") as f_out: stdout = f_out.read() ret["stdout"] = stdout # Read standard error fd_err = msvcrt.open_osfhandle(stderr_read.handle, os.O_RDONLY | os.O_TEXT) with os.fdopen(fd_err, "r") as f_err: stderr = f_err.read() ret["stderr"] = stderr finally: if hProcess is not None: salt.platform.win.kernel32.CloseHandle(hProcess) win32api.CloseHandle(th) win32api.CloseHandle(user_token) if impersonation_token: win32security.RevertToSelf() win32api.CloseHandle(impersonation_token) return ret
def SvcDoRun(self): self.logger.info("down service is run ...") self.start() win32event.WaitForSingleObject(self.hWaitStop, win32event.INFINITE)
def elevate(fn, *args, **kwargs): if is_admin(): fn(*args, **kwargs) else: # UAC elevation / sudo code working for CPython, Nuitka >= 0.6.2, PyInstaller, PyExe, CxFreeze # Regardless of the runner (CPython, Nuitka or frozen CPython), sys.argv[0] is the relative path to script, # sys.argv[1] are the arguments # The only exception being CPython on Windows where sys.argv[0] contains absolute path to script # Regarless of OS, sys.executable will contain full path to python binary for CPython and Nuitka, # and full path to frozen executable on frozen CPython # Recapitulative table create with # (CentOS 7x64 / Python 3.4 / Nuitka 0.6.1 / PyInstaller 3.4) and # (Windows 10 x64 / Python 3.7x32 / Nuitka 0.6.2.10 / PyInstaller 3.4) # -------------------------------------------------------------------------------------------------------------- # | OS | Variable | CPython | Nuitka | PyInstaller | # |------------------------------------------------------------------------------------------------------------| # | Lin | argv | ['./script.py', '-h'] | ['./test', '-h'] | ['./test.py', -h'] | # | Lin | sys.executable | /usr/bin/python3.4 | /usr/bin/python3.4 | /absolute/path/to/test | # | Win | argv | ['C:\\Python\\test.py', '-h'] | ['test', '-h'] | ['test', '-h'] | # | Win | sys.executable | C:\Python\python.exe | C:\Python\Python.exe | C:\absolute\path\to\test.exe | # -------------------------------------------------------------------------------------------------------------- # Nuitka 0.6.2 and newer define builtin __nuitka_binary_dir # Nuitka does not set the frozen attribute on sys # Nuitka < 0.6.2 can be detected in sloppy ways, ie if not sys.argv[0].endswith('.py') or len(sys.path) < 3 # Let's assume this will only be compiled with newer nuitka, and remove sloppy detections try: # Actual if statement not needed, but keeps code inspectors more happy if __nuitka_binary_dir or '__compiled__' in globals() is not None: is_nuitka_compiled = True except NameError: is_nuitka_compiled = False if is_nuitka_compiled: # On nuitka, sys.executable is the python binary, even if it does not exist in standalone, # so we need to fill runner with sys.argv[0] absolute path runner = os.path.abspath(sys.argv[0]) arguments = sys.argv[1:] # current_dir = os.path.dirname(runner) logger.debug('Running elevator as Nuitka with runner [%s]' % runner) logger.debug('Arguments are %s' % arguments) # If a freezer is used (PyInstaller, cx_freeze, py2exe) elif getattr(sys, "frozen", False): runner = os.path.abspath(sys.executable) arguments = sys.argv[1:] # current_dir = os.path.dirname(runner) logger.debug('Running elevator as Frozen with runner [%s]' % runner) logger.debug('Arguments are %s' % arguments) # If standard interpreter CPython is used else: runner = os.path.abspath(sys.executable) arguments = [os.path.abspath(sys.argv[0])] + sys.argv[1:] # current_dir = os.path.abspath(sys.argv[0]) logger.debug('Running elevator as CPython with runner [%s]' % runner) logger.debug('Arguments are %s' % arguments) if os.name == 'nt': # Re-run the function with admin rights # Join arguments and double quote each argument in order to prevent space separation arguments = ' '.join('"' + arg + '"' for arg in arguments) try: # Old method using ctypes which does not wait for executable to exit nor deos get exit code # See https://docs.microsoft.com/en-us/windows/desktop/api/shellapi/nf-shellapi-shellexecutew # int 0 means SH_HIDE window, 1 is SW_SHOWNORMAL # needs the following imports # import ctypes # ctypes.windll.shell32.ShellExecuteW(None, 'runas', runner, arguments, None, 0) # Method with exit code that waits for executable to exit, needs the following imports # import win32event # monitor process # import win32process # monitor process # from win32com.shell.shell import ShellExecuteEx # from win32com.shell import shellcon childProcess = ShellExecuteEx( nShow=0, fMask=shellcon.SEE_MASK_NOCLOSEPROCESS, lpVerb='runas', lpFile=runner, lpParameters=arguments) procHandle = childProcess['hProcess'] win32event.WaitForSingleObject(procHandle, win32event.INFINITE) exit_code = win32process.GetExitCodeProcess(procHandle) logger.debug('Child exited with code: %s' % exit_code) sys.exit(exit_code) except Exception as e: logger.info(e) logger.debug('Trace:', exc_info=True) sys.exit(255) # Linux runner and hopefully Unixes else: # Search for sudo executable in order to avoid using shell=True with subprocess sudo_path = None for path in os.environ.get('PATH', ''): if os.path.isfile(os.path.join(path, 'sudo')): sudo_path = os.path.join(path, 'sudo') if sudo_path is None: logger.error( 'Cannot find sudo executable. Cannot elevate privileges. Trying to run wihtout.' ) fn(*args, **kwargs) else: command = 'sudo "%s"%s%s' % (runner, (' ' if len(arguments) > 0 else ''), ' '.join( '"%s"' % argument for argument in arguments)) exit_code, output = command_runner(command, shell=False, timeout=None) logger.info('Child output: %s' % output) sys.exit(exit_code)
def stop(self, mode=None): # pylint: disable=too-many-branches """Terminate the process.""" if mode is None: mode = fixture_interface.TeardownMode.TERMINATE if sys.platform == "win32": # Attempt to cleanly shutdown mongod. if mode != fixture_interface.TeardownMode.KILL and self.args and self.args[ 0].find("mongod") != -1: mongo_signal_handle = None try: mongo_signal_handle = win32event.OpenEvent( win32event.EVENT_MODIFY_STATE, False, "Global\\Mongo_" + str(self._process.pid)) if not mongo_signal_handle: # The process has already died. return win32event.SetEvent(mongo_signal_handle) # Wait 60 seconds for the program to exit. status = win32event.WaitForSingleObject( self._process._handle, 60 * 1000) if status == win32event.WAIT_OBJECT_0: return except win32process.error as err: # ERROR_FILE_NOT_FOUND (winerror=2) # ERROR_ACCESS_DENIED (winerror=5) # ERROR_INVALID_HANDLE (winerror=6) # One of the above errors is received if the process has # already died. if err.winerror not in (2, 5, 6): raise finally: win32api.CloseHandle(mongo_signal_handle) print("Failed to cleanly exit the program, calling TerminateProcess() on PID: " +\ str(self._process.pid)) # Adapted from implementation of Popen.terminate() in subprocess.py of Python 2.7 # because earlier versions do not catch exceptions. try: # Have the process exit with code 0 if it is terminated by us to simplify the # success-checking logic later on. win32process.TerminateProcess(self._process._handle, 0) except win32process.error as err: # ERROR_ACCESS_DENIED (winerror=5) is received when the process # has already died. if err.winerror != winerror.ERROR_ACCESS_DENIED: raise return_code = win32process.GetExitCodeProcess( self._process._handle) if return_code == win32con.STILL_ACTIVE: raise else: try: if mode == fixture_interface.TeardownMode.KILL: self._process.kill() elif mode == fixture_interface.TeardownMode.TERMINATE: self._process.terminate() elif mode == fixture_interface.TeardownMode.ABORT: self._process.send_signal(mode.value) else: raise errors.ProcessError( "Process wrapper given unrecognized teardown mode: " + mode.value) except OSError as err: # ESRCH (errno=3) is received when the process has already died. if err.errno != 3: raise
def SvcDoRun(self): logging.info("Checking config") self.checkConfig() self.model = nowcastModel() # logging.info("Starting.....") servicemanager.LogMsg(servicemanager.EVENTLOG_INFORMATION_TYPE, servicemanager.PYS_SERVICE_STARTED,(self._svc_name_, '')) self.timeout = 60000 logging.info("Starting SvcDoRun with timeout: %s", self.timeout) mb_up = msMBDbInterface(user=self.config['DATABASE']['db_user'], password=self.config['DATABASE']['db_password'], host=self.config['DATABASE']['db_host'], db_name=self.config['DATABASE']['db_name']) next_release = mb_up.next_release_date()[0] while 1: # Wait for service stop signal, if I timeout, loop again rc = win32event.WaitForSingleObject(self.hWaitStop, self.timeout) if rc == win32event.WAIT_OBJECT_0: servicemanager.LogInfoMsg("msDbMBService Stopped") break else: try: servicemanager.LogInfoMsg("msDbMBService Querying Db") logging.info("Opening Db Connection within Service: ") now = datetime.datetime.now() incomplete_indicators = mb_up.find_incorrect_release_dates() data_correct = True if incomplete_indicators: for indicator in incomplete_indicators: logging.info("Fixing indicator: %s", str(indicator[0])) c = win32com.client.Dispatch("Macrobond.Connection") d = c.Database ts = d.FetchOneSeries(str(indicator[0])) releaseName = ts.Metadata.GetFirstValue("Release") releaseEntity = d.FetchOneEntity(releaseName) current_release = releaseEntity.Metadata.GetFirstValue("LastReleaseEventTime") next_release = releaseEntity.Metadata.GetFirstValue("NextReleaseEventTime") success = False if next_release: success = mb_up.fix_incomplete_indicator(indicator, next_release) logging.info("Fixing indicator: %s : Complete", str(indicator[0])) if not success: logging.info("Fixing indicator: %s: Incomplete. Checking again in 1hr", str(indicator[0])) self.timeout = 1000 * 60 * 60 * 5# 1s * 60 * 60 = 1hr data_correct = False if next_release.astimezone(self.tz) < now: indicator_updates = mb_up.available_updates() else: # No updates, wait until next release time until checking again. indicator_updates = [] time_diff = next_release - now error_margin_min = 15 # Error margin in minutes error_margin = 1000 * 60 * error_margin_min if data_correct: self.timeout = time_diff.total_seconds() * 1000 + error_margin else: if (time_diff.total_seconds() * 1000 + error_margin) < self.timeout: self.timeout = time_diff.total_seconds() * 1000 + error_margin if len(indicator_updates) > 0: logging.info("Updates found for: %s", str(indicator_updates)) c = win32com.client.Dispatch("Macrobond.Connection") d = c.Database all_series = d.FetchSeries(indicator_updates) logging.info("Series fetched for indicators") for num, indicator_key in enumerate(all_series): ts = all_series[num] releaseName = ts.Metadata.GetFirstValue("Release") releaseEntity = d.FetchOneEntity(releaseName) current_release = releaseEntity.Metadata.GetFirstValue("LastReleaseEventTime") next_release = releaseEntity.Metadata.GetFirstValue("NextReleaseEventTime") if not next_release: next_release = pywintypes.Time(0).replace(year=1900, month=1, day=1) if ts: logging.info("Uploading data for indicator %s", str(indicator_key)) mb_up.upload_mb_data(ts, str(indicator_key), current_release, next_release) logging.info("Upload complete for indicator %s", str(indicator_key)) next_release = mb_up.next_release_date()[0] time_diff = next_release - now error_margin_min = 15 # Error margin in minutes error_margin = 1000 * 60 * error_margin_min if (time_diff.total_seconds() * 1000 + error_margin) < self.timeout: self.timeout = time_diff.total_seconds() * 1000 + error_margin if len([indicator[0] for indicator in indicator_updates if indicator[0].find('usfcst') ]) > 0: self.LaunchModelScript() logging.info("Before email latest run is %s", str(mb_up.return_latest_run_id())) self.indicatorChange(mb_up, indicator_updates) else: logging.info("No updates found, waiting for %s minutes", str(self.timeout / 60000)) logging.info("Next Release is: %s", datetime.datetime.strftime(mb_up.next_release_date()[0], '%Y-%m-%d %H:%M')) logging.info("Next check will be: %s", datetime.datetime.strftime(now + datetime.timedelta(seconds = (self.timeout * 0.001)), '%Y-%m-%d %H:%M')) except: self.sendErrorMail(str(traceback.format_exc())) logging.info("Connection failed with: %s", traceback.format_exc()) servicemanager.LogErrorMsg(traceback.format_exc()) pass
class HIDThread(threading.Thread): def __init__(self, deviceName, devicePath, threadName=None): self.lockObject = threading.Lock() self.lockObject.acquire() self.handle = None self.text = Text self.deviceName = deviceName self.devicePath = devicePath self.abort = False self.initialized = False self._overlappedRead = win32file.OVERLAPPED() self._overlappedRead.hEvent = win32event.CreateEvent(None, 1, 0, None) self._overlappedWrite = None self.RawCallback = None self.ButtonCallback = None self.ValueCallback = None self.StopCallback = None threading.Thread.__init__( self, name=threadName if threadName else self.devicePath) @eg.LogIt def AbortThread(self): self.abort = True if self._overlappedWrite: win32event.SetEvent(self._overlappedWrite.hEvent) win32event.SetEvent(self._overlappedRead.hEvent) def run(self): #open file/device try: handle = win32file.CreateFile( self.devicePath, win32con.GENERIC_READ | win32con.GENERIC_WRITE, win32con.FILE_SHARE_READ | win32con.FILE_SHARE_WRITE, None, # no security win32con.OPEN_EXISTING, win32con.FILE_ATTRIBUTE_NORMAL | win32con.FILE_FLAG_OVERLAPPED, 0) except pywintypes.error as (errno, function, strerror): self.lockObject.release() eg.PrintError(self.text.errorOpen + self.deviceName + " (" + strerror + ")") return hidDLL = ctypes.windll.hid #setupapiDLL = ctypes.windll.setupapi #get preparsed data preparsedData = c_ulong() hidDLL.HidD_GetPreparsedData(int(handle), ctypes.byref(preparsedData)) #getCaps hidpCaps = HIDP_CAPS() hidDLL.HidP_GetCaps(preparsedData, ctypes.byref(hidpCaps)) n = hidpCaps.InputReportByteLength if n == 0: self.abort = True eg.PrintError(self.text.errorReportLength + self.deviceName) rt = c_int(0) #report type input rl = c_ulong(n) #report length maxDataL = hidDLL.HidP_MaxDataListLength(rt, preparsedData) #getting button caps bCapsArrL = c_ushort(hidpCaps.NumberInputButtonCaps) bCapsArrType = HIDP_BUTTON_CAPS * bCapsArrL.value bCapsArr = bCapsArrType() hidDLL.HidP_GetButtonCaps(rt, ctypes.byref(bCapsArr), ctypes.byref(bCapsArrL), preparsedData) #getting value caps vCapsArrL = c_ushort(hidpCaps.NumberInputValueCaps) vCapsArrType = HIDP_VALUE_CAPS * vCapsArrL.value vCapsArr = vCapsArrType() hidDLL.HidP_GetValueCaps(rt, ctypes.byref(vCapsArr), ctypes.byref(vCapsArrL), preparsedData) #parsing caps # prepare a list to find and store for each index # whether it is a button or value dataIndexType = [0] * hidpCaps.NumberInputDataIndices #list entries depending on caps for i in range(bCapsArrL.value): if bCapsArr[i].IsRange: for ii in range(bCapsArr[i].Info.Range.DataIndexMin, bCapsArr[i].Info.Range.DataIndexMax + 1): dataIndexType[ii] = 1 else: ii = bCapsArr[i].Info.NotRange.DataIndex dataIndexType[ii] = 1 for i in range(vCapsArrL.value): if vCapsArr[i].IsRange: for ii in range(vCapsArr[i].Info.Range.DataIndexMin, vCapsArr[i].Info.Range.DataIndexMax + 1): dataIndexType[ii] = 2 else: ii = vCapsArr[i].Info.NotRange.DataIndex dataIndexType[ii] = 2 #prepare data array with maximum possible length DataArrayType = HIDP_DATA * maxDataL data = DataArrayType() #initializing finished try: self.handle = handle self.initialized = True rc, newBuf = win32file.ReadFile(handle, n, self._overlappedRead) if eg.debugLevel: print self.getName() + "init done. Entering loop" self.lockObject.release() while not self.abort: if rc == 997: #error_io_pending win32event.WaitForSingleObject(self._overlappedRead.hEvent, win32event.INFINITE) buf = newBuf try: win32event.ResetEvent(self._overlappedRead.hEvent) rc, newBuf = win32file.ReadFile(handle, n, self._overlappedRead) except pywintypes.error as (errno, function, strerror): #device got disconnected so set status to waiting self.abort = True if errno == 1167: eg.PrintError(self.text.errorDisconnected + self.deviceName) else: eg.PrintError(self.text.errorRead + self.deviceName + " (" + strerror + ")") #parse data if len(buf) == n and not self.abort: #raw data events if self.RawCallback: try: self.RawCallback(buf) except Exception: eg.PrintTraceback() #handling button presses and values if maxDataL != 0: dataL = c_ulong(maxDataL) hidDLL.HidP_GetData(rt, ctypes.byref(data), ctypes.byref(dataL), preparsedData, ctypes.c_char_p(str(buf)), rl) #parse data to trigger events btnPressed = [] values = {} for i in range(dataL.value): tmpIndex = data[i].DataIndex if tmpIndex >= len(dataIndexType) or dataIndexType[ tmpIndex] == 1: #button #collect buttons pressed btnPressed.append(tmpIndex) elif dataIndexType[tmpIndex] == 2: #control value values[tmpIndex] = int(data[i].Data.RawValue) else: eg.PrintError(self.text.errorInvalidDataIndex) #value events if (self.ValueCallback): try: self.ValueCallback(values) except Exception: eg.PrintTraceback() #button events if self.ButtonCallback: try: self.ButtonCallback(btnPressed) except Exception: eg.PrintTraceback() except: self.abort = True eg.PrintError(self.text.errorRead + self.deviceName) finally: win32file.CloseHandle(handle) #free references hidDLL.HidD_FreePreparsedData(ctypes.byref(preparsedData)) #HID thread finished if self.StopCallback: try: self.StopCallback() except Exception: eg.PrintTraceback() self.handle = None
def stop(): """stop thinking""" global terminateAI terminateAI = 1 win32event.WaitForSingleObject(event2, win32event.INFINITE)
def Stop(self) -> None: win32process.TerminateProcess(self._handle, -1) res = win32event.WaitForSingleObject(self._handle, win32event.INFINITE) if res == win32event.WAIT_FAILED: raise Error("WaitForSingleObject failed.") win32api.CloseHandle(self._handle)
def SvcDoRun(self): if not self._checkConfig(): # stopped status set by caller. return self.logmsg(servicemanager.PYS_SERVICE_STARTED) child_infos = [] for bbdir in self.dirs: self.info("Starting BuildBot in directory '%s'" % (bbdir, )) hstop = self.hWaitStop cmd = '%s --spawn %d start --nodaemon %s' % (self.runner_prefix, hstop, bbdir) # print "cmd is", cmd h, t, output = self.createProcess(cmd) child_infos.append((bbdir, h, t, output)) while child_infos: handles = [self.hWaitStop] + [i[1] for i in child_infos] rc = win32event.WaitForMultipleObjects(handles, 0, # bWaitAll win32event.INFINITE) if rc == win32event.WAIT_OBJECT_0: # user sent a stop service request break else: # A child process died. For now, just log the output # and forget the process. index = rc - win32event.WAIT_OBJECT_0 - 1 bbdir, dead_handle, dead_thread, output_blocks = \ child_infos[index] status = win32process.GetExitCodeProcess(dead_handle) output = "".join(output_blocks) if not output: output = "The child process generated no output. " \ "Please check the twistd.log file in the " \ "indicated directory." self.warning("BuildBot for directory %r terminated with " "exit code %d.\n%s" % (bbdir, status, output)) del child_infos[index] if not child_infos: self.warning("All BuildBot child processes have " "terminated. Service stopping.") # Either no child processes left, or stop event set. self.ReportServiceStatus(win32service.SERVICE_STOP_PENDING) # The child processes should have also seen our stop signal # so wait for them to terminate. for bbdir, h, t, output in child_infos: for i in range(10): # 30 seconds to shutdown... self.ReportServiceStatus(win32service.SERVICE_STOP_PENDING) rc = win32event.WaitForSingleObject(h, 3000) if rc == win32event.WAIT_OBJECT_0: break # Process terminated - no need to try harder. if rc == win32event.WAIT_OBJECT_0: break self.ReportServiceStatus(win32service.SERVICE_STOP_PENDING) # If necessary, kill it if win32process.GetExitCodeProcess(h) == win32con.STILL_ACTIVE: self.warning("BuildBot process at %r failed to terminate - " "killing it" % (bbdir, )) win32api.TerminateProcess(h, 3) self.ReportServiceStatus(win32service.SERVICE_STOP_PENDING) # Wait for the redirect thread - it should have died as the remote # process terminated. # As we are shutting down, we do the join with a little more care, # reporting progress as we wait (even though we never will <wink>) for i in range(5): t.join(1) self.ReportServiceStatus(win32service.SERVICE_STOP_PENDING) if not t.isAlive(): break else: self.warning("Redirect thread did not stop!") # All done. self.logmsg(servicemanager.PYS_SERVICE_STOPPED)
sent += client.send(data) except socket.error, e: if e.args[0] == win32file.WSAEINTR: continue elif e.args[0] in (win32file.WSAEWOULDBLOCK, win32file.WSAENOBUFS): break else: raise else: self.fail("could not find socket buffer limit") events = win32file.WSAEnumNetworkEvents(client) self.assertEquals(events, {}) res = win32event.WaitForSingleObject(server_event, 1000) self.assertEquals(res, win32event.WAIT_OBJECT_0) events = win32file.WSAEnumNetworkEvents(server, server_event) self.assertEquals(events, {win32file.FD_READ: 0}) received = 0 while received < sent: try: received += len(server.recv(16 * 1024)) except socket.error, e: if e.args[0] in [win32file.WSAEINTR, win32file.WSAEWOULDBLOCK]: continue else: raise self.assertEquals(received, sent)
def join(self): win32event.WaitForSingleObject(self.processHandle, win32event.INFINITE) self.exitCode = win32process.GetExitCodeProcess(self.processHandle)
#!/usr/bin/python #-*-coding:utf-8 -*- import os, os.path, sys import win32process, win32event try: handle = win32process.CreateProcess('test.exe', '', None, None, 0, win32process.CREATE_NO_WINDOW, None, None, win32process.STARTUPINFO()) running = True except Exception, e: print "Create Error!" handle = None running = False while running: rc = win32event.WaitForSingleObject(handle[0], 1000) if rc == win32event.WAIT_OBJECT_0: running = False #end while print "GoodBye"
def assertNotSignaled(self, event): self.assertEqual(win32event.WaitForSingleObject(event, 0), win32event.WAIT_TIMEOUT)
def SvcDoRun(self): rc = None while rc != win32event.WAIT_OBJECT_0: pass rc = win32event.WaitForSingleObject(self.hWaitStop, 5000)
startup = win32process.STARTUPINFO() # FIXME: this arg quoting won't work with trailing slashes. See MSDN: CommandLineToArgvW (hProcess, hThread, processId, threadId) = win32process.CreateProcess( None, ' '.join(['"' + arg + '"' for arg in sys.argv[1:]]), None, None, True, win32process.CREATE_SUSPENDED | win32process.CREATE_BREAKAWAY_FROM_JOB, None, None, startup) # assert not win32job.IsProcessInJob(hProcess, None) hJob = win32job.CreateJobObject(None, "") extended_info = win32job.QueryInformationJobObject( hJob, win32job.JobObjectExtendedLimitInformation) extended_info['BasicLimitInformation'][ 'LimitFlags'] = win32job.JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE | win32job.JOB_OBJECT_LIMIT_BREAKAWAY_OK win32job.SetInformationJobObject( hJob, win32job.JobObjectExtendedLimitInformation, extended_info) win32job.AssignProcessToJobObject(hJob, hProcess) # n.b. intentionally leak hJob. Otherwise, when running on Windows Server 2008R2 SP1, AssignProcessToJobObject closes hJob (try !handle # in windbg before and after), and we crash with invalid handle in CloseHandle on exit hJob.Detach() win32process.ResumeThread(hThread) status = win32event.WAIT_TIMEOUT while status == win32event.WAIT_TIMEOUT: status = win32event.WaitForSingleObject(hProcess, 500) # timeout so ctrl-c works #win32process.TerminateProcess(hProcess, 1) sys.exit(win32process.GetExitCodeProcess(hProcess))
def SvcStop(self): reactor.callFromThread(reactor.stop) win32event.WaitForSingleObject(self.hWaitStop, win32event.INFINITE)