def test_usr1(self):
import types, posix
signal = self.signal # the signal module to test
received = []
def myhandler(signum, frame):
assert isinstance(frame, types.FrameType)
received.append(signum)
signal.signal(signal.SIGUSR1, myhandler)
posix.kill(posix.getpid(), signal.SIGUSR1)
# the signal should be delivered to the handler immediately
assert received == [signal.SIGUSR1]
del received[:]
posix.kill(posix.getpid(), signal.SIGUSR1)
# the signal should be delivered to the handler immediately
assert received == [signal.SIGUSR1]
del received[:]
signal.signal(signal.SIGUSR1, signal.SIG_IGN)
posix.kill(posix.getpid(), signal.SIGUSR1)
for i in range(10000):
# wait a bit - signal should not arrive
if received:
break
assert received == []
signal.signal(signal.SIGUSR1, signal.SIG_DFL)
def test_set_wakeup_fd(self):
import signal, posix, fcntl
def myhandler(signum, frame):
pass
signal.signal(signal.SIGUSR1, myhandler)
#
def cannot_read():
try:
posix.read(fd_read, 1)
except OSError:
pass
else:
raise AssertionError, "os.read(fd_read, 1) succeeded?"
#
fd_read, fd_write = posix.pipe()
flags = fcntl.fcntl(fd_write, fcntl.F_GETFL, 0)
flags = flags | posix.O_NONBLOCK
fcntl.fcntl(fd_write, fcntl.F_SETFL, flags)
flags = fcntl.fcntl(fd_read, fcntl.F_GETFL, 0)
flags = flags | posix.O_NONBLOCK
fcntl.fcntl(fd_read, fcntl.F_SETFL, flags)
#
old_wakeup = signal.set_wakeup_fd(fd_write)
try:
cannot_read()
posix.kill(posix.getpid(), signal.SIGUSR1)
res = posix.read(fd_read, 1)
assert res == '\x00'
cannot_read()
finally:
old_wakeup = signal.set_wakeup_fd(old_wakeup)
#
signal.signal(signal.SIGUSR1, signal.SIG_DFL)
def __init__(self, dollar0, argv, environ, arena, has_main=False):
self.dollar0 = dollar0
self.argv_stack = [_ArgFrame(argv)]
self.var_stack = [_StackFrame()]
# The debug_stack isn't strictly necessary for execution. We use it for
# crash dumps and for 3 parallel arrays: FUNCNAME, BASH_SOURCE,
# BASH_LINENO. The First frame points at the global vars and argv.
self.debug_stack = [(None, None, const.NO_INTEGER, 0, 0)]
self.bash_source = [] # for implementing BASH_SOURCE
self.has_main = has_main
if has_main:
self.bash_source.append(dollar0) # e.g. the filename
self.current_spid = const.NO_INTEGER
# Note: we're reusing these objects because they change on every single
# line! Don't want to allocate more than necsesary.
self.source_name = value.Str('')
self.line_num = value.Str('')
self.last_status = 0 # Mutable public variable
self.last_job_id = -1 # Uninitialized value mutable public variable
# Done ONCE on initialization
self.root_pid = posix.getpid()
self._InitDefaults()
self._InitVarsFromEnv(environ)
self.arena = arena
def start(self): fcntl(self.conn.sock.fileno(),F_SETOWN,getpid()) flgs = fcntl(self.conn.sock.fileno(),F_GETFL,0) fcntl(self.conn.sock.fileno(),F_SETFL,flgs | 0x0040 | 0x0004) # O_ASYNC | O_NONBLOCK signal(SIGALRM,handler) signal(SIGIO,iohandler) alarm(Bot.delay) self.listen()
def log(msg):
if not debug: return
if type(msg) <> type(''):
msg = ` msg `
f = open('/tmp/intercom.log', 'a')
f.write( ` sys.argv ` + ' ' + ` posix.getpid() ` + ': ' + msg + '\n')
f.close()
def log(msg):
if not debug: return
if type(msg) <> type(''):
msg = `msg`
f = open('/tmp/intercom.log', 'a')
f.write(`sys.argv` + ' ' + `posix.getpid()` + ': ' + msg + '\n')
f.close()
def uniqueFileName(file): import socket, posix hostname = socket.gethostname() pid = posix.getpid() fileName = str(file)+"."+str(pid)+"."+str(hostname) return fileName
def main():
parser = argparse.ArgumentParser(description='Development Server Help')
parser.add_argument("-p", "--port", action="store", dest="port", type=int,
help="listening port", default=8000)
parser.add_argument("-n", "--num_processes", action="store", dest="num_processes", type=int,
help="num of worker processes", default=8)
parser.add_argument("-m", "--multi_port", action="store_true", dest="multi_port",
help="use different port for each process", default=False)
parser.add_argument("-c", "--cpu_set", action="store", dest="cpu_set",
help="run on cpu set", default="")
parser.add_argument("-x", "--xperf", action="store_true", dest="xperf",
help="collect call stacks with python-flamegraph", default=False)
args = parser.parse_args()
print("Server starting with master pid {}".format(posix.getpid()))
posix.setpgid(0, 0)
register_signal_handler_for_master()
if args.xperf:
dest_dir = "xperf-log/{}".format(datetime.datetime.utcnow().timestamp())
os.system("mkdir -p {}".format(dest_dir))
port = args.port
if not args.multi_port:
http_server = HTTPServer(WSGIContainer(app))
http_server.bind(port)
#http_server.start(args.num_processes)
tornado.process.fork_processes(args.num_processes)
sockets = http_server._pending_sockets
http_server._pending_sockets = []
http_server.add_sockets(sockets)
else:
tornado.process.fork_processes(args.num_processes)
sockets = tornado.netutil.bind_sokets(args.port + tornado.process.task_id())
http_server = HTTPServer(WSGIContainer(app))
http_server.add_sockets(sockets)
thread = None
if args.xperf:
from flamegraph.flamegraph import ProfileThread
thread = ProfileThread(open("{}/perf-{}.log".format(dest_dir, posix.getpid()), "w"), 0.001, None)
thread.start()
register_signal_handler_for_worker(thread)
IOLoop.instance().start()
def dbfLock():
if dbfQuery():
fo = open(lockFile, "w")
fo.write(repr(posix.getpid()))
fo.close()
else:
sys.stderr.write("E: couldn't get lock on database. (" +
repr(dbfQuery()) + ")\n")
sys.exit(-1)
def test_sigmask(self):
import _signal as signal, posix
signum1 = signal.SIGUSR1
signum2 = signal.SIGUSR2
def handler(signum, frame):
pass
signal.signal(signum1, handler)
signal.signal(signum2, handler)
signal.pthread_sigmask(signal.SIG_BLOCK, (signum1, signum2))
posix.kill(posix.getpid(), signum1)
posix.kill(posix.getpid(), signum2)
assert signal.sigpending() == set((signum1, signum2))
# Unblocking the 2 signals calls the C signal handler twice
signal.pthread_sigmask(signal.SIG_UNBLOCK, (signum1, signum2))
assert signal.sigpending() == set()
def _CheckStatus(self, status, node, argv0=None):
"""ErrExitFailure with location info attached."""
if self.exec_opts.ErrExit() and status != 0:
# Add context based on node type
if node.tag == command_e.SimpleCommand:
argv0 = argv0 or '<unknown>'
raise util.ErrExitFailure(
'[%d] %r command exited with status %d', posix.getpid(), argv0,
status, word=node.words[0], status=status)
elif node.tag == command_e.Assignment:
span_id = self._SpanIdForAssignment(node)
raise util.ErrExitFailure(
'[%d] assignment exited with status %d', posix.getpid(),
status, span_id=span_id, status=status)
else:
raise util.ErrExitFailure(
'[%d] %r exited with status %d', posix.getpid(),
node.__class__.__name__, status, status=status)
def __init__(self, logfile):
try:
self.f = open(LOGDIR + logfile, 'a+', 0)
except IOError:
try:
self.f = open(LOGDIR + logfile, 'w+', 0)
except IOError:
self.f = open(LOGDIR + logfile, 'w', 0)
self.ident = '[' + sys.argv[0] + ':' + repr(posix.getpid()) + ']: '
pass
def __init__(self, logfile): try: self.f = open(LOGDIR + logfile, 'a+', 0) except IOError: try: self.f = open(LOGDIR + logfile, 'w+', 0) except IOError: self.f = open(LOGDIR + logfile, 'w', 0) self.ident = '['+sys.argv[0]+ ':' + repr(posix.getpid()) +']: ' pass
def toby_based_access(device_name_list):
'''
Handle Toby based execution via command line
'''
# Toby information for reference
log("Info", "Toby version : " + toby_version)
# Create and save YAML based resource template file
resource_template = build_resource_template(device_name_list)
uniq_id = posix.getpid()
resource_yaml = '/tmp/attribute_init_topo_' + str(uniq_id) + '.yaml'
try:
with open(resource_yaml, 'w') as file_handle:
file_handle.write(resource_template)
file_handle.flush()
except IOError:
log("Error", "Could not write file : " + resource_yaml)
sys.exit(1)
finally:
file_handle.close()
# Initialize resources and create 't' object for Toby
log("Info", "Initializing resources")
try:
stdout_orig = sys.stdout # Disable Toby console logging during device initialization
sys.stdout = StringIO()
t = init()
t.Initialize(init_file=resource_yaml)
except jnpr.toby.utils.utils.RunMultipleException:
sys.stdout = stdout_orig # Enable Toby console logging after failure
log("Error", "Exception occured while initializing resources")
sys.exit(1)
finally:
sys.stdout = stdout_orig # Enable Toby console logging after device initialization
log("Info", "Resource initialization completed")
# Remove YAML based resource template file
if uniq_id:
os.remove(resource_yaml)
# Process resources and generate attribute variables
return process_resources(t)
def MaybeDump(self, status):
# type: (int) -> None
"""Write the dump as JSON.
User can configure it two ways:
- dump unconditionally -- a daily cron job. This would be fine.
- dump on non-zero exit code
OIL_FAIL
Maybe counters are different than failure
OIL_CRASH_DUMP='function alias trap completion stack' ?
OIL_COUNTER_DUMP='function alias trap completion'
and then
I think both of these should dump the (path, mtime, checksum) of the source
they ran? And then you can match those up with source control or whatever?
"""
if not self.collected:
return
my_pid = posix.getpid() # Get fresh PID here
# Other things we need: the reason for the crash! _ErrorWithLocation is
# required I think.
d = {
'var_stack': self.var_stack,
'argv_stack': self.argv_stack,
'debug_stack': self.debug_stack,
'error': self.error,
'status': status,
'pid': my_pid,
}
# TODO: Add PID here
path = os_path.join(self.crash_dump_dir,
'%d-osh-crash-dump.json' % my_pid)
with open(path, 'w') as f:
import json
json.dump(d, f, indent=2)
#print(repr(d), file=f)
log('[%d] Wrote crash dump to %s', my_pid, path)
def test_set_wakeup_fd(self):
try:
import _signal as signal, posix, fcntl
except ImportError:
skip('cannot import posix or fcntl')
def myhandler(signum, frame):
pass
signal.signal(signal.SIGINT, myhandler)
#
def cannot_read():
try:
posix.read(fd_read, 1)
except OSError:
pass
else:
raise AssertionError("os.read(fd_read, 1) succeeded?")
#
fd_read, fd_write = posix.pipe()
flags = fcntl.fcntl(fd_write, fcntl.F_GETFL, 0)
flags = flags | posix.O_NONBLOCK
fcntl.fcntl(fd_write, fcntl.F_SETFL, flags)
flags = fcntl.fcntl(fd_read, fcntl.F_GETFL, 0)
flags = flags | posix.O_NONBLOCK
fcntl.fcntl(fd_read, fcntl.F_SETFL, flags)
#
old_wakeup = signal.set_wakeup_fd(fd_write)
try:
cannot_read()
posix.kill(posix.getpid(), signal.SIGINT)
res = posix.read(fd_read, 1)
assert res == bytes([signal.SIGINT])
cannot_read()
finally:
old_wakeup = signal.set_wakeup_fd(old_wakeup)
#
signal.signal(signal.SIGINT, signal.SIG_DFL)
Created on Apr 22, 2016
@author: Developer
'''
# From socket module we import the required structures and constants.
from socket import AF_INET, SOCK_STREAM, socket
# Sleep function will be used to keep application running for a while
from time import sleep
# And we also will need the process id given by OS when we execute this code
from os import getpgid
from posix import getpid
if __name__ == '__main__':
print 'Application started'
print 'OS assigned process id: %d' % getpid()
# Creating a UDP/IP socket
s = socket(AF_INET, SOCK_STREAM)
print 'TCP Socket created'
print 'File descriptor assigned by OS: ', s.fileno()
wait_secs = 60 * 5
print 'Waiting %d seconds before termination ...' % wait_secs
sleep(wait_secs)
print 'Closing the TCP socket ...'
s.close()
print 'Terminating ...'
def save_pid():
with open(pid_filename, 'w') as f:
f.write(str(getpid()))
def ShowFdState():
import subprocess
subprocess.call(['ls', '-l', '/proc/%d/fd' % posix.getpid()])
class IdentifierSnowflake(PersistentUniqueIdentifier):
store_class = BERadioConfig
attribute = 'gateway_id'
datacenter = 0
id_generator = SnowflakeGenerator(datacenter, getpid()).get_next_id
def OshMain(argv0, argv, login_shell):
arg_r = args.Reader(argv)
try:
opts = OSH_SPEC.Parse(arg_r)
except args.UsageError as e:
ui.usage('osh usage error: %s', e)
return 2
if opts.help:
loader = util.GetResourceLoader()
builtin.Help(['osh-usage'], loader)
return 0
if opts.version:
# OSH version is the only binary in Oil right now, so it's all one version.
_ShowVersion()
return 0
# TODO: This should be in interactive mode only?
builtin.RegisterSigIntHandler()
if arg_r.AtEnd():
dollar0 = argv0
has_main = False
else:
dollar0 = arg_r.Peek() # the script name, or the arg after -c
has_main = True
pool = alloc.Pool()
arena = pool.NewArena()
# NOTE: has_main is only for ${BASH_SOURCE[@} and family. Could be a
# required arg.
mem = state.Mem(dollar0,
argv[arg_r.i + 1:],
posix.environ,
arena,
has_main=has_main)
funcs = {}
comp_lookup = completion.CompletionLookup()
fd_state = process.FdState()
exec_opts = state.ExecOpts(mem, readline)
builtin.SetExecOpts(exec_opts, opts.opt_changes)
aliases = {} # feedback between runtime and parser
parse_ctx = parse_lib.ParseContext(arena, aliases)
if opts.debug_file:
debug_f = util.DebugFile(fd_state.Open(opts.debug_file, mode='w'))
else:
debug_f = util.NullDebugFile()
debug_f.log('Debug file is %s', opts.debug_file)
# Controlled by env variable, flag, or hook?
dumper = dev.CrashDumper(posix.environ.get('OSH_CRASH_DUMP_DIR', ''))
if opts.xtrace_to_debug_file:
trace_f = debug_f
else:
trace_f = util.DebugFile(sys.stderr)
devtools = dev.DevTools(dumper, debug_f, trace_f)
ex = cmd_exec.Executor(mem, fd_state, funcs, comp_lookup, exec_opts,
parse_ctx, devtools)
# NOTE: The rc file can contain both commands and functions... ideally we
# would only want to save nodes/lines for the functions.
try:
rc_path = 'oilrc'
arena.PushSource(rc_path)
with open(rc_path) as f:
rc_line_reader = reader.FileLineReader(f, arena)
_, rc_c_parser = parse_ctx.MakeParser(rc_line_reader)
try:
status = main_loop.Batch(ex, rc_c_parser, arena)
finally:
arena.PopSource()
except IOError as e:
if e.errno != errno.ENOENT:
raise
# Needed in non-interactive shells for @P
prompt = ui.Prompt(arena, parse_ctx, ex)
ui.PROMPT = prompt
if opts.c is not None:
arena.PushSource('<command string>')
line_reader = reader.StringLineReader(opts.c, arena)
if opts.i: # -c and -i can be combined
exec_opts.interactive = True
elif opts.i: # force interactive
arena.PushSource('<stdin -i>')
line_reader = reader.InteractiveLineReader(arena, prompt)
exec_opts.interactive = True
else:
try:
script_name = arg_r.Peek()
except IndexError:
if sys.stdin.isatty():
arena.PushSource('<interactive>')
line_reader = reader.InteractiveLineReader(arena, prompt)
exec_opts.interactive = True
else:
arena.PushSource('<stdin>')
line_reader = reader.FileLineReader(sys.stdin, arena)
else:
arena.PushSource(script_name)
try:
f = fd_state.Open(script_name)
except OSError as e:
util.error("Couldn't open %r: %s", script_name,
posix.strerror(e.errno))
return 1
line_reader = reader.FileLineReader(f, arena)
# TODO: assert arena.NumSourcePaths() == 1
# TODO: .rc file needs its own arena.
w_parser, c_parser = parse_ctx.MakeParser(line_reader)
if exec_opts.interactive:
# NOTE: We're using a different evaluator here. The completion system can
# also run functions... it gets the Executor through Executor._Complete.
if HAVE_READLINE:
splitter = legacy.SplitContext(mem) # TODO: share with executor.
ev = word_eval.CompletionWordEvaluator(mem, exec_opts, splitter,
arena)
progress_f = ui.StatusLine()
var_action = completion.VariablesActionInternal(ex.mem)
root_comp = completion.RootCompleter(ev, comp_lookup, var_action,
parse_ctx, progress_f,
debug_f)
completion.Init(readline, root_comp, debug_f)
_InitDefaultCompletions(ex, comp_lookup)
return main_loop.Interactive(opts, ex, c_parser, arena)
# TODO: Remove this after removing it from benchmarks/osh-runtime. It's no
# longer relevant with main_loop.
if opts.parser_mem_dump:
# This might be superstition, but we want to let the value stabilize
# after parsing. bash -c 'cat /proc/$$/status' gives different results
# with a sleep.
time.sleep(0.001)
input_path = '/proc/%d/status' % posix.getpid()
with open(input_path) as f, open(opts.parser_mem_dump, 'w') as f2:
contents = f.read()
f2.write(contents)
log('Wrote %s to %s (--parser-mem-dump)', input_path,
opts.parser_mem_dump)
nodes_out = [] if exec_opts.noexec else None
_tlog('Execute(node)')
status = main_loop.Batch(ex, c_parser, arena, nodes_out=nodes_out)
if nodes_out is not None:
ui.PrintAst(nodes_out, opts)
# NOTE: 'exit 1' is ControlFlow and gets here, but subshell/commandsub
# don't because they call sys.exit().
if opts.runtime_mem_dump:
# This might be superstition, but we want to let the value stabilize
# after parsing. bash -c 'cat /proc/$$/status' gives different results
# with a sleep.
time.sleep(0.001)
input_path = '/proc/%d/status' % posix.getpid()
with open(input_path) as f, open(opts.runtime_mem_dump, 'w') as f2:
contents = f.read()
f2.write(contents)
log('Wrote %s to %s (--runtime-mem-dump)', input_path,
opts.runtime_mem_dump)
# NOTE: We haven't closed the file opened with fd_state.Open
return status
# intercom -- use mike and headset to *talk* to a person on another host.
import time
from posix import getpid
if not os.environ['HOME']:
print "HOME environment variable missing. Attempting stupid detection."
if os.path.exists('/home/user') and os.path.exists('/usr/bin/ossofilemanager'):
print "Stupid detection succeeded, using /home/user/"
os.environ['HOME'] = '/home/user/'
else:
print "Stupid detection failed. HOME missing. Refusing to continue."
sys.exit(1)
comSocket = file('/dev/null')
confDir = os.environ['HOME']+"/.config/dayplanner.mobile/"
socketPath = confDir+"Data_Servant"
pid = str(getpid())
UpcomingEventsBuffer = gtk.TextBuffer()
CalendarWidget = gtk.Calendar();
EventlistWin = gtk.ScrolledWindow()
liststore = gtk.ListStore(str, str, str)
# -- Communication conversion methods --
# Purpose: Extract a quoted communication string.
# Returns: The new string
def UnGetComString(string):
slashn = re.compile("{DPNL}")
newstring = slashn.sub("\n",string)
return(newstring)
# Purpose: Quote a string for communication
# Returns: The new string
def _tlog(msg):
pid = posix.getpid() # TODO: Maybe remove PID later.
print('[%d] %.3f %s' % (pid, (time.time() - start_time) * 1000, msg))
def ShellMain(lang, argv0, argv, login_shell):
"""Used by bin/osh and bin/oil.
Args:
lang: 'osh' or 'oil'
argv0, argv: So we can also invoke bin/osh as 'oil.ovm osh'. Like busybox.
login_shell: Was - on the front?
"""
# Differences between osh and oil:
# - --help? I guess Oil has a SUPERSET of OSH options.
# - oshrc vs oilrc
# - the parser and executor
# - Change the prompt in the interactive shell?
assert lang in ('osh', 'oil'), lang
arg_r = args.Reader(argv)
try:
opts = OSH_SPEC.Parse(arg_r)
except args.UsageError as e:
ui.usage('osh usage error: %s', e)
return 2
# NOTE: This has a side effect of deleting _OVM_* from the environment!
# TODO: Thread this throughout the program, and get rid of the global
# variable in core/util.py. Rename to InitResourceLaoder(). It's now only
# used for the 'help' builtin and --version.
loader = pyutil.GetResourceLoader()
if opts.help:
builtin.Help(['%s-usage' % lang], loader)
return 0
if opts.version:
# OSH version is the only binary in Oil right now, so it's all one version.
_ShowVersion()
return 0
if arg_r.AtEnd():
dollar0 = argv0
has_main = False
else:
dollar0 = arg_r.Peek() # the script name, or the arg after -c
has_main = True
arena = alloc.Arena()
# NOTE: has_main is only for ${BASH_SOURCE[@} and family. Could be a
# required arg.
mem = state.Mem(dollar0,
argv[arg_r.i + 1:],
posix.environ,
arena,
has_main=has_main)
funcs = {}
fd_state = process.FdState()
exec_opts = state.ExecOpts(mem, line_input)
builtin.SetExecOpts(exec_opts, opts.opt_changes)
aliases = {} # feedback between runtime and parser
if opts.one_pass_parse and not exec_opts.noexec:
raise args.UsageError('--one-pass-parse requires noexec (-n)')
parse_ctx = parse_lib.ParseContext(arena,
aliases,
one_pass_parse=opts.one_pass_parse)
# Three ParseContext instances SHARE aliases.
comp_arena = alloc.Arena()
comp_arena.PushSource(source.Unused('completion'))
trail1 = parse_lib.Trail()
# one_pass_parse needs to be turned on to complete inside backticks. TODO:
# fix the issue where ` gets erased because it's not part of
# set_completer_delims().
comp_ctx = parse_lib.ParseContext(comp_arena,
aliases,
trail=trail1,
one_pass_parse=True)
hist_arena = alloc.Arena()
hist_arena.PushSource(source.Unused('history'))
trail2 = parse_lib.Trail()
hist_ctx = parse_lib.ParseContext(hist_arena, aliases, trail=trail2)
# Deps helps manages dependencies. These dependencies are circular:
# - ex and word_ev, arith_ev -- for command sub, arith sub
# - arith_ev and word_ev -- for $(( ${a} )) and $x$(( 1 ))
# - ex and builtins (which execute code, like eval)
# - prompt_ev needs word_ev for $PS1, which needs prompt_ev for @P
exec_deps = cmd_exec.Deps()
my_pid = posix.getpid()
debug_path = ''
debug_dir = posix.environ.get('OSH_DEBUG_DIR')
if opts.debug_file: # --debug-file takes precedence over OSH_DEBUG_DIR
debug_path = opts.debug_file
elif debug_dir:
debug_path = os_path.join(debug_dir, '%d-osh.log' % my_pid)
if debug_path:
# This will be created as an empty file if it doesn't exist, or it could be
# a pipe.
try:
debug_f = util.DebugFile(fd_state.Open(debug_path, mode='w'))
except OSError as e:
util.error("Couldn't open %r: %s", debug_path,
posix.strerror(e.errno))
return 2
else:
debug_f = util.NullDebugFile()
exec_deps.debug_f = debug_f
# Not using datetime for dependency reasons. TODO: maybe show the date at
# the beginning of the log, and then only show time afterward? To save
# space, and make space for microseconds. (datetime supports microseconds
# but time.strftime doesn't).
iso_stamp = time.strftime("%Y-%m-%d %H:%M:%S")
debug_f.log('%s [%d] OSH started with argv %s', iso_stamp, my_pid, argv)
if debug_path:
debug_f.log('Writing logs to %r', debug_path)
interp = posix.environ.get('OSH_HIJACK_SHEBANG', '')
exec_deps.ext_prog = process.ExternalProgram(interp, fd_state, debug_f)
splitter = split.SplitContext(mem)
exec_deps.splitter = splitter
# This could just be OSH_DEBUG_STREAMS='debug crash' ? That might be
# stuffing too much into one, since a .json crash dump isn't a stream.
crash_dump_dir = posix.environ.get('OSH_CRASH_DUMP_DIR', '')
exec_deps.dumper = dev.CrashDumper(crash_dump_dir)
if opts.xtrace_to_debug_file:
trace_f = debug_f
else:
trace_f = util.DebugFile(sys.stderr)
exec_deps.trace_f = trace_f
comp_lookup = completion.Lookup()
#
# Various Global State objects to work around readline interfaces
#
compopt_state = completion.OptionState()
comp_ui_state = comp_ui.State()
prompt_state = comp_ui.PromptState()
builtins = { # Lookup
builtin_e.HISTORY: builtin.History(line_input),
builtin_e.COMPOPT: builtin_comp.CompOpt(compopt_state),
builtin_e.COMPADJUST: builtin_comp.CompAdjust(mem),
}
ex = cmd_exec.Executor(mem, fd_state, funcs, builtins, exec_opts,
parse_ctx, exec_deps)
exec_deps.ex = ex
word_ev = word_eval.NormalWordEvaluator(mem, exec_opts, exec_deps, arena)
exec_deps.word_ev = word_ev
arith_ev = expr_eval.ArithEvaluator(mem, exec_opts, word_ev, arena)
exec_deps.arith_ev = arith_ev
word_ev.arith_ev = arith_ev # Another circular dependency
bool_ev = expr_eval.BoolEvaluator(mem, exec_opts, word_ev, arena)
exec_deps.bool_ev = bool_ev
tracer = dev.Tracer(parse_ctx, exec_opts, mem, word_ev, trace_f)
exec_deps.tracer = tracer
# HACK for circular deps
ex.word_ev = word_ev
ex.arith_ev = arith_ev
ex.bool_ev = bool_ev
ex.tracer = tracer
spec_builder = builtin_comp.SpecBuilder(ex, parse_ctx, word_ev, splitter,
comp_lookup)
# Add some builtins that depend on the executor!
complete_builtin = builtin_comp.Complete(spec_builder, comp_lookup)
builtins[builtin_e.COMPLETE] = complete_builtin
builtins[builtin_e.COMPGEN] = builtin_comp.CompGen(spec_builder)
if lang == 'oil':
# The Oil executor wraps an OSH executor? It needs to be able to source
# it.
ex = oil_cmd_exec.OilExecutor(ex)
# PromptEvaluator rendering is needed in non-interactive shells for @P.
prompt_ev = prompt.Evaluator(lang, parse_ctx, ex, mem)
exec_deps.prompt_ev = prompt_ev
word_ev.prompt_ev = prompt_ev # HACK for circular deps
# History evaluation is a no-op if line_input is None.
hist_ev = history.Evaluator(line_input, hist_ctx, debug_f)
# Calculate ~/.config/oil/oshrc or oilrc
# Use ~/.config/oil to avoid cluttering the user's home directory. Some
# users may want to ln -s ~/.config/oil/oshrc ~/oshrc or ~/.oshrc.
# https://unix.stackexchange.com/questions/24347/why-do-some-applications-use-config-appname-for-their-config-data-while-other
home_dir = process.GetHomeDir()
assert home_dir is not None
rc_path = opts.rcfile or os_path.join(home_dir, '.config/oil', lang + 'rc')
history_filename = os_path.join(home_dir, '.config/oil', 'history_' + lang)
if opts.c is not None:
arena.PushSource(source.CFlag())
line_reader = reader.StringLineReader(opts.c, arena)
if opts.i: # -c and -i can be combined
exec_opts.interactive = True
elif opts.i: # force interactive
arena.PushSource(source.Stdin(' -i'))
# interactive shell only
line_reader = reader.InteractiveLineReader(arena, prompt_ev, hist_ev,
line_input, prompt_state)
exec_opts.interactive = True
else:
try:
script_name = arg_r.Peek()
except IndexError:
if sys.stdin.isatty():
arena.PushSource(source.Interactive())
# interactive shell only
line_reader = reader.InteractiveLineReader(
arena, prompt_ev, hist_ev, line_input, prompt_state)
exec_opts.interactive = True
else:
arena.PushSource(source.Stdin(''))
line_reader = reader.FileLineReader(sys.stdin, arena)
else:
arena.PushSource(source.MainFile(script_name))
try:
f = fd_state.Open(script_name)
except OSError as e:
util.error("Couldn't open %r: %s", script_name,
posix.strerror(e.errno))
return 1
line_reader = reader.FileLineReader(f, arena)
# TODO: assert arena.NumSourcePaths() == 1
# TODO: .rc file needs its own arena.
if lang == 'osh':
c_parser = parse_ctx.MakeOshParser(line_reader)
else:
c_parser = parse_ctx.MakeOilParser(line_reader)
# NOTE: SIGINT is temporarily enabled during readline() by
# frontend/reader.py.
# It's treated differently than SIGQUIT and SIGTSTP because Python handles it
# with KeyboardInterrupt. We don't want KeyboardInterrupt at arbitrary
# points in a non-interactive shell. (e.g. osh -c 'sleep 5' then Ctrl-C)
signal.signal(signal.SIGINT, signal.SIG_IGN)
if exec_opts.interactive:
if line_input:
# NOTE: We're using a different WordEvaluator here.
ev = word_eval.CompletionWordEvaluator(mem, exec_opts, exec_deps,
arena)
root_comp = completion.RootCompleter(ev, mem, comp_lookup,
compopt_state, comp_ui_state,
comp_ctx, debug_f)
term_width = 0
if opts.completion_display == 'nice':
try:
term_width = libc.get_terminal_width()
except IOError: # stdin not a terminal
pass
if term_width != 0:
display = comp_ui.NiceDisplay(term_width, comp_ui_state,
prompt_state, debug_f,
line_input)
else:
display = comp_ui.MinimalDisplay(comp_ui_state, prompt_state,
debug_f)
_InitReadline(line_input, history_filename, root_comp, display,
debug_f)
_InitDefaultCompletions(ex, complete_builtin, comp_lookup)
else: # Without readline module
display = comp_ui.MinimalDisplay(comp_ui_state, prompt_state,
debug_f)
# The shell itself should ignore Ctrl-\.
signal.signal(signal.SIGQUIT, signal.SIG_IGN)
# This prevents Ctrl-Z from suspending OSH in interactive mode. But we're
# not getting notification via wait() that the child stopped?
signal.signal(signal.SIGTSTP, signal.SIG_IGN)
# Register a callback to receive terminal width changes.
signal.signal(signal.SIGWINCH, lambda x, y: display.OnWindowChange())
# NOTE: Call this AFTER _InitDefaultCompletions.
SourceStartupFile(rc_path, lang, parse_ctx, ex)
line_reader.Reset() # After sourcing startup file, render $PS1
return main_loop.Interactive(opts, ex, c_parser, display, arena)
nodes_out = [] if exec_opts.noexec else None
if nodes_out is None and opts.parser_mem_dump:
raise args.UsageError('--parser-mem-dump can only be used with -n')
_tlog('Execute(node)')
status = main_loop.Batch(ex, c_parser, arena, nodes_out=nodes_out)
# Only print nodes if the whole parse succeeded.
if nodes_out is not None and status == 0:
if opts.parser_mem_dump: # only valid in -n mode
# This might be superstition, but we want to let the value stabilize
# after parsing. bash -c 'cat /proc/$$/status' gives different results
# with a sleep.
time.sleep(0.001)
input_path = '/proc/%d/status' % posix.getpid()
with open(input_path) as f, open(opts.parser_mem_dump, 'w') as f2:
contents = f.read()
f2.write(contents)
log('Wrote %s to %s (--parser-mem-dump)', input_path,
opts.parser_mem_dump)
ui.PrintAst(nodes_out, opts)
# NOTE: 'exit 1' is ControlFlow and gets here, but subshell/commandsub
# don't because they call sys.exit().
if opts.runtime_mem_dump:
# This might be superstition, but we want to let the value stabilize
# after parsing. bash -c 'cat /proc/$$/status' gives different results
# with a sleep.
time.sleep(0.001)
input_path = '/proc/%d/status' % posix.getpid()
with open(input_path) as f, open(opts.runtime_mem_dump, 'w') as f2:
contents = f.read()
f2.write(contents)
log('Wrote %s to %s (--runtime-mem-dump)', input_path,
opts.runtime_mem_dump)
# NOTE: We haven't closed the file opened with fd_state.Open
return status
def ShellMain(lang, argv0, argv, login_shell):
"""Used by bin/osh and bin/oil.
Args:
lang: 'osh' or 'oil'
argv0, argv: So we can also invoke bin/osh as 'oil.ovm osh'. Like busybox.
login_shell: Was - on the front?
"""
# Differences between osh and oil:
# - --help? I guess Oil has a SUPERSET of OSH options.
# - oshrc vs oilrc
# - the parser and executor
# - Change the prompt in the interactive shell?
assert lang in ('osh', 'oil'), lang
arg_r = args.Reader(argv)
try:
opts = OSH_SPEC.Parse(arg_r)
except args.UsageError as e:
ui.usage('osh usage error: %s', e)
return 2
if opts.help:
loader = util.GetResourceLoader()
builtin.Help(['%s-usage' % lang], loader)
return 0
if opts.version:
# OSH version is the only binary in Oil right now, so it's all one version.
_ShowVersion()
return 0
# TODO: This should be in interactive mode only?
builtin.RegisterSigIntHandler()
if arg_r.AtEnd():
dollar0 = argv0
has_main = False
else:
dollar0 = arg_r.Peek() # the script name, or the arg after -c
has_main = True
pool = alloc.Pool()
arena = pool.NewArena()
# NOTE: has_main is only for ${BASH_SOURCE[@} and family. Could be a
# required arg.
mem = state.Mem(dollar0,
argv[arg_r.i + 1:],
posix.environ,
arena,
has_main=has_main)
funcs = {}
fd_state = process.FdState()
exec_opts = state.ExecOpts(mem, readline)
builtin.SetExecOpts(exec_opts, opts.opt_changes)
aliases = {} # feedback between runtime and parser
parse_ctx = parse_lib.ParseContext(arena, aliases) # For main_loop
# Three ParseContext instances SHARE aliases. TODO: Complete aliases.
comp_arena = pool.NewArena()
comp_arena.PushSource('<completion>')
trail1 = parse_lib.Trail()
comp_ctx = parse_lib.ParseContext(comp_arena, aliases, trail=trail1)
hist_arena = pool.NewArena()
hist_arena.PushSource('<history>')
trail2 = parse_lib.Trail()
hist_ctx = parse_lib.ParseContext(hist_arena, aliases, trail=trail2)
# Deps helps manages dependencies. These dependencies are circular:
# - ex and word_ev, arith_ev -- for command sub, arith sub
# - arith_ev and word_ev -- for $(( ${a} )) and $x$(( 1 ))
# - ex and builtins (which execute code, like eval)
# - prompt_ev needs word_ev for $PS1, which needs prompt_ev for @P
exec_deps = cmd_exec.Deps()
if opts.debug_file:
debug_f = util.DebugFile(fd_state.Open(opts.debug_file, mode='w'))
else:
debug_f = util.NullDebugFile()
exec_deps.debug_f = debug_f
debug_f.log('Debug file is %s', opts.debug_file)
splitter = split.SplitContext(mem)
exec_deps.splitter = splitter
# Controlled by env variable, flag, or hook?
exec_deps.dumper = dev.CrashDumper(
posix.environ.get('OSH_CRASH_DUMP_DIR', ''))
if opts.xtrace_to_debug_file:
trace_f = debug_f
else:
trace_f = util.DebugFile(sys.stderr)
exec_deps.trace_f = trace_f
# TODO: Separate comp_state and comp_lookup.
comp_state = completion.State()
comp_lookup = completion.Lookup()
builtins = { # Lookup
builtin_e.HISTORY: builtin.History(readline),
builtin_e.COMPOPT: builtin_comp.CompOpt(comp_state),
builtin_e.COMPADJUST: builtin_comp.CompAdjust(mem),
}
ex = cmd_exec.Executor(mem, fd_state, funcs, builtins, exec_opts,
parse_ctx, exec_deps)
exec_deps.ex = ex
word_ev = word_eval.NormalWordEvaluator(mem, exec_opts, exec_deps, arena)
exec_deps.word_ev = word_ev
arith_ev = expr_eval.ArithEvaluator(mem, exec_opts, word_ev, arena)
exec_deps.arith_ev = arith_ev
word_ev.arith_ev = arith_ev # Another circular dependency
bool_ev = expr_eval.BoolEvaluator(mem, exec_opts, word_ev, arena)
exec_deps.bool_ev = bool_ev
tracer = cmd_exec.Tracer(parse_ctx, exec_opts, mem, word_ev, trace_f)
exec_deps.tracer = tracer
# HACK for circular deps
ex.word_ev = word_ev
ex.arith_ev = arith_ev
ex.bool_ev = bool_ev
ex.tracer = tracer
spec_builder = builtin_comp.SpecBuilder(ex, parse_ctx, word_ev, splitter)
# Add some builtins that depend on the executor!
complete_builtin = builtin_comp.Complete(spec_builder,
comp_lookup) # used later
builtins[builtin_e.COMPLETE] = complete_builtin
builtins[builtin_e.COMPGEN] = builtin_comp.CompGen(spec_builder)
if lang == 'oil':
# The Oil executor wraps an OSH executor? It needs to be able to source
# it.
ex = oil_cmd_exec.OilExecutor(ex)
# PromptEvaluator rendering is needed in non-interactive shells for @P.
prompt_ev = ui.PromptEvaluator(lang, arena, parse_ctx, ex, mem)
exec_deps.prompt_ev = prompt_ev
word_ev.prompt_ev = prompt_ev # HACK for circular deps
# History evaluation is a no-op if readline is None.
hist_ev = reader.HistoryEvaluator(readline, hist_ctx, debug_f)
# Calculate ~/.config/oil/oshrc or oilrc
# Use ~/.config/oil to avoid cluttering the user's home directory. Some
# users may want to ln -s ~/.config/oil/oshrc ~/oshrc or ~/.oshrc.
# https://unix.stackexchange.com/questions/24347/why-do-some-applications-use-config-appname-for-their-config-data-while-other
home_dir = mem.GetVar('HOME')
assert home_dir.tag == value_e.Str, home_dir
rc_path = opts.rcfile or os_path.join(home_dir.s, '.config/oil',
lang + 'rc')
history_filename = os_path.join(home_dir.s, '.config/oil',
'history_' + lang)
if opts.c is not None:
arena.PushSource('<command string>')
line_reader = reader.StringLineReader(opts.c, arena)
if opts.i: # -c and -i can be combined
exec_opts.interactive = True
elif opts.i: # force interactive
arena.PushSource('<stdin -i>')
# interactive shell only
line_reader = reader.InteractiveLineReader(arena, prompt_ev, hist_ev)
exec_opts.interactive = True
else:
try:
script_name = arg_r.Peek()
except IndexError:
if sys.stdin.isatty():
arena.PushSource('<interactive>')
# interactive shell only
line_reader = reader.InteractiveLineReader(
arena, prompt_ev, hist_ev)
exec_opts.interactive = True
else:
arena.PushSource('<stdin>')
line_reader = reader.FileLineReader(sys.stdin, arena)
else:
arena.PushSource(script_name)
try:
f = fd_state.Open(script_name)
except OSError as e:
util.error("Couldn't open %r: %s", script_name,
posix.strerror(e.errno))
return 1
line_reader = reader.FileLineReader(f, arena)
# TODO: assert arena.NumSourcePaths() == 1
# TODO: .rc file needs its own arena.
if lang == 'osh':
c_parser = parse_ctx.MakeOshParser(line_reader)
else:
c_parser = parse_ctx.MakeOilParser(line_reader)
if exec_opts.interactive:
# NOTE: We're using a different evaluator here. The completion system can
# also run functions... it gets the Executor through Executor._Complete.
if readline:
ev = word_eval.CompletionWordEvaluator(mem, exec_opts, exec_deps,
arena)
progress_f = ui.StatusLine()
root_comp = completion.RootCompleter(ev, mem, comp_lookup,
comp_state, comp_ctx,
progress_f, debug_f)
_InitReadline(readline, history_filename, root_comp, debug_f)
_InitDefaultCompletions(ex, complete_builtin, comp_lookup)
# NOTE: Call this AFTER _InitDefaultCompletions.
SourceStartupFile(rc_path, lang, parse_ctx, ex)
return main_loop.Interactive(opts, ex, c_parser, arena)
# TODO: Remove this after removing it from benchmarks/osh-runtime. It's no
# longer relevant with main_loop.
if opts.parser_mem_dump:
# This might be superstition, but we want to let the value stabilize
# after parsing. bash -c 'cat /proc/$$/status' gives different results
# with a sleep.
time.sleep(0.001)
input_path = '/proc/%d/status' % posix.getpid()
with open(input_path) as f, open(opts.parser_mem_dump, 'w') as f2:
contents = f.read()
f2.write(contents)
log('Wrote %s to %s (--parser-mem-dump)', input_path,
opts.parser_mem_dump)
nodes_out = [] if exec_opts.noexec else None
_tlog('Execute(node)')
status = main_loop.Batch(ex, c_parser, arena, nodes_out=nodes_out)
# Only print nodes if the whole parse succeeded.
if nodes_out is not None and status == 0:
ui.PrintAst(nodes_out, opts)
# NOTE: 'exit 1' is ControlFlow and gets here, but subshell/commandsub
# don't because they call sys.exit().
if opts.runtime_mem_dump:
# This might be superstition, but we want to let the value stabilize
# after parsing. bash -c 'cat /proc/$$/status' gives different results
# with a sleep.
time.sleep(0.001)
input_path = '/proc/%d/status' % posix.getpid()
with open(input_path) as f, open(opts.runtime_mem_dump, 'w') as f2:
contents = f.read()
f2.write(contents)
log('Wrote %s to %s (--runtime-mem-dump)', input_path,
opts.runtime_mem_dump)
# NOTE: This doesn't cause any spec tests to fail, but it could.
if posix.environ.get('ASDL_TYPE_CHECK'):
log('NOTE: Performed %d ASDL_TYPE_CHECKs.', runtime.NUM_TYPE_CHECKS)
# NOTE: We haven't closed the file opened with fd_state.Open
return status
fmt = ('To: %d\n' +
'From: 8\n' +
'Cmd: %s\n' +
'Id: %d\n' +
'Key: %s\n' +
'Value: %s')
if __name__ == '__main__':
args = parser.parse_args()
if not args.test:
s = socket.socket(socket.AF_UNIX, socket.SOCK_SEQPACKET)
if s.connect_ex('\0%s.bus.8' % getpass.getuser()):
print 'connection error'
sys.exit(1)
msg = fmt % (args.dest[0], args.cmd[0], posix.getpid(), args.key[0], args.val)
if args.test:
print msg
else:
s.send(msg)
ready = select.select([s], [], [], 4.0)
if ready[0]:
m = s.recv(4096)
print m
else:
print '*** no reply ***'
import __nemesys__
import posix
import sys
st = posix.stat(__file__)
assert st.st_size == len(__nemesys__.module_source(__name__))
print('this script is ' + repr(st.st_size) +
' bytes long, according to both stat and __nemesys__')
for k in posix.environ:
print('environment variable: ' + repr(k))
for filename in posix.listdir():
print('file in current directory: ' + filename)
pid = posix.fork()
if pid:
print('parent process ' + repr(posix.getpid()) + ' ran child ' + repr(pid))
else:
print('child process ' + repr(posix.getpid()) + ' started')
def get_tmpfile_string( self ): return self.tmpfile_template_string % \ ( self.key_string, posix.getpid() )
