def run(self, q):
# Block SIGTERM and SIGINT to allow graceful shutdown and cleanup after initialization
signal.pthread_sigmask(signal.SIG_BLOCK,
[signal.SIGTERM, signal.SIGINT])
with ExitStack() as stack:
try:
server = stack.enter_context(self._create_server())
port = server.add_insecure_port("127.0.0.1:0")
server.start()
except Exception:
q.put(None)
raise
# Send port to parent
q.put(port)
# Sleep until termination by signal
signal.sigwait([signal.SIGTERM, signal.SIGINT])
server.stop(0)
# Save collected coverage data
try:
from pytest_cov.embed import cleanup
except ImportError:
pass
else:
cleanup()
def t_func():
try:
#Wait for shutdown signal if running in service mode
print("Press Ctrl-C to quit...")
if sys.platform == "win32":
hwnd = _win32_create_message_hwnd()
def _stop_loop():
_win32_post_hwnd_close(hwnd)
try:
atexit.register(_stop_loop)
_win32_wait_message_hwnd(hwnd)
finally:
try:
atexit.unregister(_stop_loop)
except Exception:
pass
else:
import signal
signal.sigwait([signal.SIGTERM, signal.SIGINT])
except Exception:
traceback.print_exc()
callback()
def run(self):
try:
while True:
signal.sigwait([signal.SIGINT])
self.kernel.process.SendAsyncInterrupt()
except Exception as e:
self.kernel.log.error('Exception in SIGINTHandler: %s' % str(e))
def run(self):
"""
按注册顺序启动所有worker，阻塞主进程。
Hub在接收到 ``SIGTERM`` 或者 ``SIGINT`` 时会尝试安全退出。
Start workers and block the main process.
Hub tries to shutdown itself gracefully when receiving
``SIGTERM`` or ``SIGINT``.
"""
with self._mu:
self._assert_ready()
assert len(self._workers) > 0, 'no worker registered'
for worker in self._workers:
worker.start()
signal.sigwait((signal.SIGINT, signal.SIGTERM))
self.close()
for worker in self._workers:
try:
# close method does not exist until Python 3.7 and better
if getattr(worker, 'close', False):
worker.close()
except Exception as e:
logging.error(
'[resource leak warning] failed to close process "%s": %s',
worker._name, e)
def wait_exit():
#Wait for shutdown signal if running in service mode
print("Press Ctrl-C to quit...")
if sys.platform == "win32":
_win32_wait_exit()
else:
import signal
signal.sigwait([signal.SIGTERM, signal.SIGINT])
def receive_button(d):
while True:
print('waiting')
# signal.signal(signal.SIGUSR1, receive_signal)
signal.sigwait((signal.SIGUSR1, ))
socketsend("fire", d.getLatitude(), d.getLongitude(),
d.getPersonalid())
print('socketsend')
print('Senyal d emergencia enviada')
def __del__(self):
if not self.tb_process or self.tb_process.poll():
return
if self.wait_tb:
print('Finished, press Ctrl+C to exit TensorBoard',
file=sys.stderr)
sigwait([SIGINT])
self.tb_process.terminate()
def main():
parser = argparse.ArgumentParser(
description="Example Robot Raconteur iRobot Create service")
parser.add_argument("--nodename",
type=str,
default="sense_hat.SenseHat",
help="The NodeName to use")
parser.add_argument("--tcp-port",
type=int,
default=2354,
help="The listen TCP port")
parser.add_argument("--wait-signal",
action='store_const',
const=True,
default=False)
args = parser.parse_args()
sense = SenseHat()
imu_service = Sense_hat_IMU(sense)
sensor_hat_service = Sense_hat(sense, imu_service)
with RR.ServerNodeSetup(args.nodename, args.tcp_port) as node_setup:
RRN.RegisterServiceTypeFromFile("com.robotraconteur.uuid")
RRN.RegisterServiceTypeFromFile("com.robotraconteur.identifier")
RRN.RegisterServiceTypeFromFile("com.robotraconteur.geometry")
RRN.RegisterServiceTypeFromFile("com.robotraconteur.color")
RRN.RegisterServiceTypeFromFile("com.robotraconteur.datetime")
RRN.RegisterServiceTypeFromFile("com.robotraconteur.sensordata")
RRN.RegisterServiceTypeFromFile("com.robotraconteur.resource")
RRN.RegisterServiceTypeFromFile("com.robotraconteur.device")
RRN.RegisterServiceTypeFromFile("com.robotraconteur.datatype")
RRN.RegisterServiceTypeFromFile("com.robotraconteur.param")
RRN.RegisterServiceTypeFromFile("com.robotraconteur.units")
RRN.RegisterServiceTypeFromFile("com.robotraconteur.sensor")
RRN.RegisterServiceTypeFromFile("com.robotraconteur.imu")
RRN.RegisterServiceTypeFromFile("experimental.sensehat")
RRN.RegisterService("SensorHat", "experimental.sensehat.SenseHat",
sensor_hat_service)
RRN.RegisterService("SensorHatIMU", "com.robotraconteur.imu.ImuSensor",
imu_service)
sensor_hat_service.joystick_thread.start()
if args.wait_signal:
#Wait for shutdown signal if running in service mode
print("Press Ctrl-C to quit...")
import signal
signal.sigwait([signal.SIGTERM, signal.SIGINT])
else:
#Wait for the user to shutdown the service
if (sys.version_info > (3, 0)):
input("Server started, press enter to quit...")
else:
raw_input("Server started, press enter to quit...")
def main():
#Accept the names of the webcams and the nodename from command line
parser = argparse.ArgumentParser(description="Example Robot Raconteur webcam service")
parser.add_argument("--camera-names",type=str,help="List of camera names separated with commas")
parser.add_argument("--nodename",type=str,default="experimental.createwebcam2.WebcamHost",help="The NodeName to use")
parser.add_argument("--tcp-port",type=int,default=2366,help="The listen TCP port")
parser.add_argument("--wait-signal",action='store_const',const=True,default=False)
args = parser.parse_args()
#Initialize the webcam host root object
camera_names=[(0,"Left"),(1,"Right")]
if args.camera_names is not None:
camera_names_split=list(filter(None,args.camera_names.split(',')))
assert(len(camera_names_split) > 0)
camera_names = [(i,camera_names_split[i]) for i in range(len(camera_names_split))]
obj=WebcamHost_impl(camera_names)
with RR.ServerNodeSetup(args.nodename,args.tcp_port) as node_setup:
RRN.RegisterServiceTypeFromFile("robdef/experimental.createwebcam2")
RRN.RegisterService("Webcam","experimental.createwebcam2.WebcamHost",obj)
node_setup.tcp_transport.AddWebSocketAllowedOrigin("http://localhost")
node_setup.tcp_transport.AddWebSocketAllowedOrigin("http://localhost:8000")
node_setup.tcp_transport.AddWebSocketAllowedOrigin("https://johnwason.github.io")
#password: cats111!
authdata="cats be7af03a538bf30343a501cb1c8237a0 objectlock"
p=RR.PasswordFileUserAuthenticator(authdata)
policies={"requirevaliduser" : "true"}
s=RR.ServiceSecurityPolicy(p,policies)
c1=obj.get_Webcams(0)[0]
c1.CaptureFrameToBuffer()
if args.wait_signal:
#Wait for shutdown signal if running in service mode
print("Press Ctrl-C to quit...")
import signal
signal.sigwait([signal.SIGTERM,signal.SIGINT])
else:
#Wait for the user to shutdown the service
if (sys.version_info > (3, 0)):
input("Server started, press enter to quit...")
else:
raw_input("Server started, press enter to quit...")
#Shutdown
obj.Shutdown()
def wait(self, timeout=None):
success = False
if timeout is None:
signal.sigwait({
self._signalnum,
})
success = True
else:
success = (signal.sigtimedwait({
self._signalnum,
}, timeout) is not None)
self._occured = success
return success
def main():
#Accept the names of the webcams and the nodename from command line
parser = argparse.ArgumentParser(
description="Gym Duckiebot Simulation Robot Raconteur Service")
parser.add_argument("--nodename",
type=str,
default="experimental.gymDuckiebotSim.DuckiebotSim",
help="The NodeName to use")
parser.add_argument(
"--tcp-port", type=int, default=2356,
help="The listen TCP port") #random port, any unused port is fine
parser.add_argument("--wait-signal",
action='store_const',
const=True,
default=False)
args = parser.parse_args()
#Initialize the objects in the service
obj = gymDuckiebotSimRRService()
with RR.ServerNodeSetup(args.nodename, args.tcp_port) as node_setup:
RRN.RegisterServiceTypeFromFile(
"experimental.gymDuckiebotSim") # This is the .robdef file
RRN.RegisterService("DuckiebotSim",
"experimental.gymDuckiebotSim.DuckiebotSim", obj)
# These are for using the service on Web Browsers
node_setup.tcp_transport.AddWebSocketAllowedOrigin("http://localhost")
node_setup.tcp_transport.AddWebSocketAllowedOrigin(
"http://localhost:8000")
node_setup.tcp_transport.AddWebSocketAllowedOrigin(
"https://johnwason.github.io")
if args.wait_signal:
#Wait for shutdown signal if running in service mode
print("Press Ctrl-C to quit...")
import signal
signal.sigwait([signal.SIGTERM, signal.SIGINT])
else:
#Wait for the user to shutdown the service
if (sys.version_info > (3, 0)):
input("Server started, press enter to quit...")
else:
raw_input("Server started, press enter to quit...")
#Shutdown
obj.Shutdown()
def __run(args: Namespace, camguard: Any) -> None:
"""Runs camguard as program or daemonized process.
Shutdown is done by handling SystemExit exception.
Args:
args (Namespace): argument storage object, which is returned from parsing arguments
camguard (Any): camguard instance to run
"""
if args.daemonize:
return __run_daemonized(args, camguard)
camguard.start()
LOGGER.info("Camguard running, press ctrl-c to quit")
sigwait((SIGINT, ))
__shutdown(camguard, SIGINT)
def run_forever(self, listen_port=None):
with self._lock:
self._transfer_status(tm_pb.MasterStatus.CREATED,
tm_pb.MasterStatus.INITIALING)
if listen_port:
self._run_grpc_server(listen_port)
while self._cluster_server is None:
# waiting receive cluster_def from worker0
with self._lock:
if self._worker0_cluster_def:
fl_logging.info("received worker_0 cluster_def: %s",
self._worker0_cluster_def)
self._cluster_server = ClusterServer(
tf.train.ClusterSpec(self._worker0_cluster_def),
"master")
break
fl_logging.info("still waiting receive cluster_def from worker_0")
time.sleep(2)
self._run()
sig = signal.sigwait([signal.SIGHUP, signal.SIGINT, signal.SIGTERM])
fl_logging.info("Server shutdown by signal: %s",
signal.Signals(sig).name)
def main(self):
setproctitle('logd')
self.init_configstore()
self.init_syslog_server()
self.init_klog()
self.init_rpc_server()
self.init_flush()
self.load_configuration()
checkin()
signal.signal(signal.SIGUSR1, signal.SIG_DFL)
signal.signal(signal.SIGHUP, signal.SIG_DFL)
while True:
sig = signal.sigwait([signal.SIGTERM, signal.SIGUSR1, signal.SIGHUP])
if sig == signal.SIGUSR1:
with self.cv:
logging.info('Flushing logs on signal')
self.flush = True
self.cv.notify_all()
continue
if sig == signal.SIGHUP:
logging.info('Reloading configuration on SIGHUP')
self.load_configuration()
continue
if sig == signal.SIGTERM:
logging.info('Got SIGTERM, exiting')
with self.cv:
self.exiting = True
self.cv.notify_all()
self.flush_thread.join()
break
def run(program, *args):
register_signals()
if fcntl.ioctl(0, termios.TIOCNOTTY) == -1:
logger.warn("Unable to detach from controlling tty")
else:
if os.getsid(0) == os.getpid():
logger.info(
"Detached from controlling tty, ignoring the first SIGHUP and SIGCONT we receive"
)
IGNORED_SIGMAP[signal.SIGHUP] = 1
IGNORED_SIGMAP[signal.SIGCONT] = 1
else:
logger.info("Detached from controlling tty, but was not session leader.")
child_pid = os.fork()
if child_pid < 0:
logger.error("Unable to fork. Exiting.")
return 1
elif child_pid == 0:
if use_setsid:
os.setsid()
os.execvp(program, args)
return 2
else:
logger.info(f"Child spawned with PID {child_pid}.")
while True:
signum = signal.sigwait(set(SIGMAP.keys()))
handle_signal(signum)
def main(self):
setproctitle('logd')
self.init_syslog_server()
self.init_klog()
self.init_rpc_server()
self.init_flush()
checkin()
signal.signal(signal.SIGUSR1, signal.SIG_DFL)
while True:
sig = signal.sigwait([signal.SIGTERM, signal.SIGUSR1])
if sig == signal.SIGUSR1:
with self.cv:
logging.info('Flushing logs on signal')
self.flush = True
self.cv.notify_all()
continue
if sig == signal.SIGTERM:
logging.info('Got SIGTERM, exiting')
with self.cv:
self.exiting = True
self.cv.notify_all()
self.flush_thread.join()
break
def main():
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument("-v",
"--verbose",
action="count",
default=0,
help="Increase verbosity.")
args = parser.parse_args()
if args.verbose >= 3:
level = logging.DEBUG
elif args.verbose >= 2:
level = logging.INFO
elif args.verbose >= 1:
level = logging.WARNING
else:
level = logging.ERROR
logging.basicConfig(level=level,
format="[%(levelname)s] application: %(message)s")
sysrepo.configure_logging(py_logging=True)
try:
with sysrepo.SysrepoConnection() as conn:
with conn.start_session() as sess:
logging.info("subscribing to module changes: sysrepo-example")
sess.subscribe_module_change("sysrepo-example", None,
module_change_cb)
logging.info(
"subscribing to operational data requests: /sysrepo-example:state"
)
sess.subscribe_oper_data_request("sysrepo-example",
"/sysrepo-example:state",
oper_data_cb)
logging.info(
"subscribing to rpc calls: /sysrepo-example:poweroff")
sess.subscribe_rpc_call("/sysrepo-example:poweroff", poweroff)
logging.info(
"subscribing to action calls: /sysrepo-example:conf/security/alarm/trigger"
)
sess.subscribe_rpc_call(
"/sysrepo-example:conf/security/alarm/trigger",
trigger_alarm)
signal.sigwait({signal.SIGINT, signal.SIGTERM})
return 0
except sysrepo.SysrepoError as e:
logging.error("%s", e)
return 1
def __call__(self, args=None):
parser = terminal.configure_parser(__doc__, log_params=False)
parser.add_argument(
'--status-queue',
metavar='ADDR',
default=const.STATUS_QUEUE,
help="The address of the queue used to report status to monitors "
"(default: %(default)s)")
parser.add_argument(
'--control-queue',
metavar='ADDR',
default=const.CONTROL_QUEUE,
help="The address of the queue a monitor can use to control the "
"master (default: %(default)s)")
parser.add_argument(
'-r',
'--rotate',
metavar='DEGREES',
default=0,
type=int,
help="The rotation of the HAT in degrees; must be 0 (the default) "
"90, 180, or 270")
try:
config = parser.parse_args(args)
except: # pylint: disable=bare-except
return terminal.error_handler(*sys.exc_info())
with SenseHAT() as hat:
hat.rotation = config.rotate
ctx = zmq.Context()
try:
stick = StickTask(config, hat)
stick.start()
screen = ScreenTask(config, hat)
screen.start()
signal.sigwait({signal.SIGINT, signal.SIGTERM})
except KeyboardInterrupt:
pass
finally:
screen.quit()
screen.join()
stick.quit()
stick.join()
ctx.destroy(linger=1000)
ctx.term()
hat.screen.fade_to(array(Color('black')))
def receive_button(d):
while True:
# signal.signal(signal.SIGUSR1, receive_signal)
signal.sigwait((signal.SIGUSR1, ))
print('¡Button pushed!')
if d.getType() == 3: # Envia senyal d'alarma el detector de fums
functionSocket(d.getBackendID(), d.getLongitude(), d.getLatitude(),
'fire')
d.setStatus(1)
print("Alarma d'incendi enviada!")
elif d.getType() == 4: # Envia senyal d'alarma el Pacient
anomaly_on_sensors = d.getAnomaly()
if anomaly_on_sensors == True:
print("Emergencia enviada (sensors)!")
functionSocket(d.getBackendID(), d.getLongitude(),
d.getLatitude(), 'pacientEmitAlarm')
else:
print("Emergencia enviada (general)!")
functionSocket(d.getBackendID(), d.getLongitude(),
d.getLatitude(), 'pacientEmitGeneral')
def akashi_cli() -> None:
# [XXX] argument_parse() must be called before configuring signals, or weird bugs occur
parsed_option = argument_parse()
if parsed_option.action == 'init':
return do_init(parsed_option)
if 'LD_LIBRARY_PATH' in os.environ.keys():
os.environ['LD_LIBRARY_PATH'] += os.pathsep + LIBRARY_PATH
else:
os.environ['LD_LIBRARY_PATH'] = LIBRARY_PATH
if 'LD_PRELOAD' in os.environ.keys():
os.environ['LD_PRELOAD'] += os.pathsep + libpython_path()
else:
os.environ['LD_PRELOAD'] = libpython_path()
if 'QT_LOGGING_RULES' not in os.environ.keys():
os.environ['QT_LOGGING_RULES'] = '*=false;*.critical=true'
os.environ['QT_XCB_GL_INTEGRATION'] = 'xcb_egl'
if 'AK_ASSET_DIR' not in os.environ.keys():
os.environ['AK_ASSET_DIR'] = ASSETS_DIR
os.environ['AK_CORE_ARGS'] = " ".join(
[path.abspath(parsed_option.conf_path)] + parsed_option.run_args)
sigset: list[signal.Signals] = []
sigset += [signal.SIGINT, signal.SIGHUP, signal.SIGQUIT, signal.SIGTERM]
sigset += [signal.SIGPIPE, signal.SIGCHLD]
signal.pthread_sigmask(signal.SIG_BLOCK, sigset)
th_server = ServerThread(parsed_option)
th_server.start()
signal.sigwait(sigset)
th_server.terminate()
print('')
def signal_handler_loop(child_pid, session_leader):
"""Wait for signals and handle them."""
try:
while True:
signum = signal.sigwait(all_signals)
handle_signal(signum, child_pid, session_leader)
except SystemExit as sys_exit:
log.debug("Init process terminates (exit=%d)", sys_exit.code)
sys.exit(sys_exit.code)
except:
log.error("Unexpected exception thrown in signal handling")
traceback.print_exc()
sys.exit(1) # make sure we never return but exit!
def main():
parser = argparse.ArgumentParser(
description=
'manage "networks" (via network namespaces, veth pairs and bridges) for testing'
)
parser.add_argument('configuration',
help='YAML file containing networks and network nodes')
args = parser.parse_args()
with open(args.configuration) as conf_file:
config = yaml.load(conf_file)
net = TestNet(config)
try:
net.start()
except Exception as ex:
net.close()
raise ex
signal.sigwait([signal.SIGINT, signal.SIGTERM])
print('cleaning up...')
net.close()
def transient(tor_iptables):
SIGSET = frozenset({SIGINT, SIGTERM})
try:
old_rules = check_output(["iptables-save"])
except CalledProcessError as err:
print(f" {Colors.ORANGE}[!] Could not save iptables rules{Colors.DEFAULT}")
print(f" {Colors.ORANGE}[!] Command failed: {err.cmd}{Colors.DEFAULT}")
print(f" [{Colors.PINK}+{Colors.DEFAULT}] iptables rules saved")
flush(tor_iptables)
load(tor_iptables)
sigwait(SIGSET)
p = Popen(["iptables-restore"], stdin=PIPE, stdout=DEVNULL, stderr=DEVNULL)
r = p.communicate(old_rules)
if p.returncode == 0:
print(f" [{Colors.PINK}+{Colors.DEFAULT}] iptables rules restored")
else:
print(
f" [{Colors.ORANGE}!{Colors.DEFAULT}] Could not restore iptables rules. Dumping to output!"
)
print(old_rules.decode())
exit(1)
def inner():
# Block signals we expect to receive
signal.pthread_sigmask(signal.SIG_BLOCK,
test_signals | {signal.SIGUSR1})
# Save our pid so it is accessible to the test process, avoiding
# any race conditions where the file may be empty.
pid = os.getpid()
fd, path = tempfile.mkstemp()
os.write(fd, str(pid).encode("utf-8"))
os.fsync(fd)
os.close(fd)
os.rename(path, runner_pid_file)
for sig in test_signals:
logger.debug("Waiting for %s", sig)
signal.sigwait({sig})
# Stop self to indicate success to test process.
os.kill(pid, signal.SIGSTOP)
logger.debug("Waiting for signal to exit")
# This is required otherwise we may exit while the test is checking
# for our status.
signal.sigwait({resume_signal})
logger.debug("All signals received")
def main():
blurb = "Local API for Yahoo Historic Data"
print(blurb)
#Build a datetime object with Current time
dt = datetime.datetime.now()
#Make the logging file
loggingfile = "/tmp/stock_ticker_api_{timestamp}.log".format(
timestamp=dt.now().isoformat())
#Setup logging
logging.basicConfig(
format=
'%(asctime)s\t%(name)-16s\t%(funcName)-16s\t[%(levelname)-8s] %(message)s',
level=logging.DEBUG)
#Let everyone know where we logged tp
print("Logfile: {logfile}".format(logfile=loggingfile))
logger = logging.getLogger('main')
#Begin normal application
logger.warning(blurb)
# Parse the args
parser = argparse.ArgumentParser(description=blurb)
# Generate the parsed arguments
args = parser.parse_args()
logger.info("Args: %s", args)
# Server
ps = stockTickerServer.StockTickerServer(9456)
ps.initialise()
ps.start()
#Clean up everything else...
#Signal handler needed here to wait before exiting
sigset = [signal.SIGINT, signal.SIGTERM]
signal.sigwait(sigset) #3.3 only
signal.pause()
#Finally shutdown the server
ps.shutdown()
logging.shutdown()
print("Exiting...")
def main():
blurb = "AutoTrader"
print(blurb)
#Build a datetime object with Current time
dt = datetime.datetime.now()
#Make the logging file
loggingfile = "/tmp/autoTrader_{timestamp}.log".format(
timestamp=dt.now().isoformat())
#Setup logging
logging.basicConfig(
format=
'%(asctime)s\t%(name)-16s\t%(funcName)-16s\t[%(levelname)-8s] %(message)s',
level=logging.DEBUG)
#Let everyone know where we logged tp
print("Logfile: {logfile}".format(logfile=loggingfile))
logger = logging.getLogger('main')
#Begin normal application
logger.warning(blurb)
# Parse the args
parser = argparse.ArgumentParser(description=blurb)
# Generate the parsed arguments
args = parser.parse_args()
logger.info("Args: %s", args)
# Trader
t = autoTrader.AutoTrader(OPTIONS_API_ADDR, OPTIONS_API_PORT)
t.initialise()
t.start()
#Clean up everything else...
#Signal handler needed here to wait before exiting
sigset = [signal.SIGINT, signal.SIGTERM]
signal.sigwait(sigset) #3.3 only
logger.error("Shutting down.....")
#Finally shutdown the server
t.shutdown()
logging.shutdown()
print("Exiting...")
def _run_reactor(self):
"""Run the twisted reactor."""
threading.Thread(target=reactor.run,
daemon=True,
kwargs=dict(installSignalHandlers=0)).start()
signal_map = {
signal.SIGHUP: self._handle_reconfigure,
signal.SIGINT: self._handle_shutdown,
signal.SIGTERM: self._handle_shutdown,
signal.SIGQUIT: self._handle_shutdown,
signal.SIGUSR1: self._handle_debug,
}
while True:
signal.pthread_sigmask(signal.SIG_BLOCK, signal_map.keys())
signum = signal.sigwait(set(signal_map.keys()))
logging.info("Got signal %s" % signum)
if signum in signal_map:
signal_map[signum](signum, None)
def dispatch():
'''Dispatch processing events at midnight every night'''
while True:
now = time.time()
next_midnight = math.ceil(now / SECONDS_IN_DAY) * SECONDS_IN_DAY
delay = math.ceil(next_midnight - now)
logging.info("Waiting %s seconds until %s"
% (delay, datetime.datetime.fromtimestamp(next_midnight)))
signal.alarm(delay)
signum = signal.sigwait([signal.SIGALRM, signal.SIGINT, signal.SIGTERM])
if signum == signal.SIGALRM:
logging.info("Starting work")
run()
else:
logging.info("Exit requested")
break
def serve(block=True, port: int = random.randint(50000, 59000)):
"""
:param block:
:param port:
:return:
"""
logger.info("Search service, version={}".format(
pkg_resources.get_distribution('tutorial-grpc-geodatas').version))
# Register signal handler, only if blocking
if block:
for sig in SIGNALS:
signal.signal(sig, _signal_handler)
max_number_of_clients = 10
# Creates Server with which RPCs can be serviced
# https://docs.python.org/3/library/concurrent.futures.html#concurrent.futures.Executor
# https://stackoverflow.com/questions/51089746/grpc-python-thread-pool-vs-max-concurrent-rpcs
server = grpc.server(futures.ThreadPoolExecutor(max_workers=10),
maximum_concurrent_rpcs=max_number_of_clients)
# Register Rpc Handlers with `SearchServicer` server
search_pb2_grpc.add_SearchServicer_to_server(SearchServicer(), server)
# Opens an insecure port for accepting RPCs.
grpc_host_and_port = f'[::]:{port}'
insecure_port = server.add_insecure_port(grpc_host_and_port)
if insecure_port == 0:
logger.error(f"Failed to start gRPC server on {insecure_port}")
raise ConnectionError
with consuled(insecure_port):
logger.info(f"Starting server on port {insecure_port}...")
server.start()
logger.info("Ready and waiting for connections.")
if not block:
return server, insecure_port
# Wait for a signal before exiting
sig = signal.sigwait(SIGNALS)
logger.info('Signal {} received, shutting down...'.format(sig))
server.stop(5).wait()
def fork():
if os.name != 'posix':
return -1
pid = os.fork()
if pid < 0:
return -1
if pid > 0:
return pid
# child
os.setsid()
received = signal.sigwait([signal.SIGUSR1])
if received != signal.SIGUSR1:
sys.exit(os.EX_OK)
return 0
async def main(connection):
global exit_code
app = await iterm2.async_get_app(connection)
while True:
print("Waiting for signal")
sig = signal.sigwait(
[signal.SIGHUP, signal.SIGINT, signal.SIGTERM, signal.SIGUSR1])
if sig == signal.SIGUSR1:
print("Creating new window")
window = await iterm2.Window.async_create(connection)
if window is not None:
await window.async_activate()
await app.async_activate(False)
else:
print("Unable to create window")
continue
print("Terminating on signal {}".format(sig))
exit_code = sig
break
def run(self):
with no_daemon_context(self.working_dir, self.lock_file, self.signals):
signal_map = {
signal.SIGHUP: self._handle_reconfigure,
signal.SIGINT: self._handle_shutdown,
signal.SIGTERM: self._handle_shutdown,
signal.SIGQUIT: self._handle_shutdown,
signal.SIGUSR1: self._handle_debug,
}
signal.pthread_sigmask(signal.SIG_BLOCK, signal_map.keys())
self._run_mcp()
self._run_www_api()
self._run_manhole()
self._run_reactor()
while True:
signum = signal.sigwait(list(signal_map.keys()))
if signum in signal_map:
logging.info(f"Got signal {str(signum)}")
signal_map[signum](signum, None)
def run(self):
with no_daemon_context(self.working_dir, self.lock_file, self.signals):
signal_map = {
signal.SIGHUP: self._handle_reconfigure,
signal.SIGINT: self._handle_shutdown,
signal.SIGTERM: self._handle_shutdown,
signal.SIGQUIT: self._handle_shutdown,
signal.SIGUSR1: self._handle_debug,
}
signal.pthread_sigmask(signal.SIG_BLOCK, signal_map.keys())
self._run_mcp()
self._run_www_api()
self._run_manhole()
self._run_reactor()
while True:
signum = signal.sigwait(list(signal_map.keys()))
if signum in signal_map:
logging.info(f"Got signal {str(signum)}")
signal_map[signum](signum, None)
def wait_for_child_and_forward_all_signals(child_pid, process_name):
"""Wait for a child to terminate and in the meantime forward all signals the current process
receives to this child.
@return a tuple of exit code and resource usage of the child as given by os.waitpid
"""
assert _HAS_SIGWAIT
block_all_signals()
while True:
logging.debug("Waiting for signals")
signum = signal.sigwait(_ALL_SIGNALS)
if signum == signal.SIGCHLD:
pid, exitcode, ru_child = os.wait4(-1, os.WNOHANG)
while pid != 0:
if pid == child_pid:
return exitcode, ru_child
else:
logging.debug("Received unexpected SIGCHLD for PID %s", pid)
pid, exitcode, ru_child = os.wait4(-1, os.WNOHANG)
else:
_forward_signal(signum, child_pid, process_name)
config = self.config
database = config["database"]["connection"]
graphs = config["graphs"]
sensors = gather_sensors(config)
server_host = config["server"]["host"]
server_port = int(config["server"]["port"])
server_address = (server_host, server_port)
db_connection = DatabaseConnection(database, sensors)
server = Server(server_address, db_connection, graphs)
self.server = server
server.serve_forever()
db_connection.close()
server.server_close()
if __name__ == "__main__":
config = None
with open("telemetry.json", "r", encoding="utf-8") as config_file:
config = json.load(config_file)
server_thread = ServerThread(config)
server_thread.start()
signal.sigwait([signal.SIGABRT, signal.SIGINT, signal.SIGTERM])
server_thread.server.shutdown()
server_thread.join()
def on_moved(self, event):
self.handle_or_not(event)
if __name__ == "__main__":
paths = {dirname(SAMPLE_FILE), dirname(BOTS_FILE), dirname(VALIDS_FILE)}
patterns = [SAMPLE_FILE, BOTS_FILE, VALIDS_FILE]
observer = Observer()
if LOG_LEVEL == logging.DEBUG:
from watchdog.events import LoggingEventHandler
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(message)s', datefmt='%Y-%m-%d %H:%M:%S')
event_logger = LoggingEventHandler()
for path in paths:
observer.schedule(event_logger, path)
logging.debug('Started watching {} for {}'.format(path, event_logger))
event_handler = EventHandler(patterns)
for path in paths:
observer.schedule(event_handler, path)
logging.debug('Started watching {} for {}'.format(path, event_handler))
find_unknown(None)
observer.start()
rec_signal = sigwait((SIGINT, SIGTERM)) # FIXME
logging.info("Received signal {}".format(rec_signal))
observer.join() # TODO funktion recherchieren
# relay commands from user
prompt()
for line in sys.stdin:
cmd = line.strip()
print('cmd: {:s}'.format(repr(cmd)))
if cmd == 'exit':
print('exiting')
break
elif cmd == 'run':
print('running')
driver._issue_cmd(cmd)
driver._await_run()
signum = signal.sigwait([signal.SIGINT])
sigint_handler(signum, None)
elif cmd == 'borken':
driver._issue_cmd('help')
output = driver._read_stdout(target=driver.exit_re, retries=100)
print_with_spacer(output)
elif cmd == 'borken2':
driver._issue_cmd('md 0 4096')
output = driver._read_stdout(target=driver.exit_re, retries=25)
print_with_spacer(output)
elif cmd == 'borclean':
output = driver._read_stdout(target=re.compile(r'(?!x)x'), retries=100)
print_with_spacer(output)
else:
print('issuing')
driver._issue_cmd(cmd)
