File: powerline-daemon

package info (click to toggle)
powerline 2.7-1
  • links: PTS, VCS
  • area: main
  • in suites: buster
  • size: 2,824 kB
  • sloc: python: 22,536; sh: 1,789; ansic: 131; makefile: 74; csh: 51
file content (495 lines) | stat: -rwxr-xr-x 12,808 bytes parent folder | download | duplicates (7)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
#!/usr/bin/python3
# vim:fileencoding=utf-8:noet
from __future__ import (unicode_literals, division, absolute_import, print_function)

import socket
import os
import errno
import sys
import fcntl
import atexit
import stat

from argparse import ArgumentParser
from select import select
from signal import signal, SIGTERM
from time import sleep
from functools import partial
from io import BytesIO
from threading import Event
from itertools import chain
from logging import StreamHandler

from powerline.shell import ShellPowerline
from powerline.commands.main import finish_args, write_output
from powerline.lib.monotonic import monotonic
from powerline.lib.encoding import get_preferred_output_encoding, get_preferred_arguments_encoding, get_unicode_writer
from powerline.bindings.wm import wm_threads

from powerline.commands.main import get_argparser as get_main_argparser
from powerline.commands.daemon import get_argparser as get_daemon_argparser


USE_FILESYSTEM = not sys.platform.lower().startswith('linux')


class NonInteractiveArgParser(ArgumentParser):
	def print_usage(self, file=None):
		raise Exception(self.format_usage())

	def print_help(self, file=None):
		raise Exception(self.format_help())

	def exit(self, status=0, message=None):
		pass

	def error(self, message):
		raise Exception(self.format_usage())


EOF = b'EOF\0\0'


class State(object):
	__slots__ = ('powerlines', 'logger', 'config_loader', 'started_wm_threads',
	             'ts_shutdown_event')

	def __init__(self, **kwargs):
		self.logger = None
		self.config_loader = None
		self.started_wm_threads = {}
		self.powerlines = {}
		self.ts_shutdown_event = Event()


HOME = os.path.expanduser('~')


class NonDaemonShellPowerline(ShellPowerline):
	def get_log_handler(self):
		return StreamHandler()


def start_wm(args, environ, cwd, is_daemon, state):
	wm_name = args.ext[0][3:]
	if wm_name in state.started_wm_threads:
		return b''
	thread_shutdown_event = Event()
	thread = wm_threads[wm_name](
		thread_shutdown_event=thread_shutdown_event,
		pl_shutdown_event=state.ts_shutdown_event,
		pl_config_loader=state.config_loader,
	)
	thread.start()
	state.started_wm_threads[wm_name] = (thread, thread_shutdown_event)
	return b''


def render(args, environ, cwd, is_daemon, state):
	segment_info = {
		'getcwd': lambda: cwd,
		'home': environ.get('HOME', HOME),
		'environ': environ,
		'args': args,
	}
	key = (
		args.ext[0],
		args.renderer_module,
		tuple(args.config_override) if args.config_override else None,
		tuple(args.theme_override) if args.theme_override else None,
		tuple(args.config_path) if args.config_path else None,
		environ.get('POWERLINE_THEME_OVERRIDES', ''),
		environ.get('POWERLINE_CONFIG_OVERRIDES', ''),
		environ.get('POWERLINE_CONFIG_PATHS', ''),
	)

	PowerlineClass = ShellPowerline if is_daemon else NonDaemonShellPowerline
	powerline = None
	try:
		powerline = state.powerlines[key]
	except KeyError:
		try:
			powerline = state.powerlines[key] = PowerlineClass(
				args,
				logger=state.logger,
				config_loader=state.config_loader,
				run_once=False,
				shutdown_event=state.ts_shutdown_event,
			)
			if state.logger is None:
				state.logger = powerline.logger
			if state.config_loader is None:
				state.config_loader = powerline.config_loader
		except SystemExit:
			# Somebody thought raising system exit was a good idea,
			return ''
		except Exception as e:
			if powerline:
				powerline.pl.exception('Failed to render {0}: {1}', str(key), str(e))
			else:
				return 'Failed to render {0}: {1}'.format(str(key), str(e))
	s = BytesIO()
	write_output(args, powerline, segment_info, get_unicode_writer(stream=s))
	s.seek(0)
	return s.read()


def eintr_retry_call(func, *args, **kwargs):
	while True:
		try:
			return func(*args, **kwargs)
		except EnvironmentError as e:
			if getattr(e, 'errno', None) == errno.EINTR:
				continue
			raise


def do_read(conn, timeout=2.0):
	''' Read data from the client. If the client fails to send data within
	timeout seconds, abort. '''
	read = []
	end_time = monotonic() + timeout
	while not read or not read[-1].endswith(b'\0\0'):
		r, w, e = select((conn,), (), (conn,), timeout)
		if e:
			return
		if monotonic() > end_time:
			return
		if not r:
			continue
		x = eintr_retry_call(conn.recv, 4096)
		if x:
			read.append(x)
		else:
			break
	return b''.join(read)


