def do_terminate(self):
assert self.hProcess is not None
assert self.hThread is not None
start = default_timer()
logging.debug("ATTEMPT at termination")
graceful = True
if graceful:
logging.debug("### send Ctrl+C")
# avoid terminating our process
win32api.SetConsoleCtrlHandler(None, True)
win32api.GenerateConsoleCtrlEvent(win32console.CTRL_C_EVENT, self.pid)
else:
win32api.TerminateProcess(self.hProcess, 15)
self.post_terminate()
logging.debug("POST terminate DONE")
# If the HandlerRoutine parameter is NULL, a
# TRUE value causes the calling process to ignore CTRL+C input, and a
# FALSE value restores normal processing of CTRL+C input. This attribute of ignoring or processing CTRL+C is inherited by child processes.
#
# HAS TO BE called AFTER process has been terminated
win32api.SetConsoleCtrlHandler(None, False)
diff = default_timer() - start
logger.debug("Termination took: %.4f" % diff)
logging.debug("TERMINATE OVER")
def __init__(self, time_to_force_termination: int,
argument: List[str]) -> None:
self.argument = argument
basicConfig(stream=sys.stdout, level=DEBUG)
super().__init__(time_to_force_termination)
win32api.SetConsoleCtrlHandler(None, False)
win32api.SetConsoleCtrlHandler(self.handle, True)
def _stop_server(self, signalnum, frame):
"""
Confirms and stops the visualization server
signalnum:
signal number
frame:
None or a frame object
"""
# restore previous SIGINT handler
if os.name == 'nt': # windows
win32api.SetConsoleCtrlHandler(self._handle, 0)
else:
if self._sigint_handler is not None:
signal.signal(signal.SIGINT, self._sigint_handler)
self._sigint_handler = None
res = raw_input("Shutdown this visualization server ([y]/n)? ")
if not res or res[0].lower() == 'y':
print("Shutdown confirmed")
print("Shutting down server...")
self.httpd.stop()
self._thread.join()
else:
print("Resuming operations...")
self._register_sigint_handler()
def run():
if sys.platform.startswith('win'):
import win32api
import win32con
import _thread
def _win_handler(event, hook_sigint=_thread.interrupt_main):
if event == 0:
hook_sigint()
return 1
return 0
# Add the _win_handler function to the windows console's handler function list
win32api.SetConsoleCtrlHandler(_win_handler, 1)
options = docopt(__doc__)
print(options)
max_step = train_config['max_step'] if options['--max-step'] == 'None' else int(options['--max-step'])
max_episode = train_config['max_episode'] if options['--max-episode'] == 'None' else int(options['--max-episode'])
save_frequency = train_config['save_frequency'] if options['--save-frequency'] == 'None' else int(options['--save-frequency'])
name = train_config['name'] if options['--name'] == 'None' else options['--name']
seed = int(options['--seed'])
share_args, unity_args, gym_args = train_config['share'], train_config['unity'], train_config['gym']
# gym > unity > unity_env
run_params = {
'share_args': share_args,
'options': options,
'max_step': max_step,
'max_episode': max_episode,
'save_frequency': save_frequency,
'name': name,
'seed': seed,
}
if options['--gym']:
trails = int(options['--gym-models'])
if trails == 1:
gym_run(default_args=gym_args, **run_params)
elif trails > 1:
processes = []
for i in range(trails):
p = Process(target=gym_run,
args=(
gym_args,
share_args,
options,
max_step,
max_episode,
save_frequency,
name + '-' + str(i),
seed + i * 10
))
p.start()
time.sleep(1)
processes.append(p)
[p.join() for p in processes]
else:
raise Exception('trials must be greater than 0.')
else:
unity_run(default_args=unity_args, **run_params)
def globalSetUp(self):
self.setup = True
if os.name == "nt":
import win32api
win32api.SetConsoleCtrlHandler(
TestJig.on_exit,
True) # omogoci izhod tekom testiranja, izklopi vse naprave
else:
TestJig.set_exit_handler(
TestJig.on_exit
) # omogoci izhod tekom testiranja, izklopi vse naprave
TestJig.breme(0) # preventivni izklop bremena
TestJig.power_set(0.0) # preventivni izklop pred zacetkom testiranja
TestJig.izklopi(1, 2, 4) # preventivni izklop main napajanja
TestJig.izklopi(
1, 2, 5) # preventivni izklop main reverse polarity napajanja
TestJig.izklopi(1, 3, 4) # preventivni izklop service port napajanja
TestJig.izklopi(
1, 3,
5) # preventivni izklop service port reverse polarity napajanja
TestJig.connect_battery(
0) # preventivni izklop baterijskega simulatorja
def instart(cls, name, display_name=None, stay_alive=True):
from os.path import splitext, abspath
from sys import modules
cls.__svc_name_ = name
cls.__svc_display_name_ = display_name
try:
module_path = modules[cls.__module__].__file__
except AttributeError:
from sys import executable
module_path = executable
module_file = splitext(abspath(module_path))
cls.__svc_reg_class = "%s.%s" % (module_file, cls.__name__)
if stay_alive: win32api.SetConsoleCtrlHandler(lambda x: True, True)
try:
try:
print "[+] TestModule Started : %s" % (name)
win32serviceutil.QueryServiceStatus(cls.__name__)
except:
win32serviceutil.InstallService(
cls.__svc_reg_class,
cls.__svc_name_,
cls.__svc_display_name_,
startType=win32service.SERVICE_AUTO_START)
print "[+] Service Has been installed"
else:
try:
win32serviceutil.StartService(cls._svc_name_)
except Exception, e:
print "[!] %s : %s" % (e.__class__, str(e))
else:
def run(self):
log.info("pid: %s" % os.getpid())
try:
self.wait_for_journal()
except KeyboardInterrupt:
return
# TODO: windows specific
if WINDOWS:
win32api.SetConsoleCtrlHandler(self.console_ctrl_handler, 1)
with open(JOURNALFILE, "rb") as fp:
fp.seek(self.seekpos)
t = tailer.Tailer(fp)
for line in t.follow():
#print "line: %s" % repr(line)
if self.exit_requested:
break
if line == tailer.Idle:
if self.last_committed_txid != self.txid:
self.commit(self.txid, fp.tell())
time.sleep(1.0) # TODO: config
else:
self.process_line(fp, line)
log.info("exiting")
def correct_windows_signal_handlers():
"""
Corrects Windows signal handling, otherwise multiprocessing solutions will not correctly
exit if Ctrl-C is used to interrupt them.
:return:
"""
os.environ['PATH'] += os.path.pathsep + os.path.dirname(
os.path.abspath(sys.executable))
try:
# noinspection PyUnresolvedReferences
import win32api
def _handler(_, hook=_thread.interrupt_main):
hook()
return 1
win32api.SetConsoleCtrlHandler(_handler, 1)
except ImportError:
logger.warning(
"Running on Windows, but module 'win32api' could not be imported to fix signal handler.\n"
+ "Ctrl-C might break the program ..." +
"Fix: Install the module!")
def install(self):
"""Installs the service so it can be started and stopped (if it's not installed yet).
Returns:
True when installing the service was a success and false
when it failed.
"""
# Build up wrapper script
script_name = self.service.__class__.__name__
module_name = win32serviceutil.GetServiceClassString(self.service.__class__)
module_name = module_name.replace('.' + script_name, '')
print(module_name)
print(script_name)
# Enable auto-start if needed
service_start_type = None
if self.auto_start:
win32api.SetConsoleCtrlHandler(lambda control_handler: True, True)
service_start_type = win32service.SERVICE_AUTO_START
# Install the service
win32serviceutil.InstallService(
self.class_name,
self.name,
self.name,
startType = service_start_type,
description = self.description
)
def set_signal_handler(self, sigs=None):
"""Set the signal handler to manage_signal (defined in this class)
Only set handlers for:
- signal.SIGTERM, signal.SIGINT
- signal.SIGUSR1, signal.SIGUSR2
- signal.SIGHUP
:return: None
"""
if sigs is None:
sigs = (signal.SIGTERM, signal.SIGINT, signal.SIGUSR1,
signal.SIGUSR2, signal.SIGHUP)
func = self.manage_signal
if os.name == "nt": # pragma: no cover, no Windows implementation currently
try:
import win32api
win32api.SetConsoleCtrlHandler(func, True)
except ImportError:
version = ".".join([str(i) for i in os.sys.version_info[:2]])
raise Exception("pywin32 not installed for Python " + version)
else:
for sig in sigs:
signal.signal(sig, func)
def start(self,inputCSVFilePath):
self.succeeded = {}
def onExit(sig):
if sig == 2:
succeeded = self.succeeded
self.succeeded = {}
inputCSVFilePathParts = os.path.splitext(inputCSVFilePath)
outputSucceededCSVFile = open("Succeeded".join(inputCSVFilePathParts),"w",newline="")
outputSucceededCSVFileWriter = csv.writer(outputSucceededCSVFile)
outputSucceededCSVFileWriter.writerow(["Search Url","Repeats","Product ASIN"])
for (searchUrl,productASIN),repeats in succeeded.items():
if repeats > 0:
outputSucceededCSVFileWriter.writerow([searchUrl,str(repeats),productASIN])
outputSucceededCSVFile.close()
win32api.SetConsoleCtrlHandler(onExit,True)
entries = []
inputCSVFile = open(inputCSVFilePath)
inputCSVFileReader = csv.reader(inputCSVFile)
for row in itertools.islice(inputCSVFileReader,1,None):
searchUrl,repeats,*productsASINs = row
repeats = int(repeats)
for productASIN in productsASINs:
self.succeeded[(searchUrl,productASIN)] = 0
for _ in range(repeats):
entries.append((searchUrl,productsASINs))
inputCSVFile.close()
shuffle(entries)
for searchUrl,productsASINs in entries:
self.queue.put((self.openProduct,searchUrl,productsASINs))
self.queue.join()
onExit(2)
def run_app(args):
"""Run the client/server application
Parameters
----------
args
"""
# avoid one of two error messages from 'forrtl error(200)' when running
# on windows cmd - seems related to scipy's underlying Fortran
os.environ['FOR_DISABLE_CONSOLE_CTRL_HANDLER'] = 'T'
if USE_WIN32:
# Set handler for CTRL-C. Necessary to avoid `forrtl: error (200):
# program aborting...` crash on CTRL-C if we're runnging from Windows
# cmd.exe
def handler(dw_ctrl_type, hook_sigint=_thread.interrupt_main):
"""Handler for CTRL-C interrupt
"""
if dw_ctrl_type == 0: # CTRL-C
hook_sigint()
return 1 # don't chain to the next handler
return 0 # chain to the next handler
win32api.SetConsoleCtrlHandler(handler, 1)
# Create backend server process
_run_server(args)
def run():
if sys.platform.startswith('win'):
import win32api
import win32con
import _thread
def _win_handler(event, hook_sigint=_thread.interrupt_main):
if event == 0:
hook_sigint()
return 1
return 0
# Add the _win_handler function to the windows console's handler function list
win32api.SetConsoleCtrlHandler(_win_handler, 1)
options = docopt(__doc__)
print(options)
max_step = train_config['max_step'] if options['--max-step'] == 'None' else int(options['--max-step'])
max_episode = train_config['max_episode'] if options['--max-episode'] == 'None' else int(options['--max-episode'])
save_frequency = train_config['save_frequency'] if options['--save-frequency'] == 'None' else int(options['--save-frequency'])
name = train_config['name'] if options['--name'] == 'None' else options['--name']
share_args, unity_args, gym_args = train_config['share'], train_config['unity'], train_config['gym']
# gym > unity > unity_env
run_params = {
'share_args': share_args,
'options': options,
'max_step': max_step,
'max_episode': max_episode,
'save_frequency': save_frequency,
'name': name
}
gym_run(default_args=gym_args, **run_params) if options['--gym'] else unity_run(default_args=unity_args, **run_params)
def set_exit_handler(func):
try:
import win32api
win32api.SetConsoleCtrlHandler(func, True)
except ImportError:
import signal
signal.signal(signal.SIGTERM, func)
def installService(cls, name, display_name=None, stay_alive=True):
cls._svc_name_ = name
cls._svc_display_name_ = display_name or name
try:
module_path = modules[cls.__module__].__file__
except AttributeError:
# maybe py2exe went by
from sys import executable
module_path = executable
module_file = splitext(abspath(module_path))[0]
cls._svc_reg_class_ = '%s.%s' % (module_file, cls.__name__)
if stay_alive:
win32api.SetConsoleCtrlHandler(lambda x: True, True)
try:
win32serviceutil.InstallService(
cls._svc_reg_class_,
cls._svc_name_,
cls._svc_display_name_,
startType=win32service.SERVICE_AUTO_START)
print 'Installing service %s... done' % name
win32serviceutil.StartService(cls._svc_name_)
print 'Starting service %s... done' % name
print '\nAll done!'
except Exception, x:
print str(x)
def disable_os_signals(self):
if sys.platform == "win32":
import win32api # ignoring the signal
win32api.SetConsoleCtrlHandler(None, True)
else:
signal.signal(signal.SIGTERM, signal.SIG_IGN)
signal.signal(signal.SIGINT, signal.SIG_IGN)
def enable_os_signals(self):
if sys.platform == "win32":
import win32api
win32api.SetConsoleCtrlHandler(self.os_signal_handler, True)
else:
signal.signal(signal.SIGTERM, self.os_signal_handler)
signal.signal(signal.SIGINT, self.os_signal_handler)
def instart(cls, name, display_name=None, stay_alive=True):
'''
Install and Start (auto) a Service
cls : the class (derived from Service) that implement the Service
name : Service name
display_name : the name displayed in the service manager
stay_alive : Service will stop on logout if False
'''
cls._svc_name_ = name
cls._svc_display_name_ = display_name or name
try:
module_path = modules[cls.__module__].__file__
except AttributeError:
# maybe py2exe went by
from sys import executable
module_path = executable
module_file = splitext(abspath(module_path))[0]
cls._svc_reg_class_ = '%s.%s' % (module_file, cls.__name__)
if stay_alive:
win32api.SetConsoleCtrlHandler(lambda x: True, True)
try:
win32serviceutil.InstallService(
cls._svc_reg_class_,
cls._svc_name_,
cls._svc_display_name_,
startType=win32service.SERVICE_AUTO_START)
print "Install ok"
win32serviceutil.StartService(cls._svc_name_)
print 'Start ok'
except Exception, x:
print str(x)
def run():
supported_browsers=['chrome','firefox']
parser=ArgumentParser()
parser.add_argument('-u','--url',help='Set URL | Set path to URL list',metavar='URL|FILE')
parser.add_argument('-p','--processes',default=15,type=int,help='Set number of processes',metavar='N')
parser.add_argument('-B','--browser',choices=supported_browsers,help='Set browser',metavar='BROWSER')
parser.add_argument('-P','--proxies',help='Set path to proxy list',metavar='FILE')
parser.add_argument('-R','--referer',help='Set referer | Set path to referer list',metavar='REFERER|FILE')
parser.add_argument('-U','--user-agent',help='Set user agent | Set path to user agent list',metavar='USER_AGENT|FILE')
args=parser.parse_args()
urls=URLs(args.url or Input.get('URL'))
Program.browser=args.browser or Input.select('Browser',supported_browsers)
print('For next options click ENTER to use [default value].')
proxies=Proxies(args.proxies or Input.get('Proxies [proxy list from API]'))
referers=Referers(args.referer or Input.get('Referers [https://google.com]'))
user_agents=UserAgents(args.user_agent or Input.get('User agents [random user agent]'))
executable_path=WebDriver.install_if_not_installed(Program.browser)
extension_path=Extension.install_if_not_installed(Program.browser)
Program.processes=[Process(target=Bot.run,args=(urls,Program.browser,proxies,referers,user_agents,executable_path,extension_path),daemon=True) for _ in range(args.processes)]
print(f'Starting {args.processes} processes...')
for process in Program.processes:
process.start()
print(f'Started {args.processes} processes.')
if os.name=='nt':
import win32api
win32api.SetConsoleCtrlHandler(Program.quit)
elif os.name=='posix':
import signal
signal.signal(signal.SIGINT,Program.quit)
print(f'Click ctrl+c when you want to stop the bot.')
for process in Program.processes:
process.join()
def _RunChild(runfn):
del sys.argv[1] # The --spawn arg.
# Create a new thread that just waits for the event to be signalled.
t = threading.Thread(target=_WaitForShutdown,
args=(int(sys.argv[1]), )
)
del sys.argv[1] # The stop handle
# This child process will be sent a console handler notification as
# users log off, or as the system shuts down. We want to ignore these
# signals as the service parent is responsible for our shutdown.
def ConsoleHandler(what):
# We can ignore *everything* - ctrl+c will never be sent as this
# process is never attached to a console the user can press the
# key in!
return True
win32api.SetConsoleCtrlHandler(ConsoleHandler, True)
t.setDaemon(True) # we don't want to wait for this to stop!
t.start()
if hasattr(sys, "frozen"):
# py2exe sets this env vars that may screw our child process - reset
del os.environ["PYTHONPATH"]
# Start the buildbot/worker app
runfn()
print("Service child process terminating normally.")
def adjust_interrupt_handlers():
import os
import imp
import ctypes
import _thread
import win32api
# Load the DLL manually to ensure its handler gets
# set before our handler.
basepath = imp.find_module('numpy')[1]
def try_to_load(dll_path):
try:
ctypes.CDLL(dll_path)
except OSError as e:
pass
try_to_load(os.path.join(basepath, 'core', 'libmmd.dll'))
try_to_load(os.path.join(basepath, 'core', 'libifcoremd.dll'))
# Now set our handler for CTRL_C_EVENT. Other control event
# types will chain to the next handler.
def handler(dwCtrlType, hook_sigint=_thread.interrupt_main):
if dwCtrlType == 0: # CTRL_C_EVENT
hook_sigint()
return 1 # don't chain to the next handler
return 0 # chain to the next handler
win32api.SetConsoleCtrlHandler(handler, 1)
def enable_ctrl_logoff_handler():
if HAS_WIN32:
ctrl_logoff_event = 5
win32api.SetConsoleCtrlHandler(
lambda event: True if event == ctrl_logoff_event else False,
1
)
def __call_service_handler():
def __ctrlHandler(ctrlType):
return True
from opsbro.windows_service.windows_service import Service
win32api.SetConsoleCtrlHandler(__ctrlHandler, True)
win32serviceutil.HandleCommandLine(Service)
def __init__(self, config, base='', driver=None):
self.base_directory = base
today = datetime.datetime.utcnow()
if datetime.datetime.now().hour >= 10 and datetime.datetime.now(
).hour <= 16:
today = today + datetime.timedelta(days=1)
self.night = 'n' + today.strftime('%Y%m%d')
self.logger_name = 'ASCOM_CAMERA'
self.logger = utils.setup_logger(self.base_directory, self.night,
self.logger_name)
self.header_buffer = ''
# if you don't know what your driver is called, use the ASCOM Chooser
# this will give you a GUI to select it
if driver == None:
x = win32com.client.Dispatch("ASCOM.Utilities.Chooser")
x.DeviceType = 'Camera'
driver = x.Choose(None)
print("The driver is " + driver)
# initialize the camera
try:
self.camera = win32com.client.Dispatch(driver)
except:
x = win32com.client.Dispatch("ASCOM.Utilities.Chooser")
x.DeviceType = 'Camera'
driver = x.Choose(None)
print("The driver is " + driver)
win32api.SetConsoleCtrlHandler(self.safe_close, True)
atexit.register(self.safe_close, 'signal_argument')
def unhandle_ctrl(handler):
if os.name != 'nt':
signal.signal(signal.SIGINT, handler)
return 1
else:
import win32api
return win32api.SetConsoleCtrlHandler(handler, 0)
def handle_ctrl(hook_sigint=None):
if os.name != 'nt':
import signal
original_sigint_handler = signal.getsignal(signal.SIGINT)
signal.signal(signal.SIGINT, hook_sigint)
return original_sigint_handler
else:
# work around scipy's SIGINT handling: https://stackoverflow.com/a/15472811
import imp
import ctypes
import _thread
import win32api
if hook_sigint is None:
hook_sigint = _thread.interrupt_main
# Load the DLL manually to ensure its handler gets
# set before our handler.
#basepath = imp.find_module('numpy')[1]
#ctypes.CDLL(os.path.join(basepath, 'core', 'libmmd.dll'))
#ctypes.CDLL(os.path.join(basepath, 'core', 'libifcoremd.dll'))
import numpy as np
# Now set our handler for CTRL_C_EVENT. Other control event
# types will chain to the next handler.
def handler(dwCtrlType, hook_sigint=hook_sigint):
if dwCtrlType == 0: # CTRL_C_EVENT
hook_sigint()
return 1 # don't chain to the next handler
return 0 # chain to the next handler
win32api.SetConsoleCtrlHandler(handler, 1)
return handler
def start(self, open_ui=False):
async_fire_and_forget(self.async_start(open_ui=open_ui), self.loop)
# Windows does not seem to handle Ctrl+C well so as a workaround
# register a handler and manually stop the app
if sys.platform == 'win32':
import win32api
def handle_win32_interrupt(sig, func=None):
self.stop()
return True
win32api.SetConsoleCtrlHandler(handle_win32_interrupt, 1)
try:
self.loop.run_forever()
except KeyboardInterrupt:
self.loop.call_soon_threadsafe(self.loop.create_task,
self.async_stop())
self.loop.run_forever()
except:
# Catch all other exceptions and terminate the application. The loop
# exeception handler will take care of logging the actual error and
# LedFx will cleanly shutdown.
self.loop.run_until_complete(self.async_stop(exit_code = -1))
pass
finally:
self.loop.stop()
return self.exit_code
def __register_signal_handlers(self):
if operating_system.isWindows():
import win32api # pylint: disable=F0401
def quit_adapter(*args):
# The handler is called from something that is not the main thread, so we can't do
# much wx-related
event = threading.Event()
def quit():
try:
self.quitApplication()
finally:
event.set()
wx.CallAfter(quit)
event.wait()
return True
win32api.SetConsoleCtrlHandler(quit_adapter, True)
else:
import signal
def quit_adapter(*args):
return self.quitApplication()
signal.signal(signal.SIGTERM, quit_adapter)
if hasattr(signal, 'SIGHUP'):
forced_quit = lambda *args: self.quitApplication(force=True)
signal.signal(signal.SIGHUP, forced_quit) # pylint: disable=E1101
def execute_tests_in_pool(self, jobs, max_time):
# We need to issue many wait calls, so compute the final deadline and
# subtract time.time() from that as we go along.
deadline = None
if max_time:
deadline = time.time() + max_time
# Start a process pool. Copy over the data shared between all test runs.
# FIXME: Find a way to capture the worker process stderr. If the user
# interrupts the workers before we make it into our task callback, they
# will each raise a KeyboardInterrupt exception and print to stderr at
# the same time.
pool = multiprocessing.Pool(
jobs, worker_initializer,
(self.lit_config, self.parallelism_semaphores))
# Install a console-control signal handler on Windows.
if win32api is not None:
def console_ctrl_handler(type):
print('\nCtrl-C detected, terminating.')
pool.terminate()
pool.join()
abort_now()
return True
win32api.SetConsoleCtrlHandler(console_ctrl_handler, True)
try:
async_results = [
pool.apply_async(worker_run_one_test,
args=(test_index, test),
callback=self.consume_test_result)
for test_index, test in enumerate(self.tests)
]
pool.close()
# Wait for all results to come in. The callback that runs in the
# parent process will update the display.
for a in async_results:
if deadline:
a.wait(deadline - time.time())
else:
# Python condition variables cannot be interrupted unless
# they have a timeout. This can make lit unresponsive to
# KeyboardInterrupt, so do a busy wait with a timeout.
while not a.ready():
a.wait(1)
if not a.successful():
a.get() # Exceptions raised here come from the worker.
if self.hit_max_failures:
break
except:
# Stop the workers and wait for any straggling results to come in
# if we exited without waiting on every async result.
pool.terminate()
raise
finally:
pool.join()
def registerSignals():
signal.signal(signal.SIGINT, exitGracefully)
signal.signal(signal.SIGTERM, exitGracefully)
signal.signal(signal.SIGABRT, exitGracefully)
signal.signal(signal.SIGSEGV, exitGracefully)
signal.signal(signal.SIGILL, exitGracefully)
signal.signal(signal.SIGFPE, exitGracefully)
win32api.SetConsoleCtrlHandler(winExit, True)