def do_write(conn, result):
	try:
		eintr_retry_call(conn.sendall, result)
	except Exception:
		pass


def safe_bytes(o, encoding=get_preferred_output_encoding()):
	'''Return bytes instance without ever throwing an exception.'''
	try:
		try:
			# We are assuming that o is a unicode object
			return o.encode(encoding, 'replace')
		except Exception:
			# Object may have defined __bytes__ (python 3) or __str__ method 
			# (python 2)
			# This also catches problem with non_ascii_bytes.encode('utf-8') 
			# that first tries to decode to UTF-8 using ascii codec (and fails 
			# in this case) and then encode to given encoding: errors= argument 
			# is not used in the first stage.
			return bytes(o)
	except Exception as e:
		return safe_bytes(str(e), encoding)


def parse_args(req, parser, encoding=get_preferred_arguments_encoding()):
	args = [x.decode(encoding) for x in req.split(b'\0') if x]
	numargs = int(args[0], 16)
	shell_args = parser.parse_args(args[1:numargs + 1])
	cwd = args[numargs + 1]
	environ = dict(((k, v) for k, v in (x.partition('=')[0::2] for x in args[numargs + 2:])))
	cwd = cwd or environ.get('PWD', '/')
	return shell_args, environ, cwd


def get_answer(req, is_daemon, argparser, state):
	try:
		args, environ, cwd = parse_args(req, argparser)
		finish_args(argparser, environ, args, is_daemon=True)
		if args.ext[0].startswith('wm.'):
			return safe_bytes(start_wm(args, environ, cwd, is_daemon, state))
		else:
			return safe_bytes(render(args, environ, cwd, is_daemon, state))
	except Exception as e:
		return safe_bytes(str(e))


def do_one(sock, read_sockets, write_sockets, result_map, is_daemon, argparser,
           state):
	r, w, e = select(
		tuple(read_sockets) + (sock,),
		tuple(write_sockets),
		tuple(read_sockets) + tuple(write_sockets) + (sock,),
		60.0
	)

	if sock in e:
		# We cannot accept any more connections, so we exit
		raise SystemExit(1)

	for s in e:
		# Discard all broken connections to clients
		s.close()
		read_sockets.discard(s)
		write_sockets.discard(s)

	for s in r:
		if s == sock:
			# A client wants to connect
			conn, _ = eintr_retry_call(sock.accept)
			read_sockets.add(conn)
		else:
			# A client has sent some data
			read_sockets.discard(s)
			req = do_read(s)
			if req == EOF:
				raise SystemExit(0)
			elif req:
				ans = get_answer(req, is_daemon, argparser, state)
				result_map[s] = ans
				write_sockets.add(s)
			else:
				s.close()

	for s in w:
		# A client is ready to receive the result
		write_sockets.discard(s)
		result = result_map.pop(s)
		try:
			do_write(s, result)
		finally:
			s.close()


def shutdown(sock, read_sockets, write_sockets, state):
	'''Perform operations necessary for nicely shutting down daemon

	Specifically it

	#. Closes all sockets.
	#. Notifies segments based on 
	  :py:class:`powerline.lib.threaded.ThreadedSegment` and WM-specific 
	  threads that daemon is shutting down.
	#. Waits for threads to finish, but no more then 2 seconds total.
	#. Waits so that total execution time of this function is 2 seconds in order 
	   to allow ThreadedSegments to finish.
	'''
	total_wait_time = 2
	shutdown_start_time = monotonic()

	for s in chain((sock,), read_sockets, write_sockets):
		s.close()

	# Notify ThreadedSegments
	state.ts_shutdown_event.set()
	for thread, shutdown_event in state.started_wm_threads.values():
		shutdown_event.set()

	for thread, shutdown_event in state.started_wm_threads.values():
		wait_time = total_wait_time - (monotonic() - shutdown_start_time)
		if wait_time > 0:
			thread.join(wait_time)

	wait_time = total_wait_time - (monotonic() - shutdown_start_time)
	sleep(wait_time)


def main_loop(sock, is_daemon):
	sock.listen(128)
	sock.setblocking(0)

	read_sockets, write_sockets = set(), set()
	result_map = {}
	parser = get_main_argparser(NonInteractiveArgParser)
	state = State()
	try:
		try:
			while True:
				do_one(
					sock, read_sockets, write_sockets, result_map,
					is_daemon=is_daemon,
					argparser=parser,
					state=state,
				)
		except KeyboardInterrupt:
			raise SystemExit(0)
	except SystemExit as e:
		shutdown(sock, read_sockets, write_sockets, state)
		raise e
	return 0


def daemonize(stdin=os.devnull, stdout=os.devnull, stderr=os.devnull):
	try:
		pid = os.fork()
		if pid > 0:
			# exit first parent
			raise SystemExit(0)
	except OSError as e:
		sys.stderr.write("fork #1 failed: %d (%s)\n" % (e.errno, e.strerror))
		raise SystemExit(1)

	# decouple from parent environment
	os.chdir("/")
	os.setsid()
	os.umask(0)

	# do second fork
	try:
		pid = os.fork()
		if pid > 0:
			# exit from second parent
			raise SystemExit(0)
	except OSError as e:
		sys.stderr.write("fork #2 failed: %d (%s)\n" % (e.errno, e.strerror))
		raise SystemExit(1)

	# Redirect standard file descriptors.
	si = open(stdin, 'rb')
	so = open(stdout, 'a+b')
	se = open(stderr, 'a+b', 0)
	os.dup2(si.fileno(), sys.stdin.fileno())
	os.dup2(so.fileno(), sys.stdout.fileno())
	os.dup2(se.fileno(), sys.stderr.fileno())
	return True


def check_existing(address):
	if USE_FILESYSTEM:
		# We cannot bind if the socket file already exists so remove it, we
		# already have a lock on pidfile, so this should be safe.
		try:
			os.unlink(address)
		except EnvironmentError:
			pass

	sock = socket.socket(family=socket.AF_UNIX)
	try:
		sock.bind(address)
	except socket.error as e:
		if getattr(e, 'errno', None) == errno.EADDRINUSE:
			return None
		raise
	return sock


def kill_daemon(address):
	sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
	try:
		try:
			eintr_retry_call(sock.connect, address)
		except socket.error:
			return False
		else:
			eintr_retry_call(sock.sendall, EOF)
	finally:
		sock.close()
	return True


def cleanup_lockfile(pidfile, fd, *args):
	try:
		# Remove the directory entry for the lock file
		os.unlink(pidfile)
		# Close the file descriptor
		os.close(fd)
	except EnvironmentError:
		pass
	if args:
		# Called in signal handler
		raise SystemExit(1)


def lockpidfile(pidfile):
	fd = os.open(
		pidfile,
		os.O_WRONLY | os.O_CREAT,
		stat.S_IRUSR | stat.S_IWUSR | stat.S_IRGRP | stat.S_IROTH
	)
	try:
		fcntl.lockf(fd, fcntl.LOCK_EX | fcntl.LOCK_NB)
	except EnvironmentError:
		os.close(fd)
		return None
	os.lseek(fd, 0, os.SEEK_SET)
	os.ftruncate(fd, 0)
	os.write(fd, ('%d' % os.getpid()).encode('ascii'))
	os.fsync(fd)
	cleanup = partial(cleanup_lockfile, pidfile, fd)
	signal(SIGTERM, cleanup)
	atexit.register(cleanup)
	return fd


def main():
	parser = get_daemon_argparser()
	args = parser.parse_args()
	is_daemon = False
	address = None
	pidfile = None

	if args.socket:
		address = args.socket
		if not USE_FILESYSTEM:
			address = '\0' + address
	else:
		if USE_FILESYSTEM:
			address = '/tmp/powerline-ipc-%d'
		else:
			# Use the abstract namespace for sockets rather than the filesystem
			# (Available only in linux)
			address = '\0powerline-ipc-%d'

		address = address % os.getuid()

	if USE_FILESYSTEM:
		pidfile = address + '.pid'

	if args.kill:
		if args.foreground or args.replace:
			parser.error('--kill and --foreground/--replace cannot be used together')
		if kill_daemon(address):
			if not args.quiet:
				print ('Kill command sent to daemon, if it does not die in a couple of seconds use kill to kill it')
			raise SystemExit(0)
		else:
			if not args.quiet:
				print ('No running daemon found')
			raise SystemExit(1)

	if args.replace:
		while kill_daemon(address):
			if not args.quiet:
				print ('Kill command sent to daemon, waiting for daemon to exit, press Ctrl-C to terminate wait and exit')
			sleep(2)

	if USE_FILESYSTEM and not args.foreground:
		# We must daemonize before creating the locked pidfile, unfortunately,
		# this means further print statements are discarded
		is_daemon = daemonize()

	if USE_FILESYSTEM:
		# Create a locked pid file containing the daemon’s PID
		if lockpidfile(pidfile) is None:
			if not args.quiet:
				sys.stderr.write(
					'The daemon is already running. Use %s -k to kill it.\n' % (
						os.path.basename(sys.argv[0])))
			raise SystemExit(1)

	# Bind to address or bail if we cannot bind
	sock = check_existing(address)
	if sock is None:
		if not args.quiet:
			sys.stderr.write(
				'The daemon is already running. Use %s -k to kill it.\n' % (
					os.path.basename(sys.argv[0])))
		raise SystemExit(1)

	if not USE_FILESYSTEM and not args.foreground:
		# We daemonize on linux
		is_daemon = daemonize()

	return main_loop(sock, is_daemon)


if __name__ == '__main__':
	main()