def _install(maybe=False):
if _inst_state() != "":
return
start = time.time()
gs.set_attr(_inst_name(), 'busy')
m_out = build_mg()
gs.set_attr(_inst_name(), 'done')
if m_out == 'ok':
ev.margo_ready()
gs.notify('GoSublime', 'ready')
if maybe:
return
e = sh.env()
a = [
'GoSublime init %s (%0.3fs)' % (INSTALL_VERSION, time.time() - start),
]
sl = [('install margo', m_out)]
sl.extend(sanity_check(e))
a.extend(sanity_check_sl(sl))
gs.println(*a)
_check_env(e)
killSrv()
_cleanup()
def plugin_loaded():
from gosubl import about
from gosubl import sh
from gosubl import ev
from gosubl import gs
from gosubl import mg9
if VERSION != about.VERSION:
gs.show_output('GoSublime-main', '\n'.join([
'GoSublime has been updated.',
'New version: `%s`, current version: `%s`' % (VERSION, about.VERSION),
'Please restart Sublime Text to complete the update.',
execErr,
]))
return
if gs.attr('about.version'):
gs.show_output('GoSublime-main', '\n'.join([
'GoSublime appears to have been updated.',
'New ANNOUNCE: `%s`, current ANNOUNCE: `%s`' % (ANN, about.ANN),
'You may need to restart Sublime Text.',
]))
return
mods = [
('gs', gs),
('sh', sh),
('mg9', mg9),
]
gs.set_attr('about.version', VERSION)
gs.set_attr('about.ann', ANN)
for mod_name, mod in mods:
print('GoSublime %s: init mod(%s)' % (VERSION, mod_name))
try:
mod.gs_init({
'version': VERSION,
'ann': ANN,
'margo_exe': MARGO_EXE,
})
except TypeError:
# old versions didn't take an arg
mod.gs_init()
ev.init.post_add = lambda e, f: f()
ev.init()
def cb():
aso = gs.aso()
old_version = aso.get('version', '')
old_ann = aso.get('ann', '')
if about.VERSION > old_version or about.ANN > old_ann:
aso.set('version', about.VERSION)
aso.set('ann', about.ANN)
gs.save_aso()
gs.focus(gs.dist_path('CHANGELOG.md'))
sublime.set_timeout(cb, 0)
def plugin_loaded():
from gosubl import about
from gosubl import gs
from gosubl import mg9
gs.gs_init()
mg9.gs_init()
# we need the values in the file on-disk but we don't want any interference with the live env
try:
gs.set_attr('about.version', VERSION)
gs.set_attr('about.ann', ANN)
if about.VERSION != VERSION:
gs.show_output(
'GoSublime-source', '\n'.join([
'GoSublime source has been updated.',
'New version: `%s`, current version: `%s`' %
(VERSION, about.VERSION),
'Please restart Sublime Text to complete the update.',
]))
except Exception:
pass
def cb():
aso = gs.aso()
old_version = aso.get('version', '')
old_ann = aso.get('ann', '')
if about.VERSION > old_version or about.ANN > old_ann:
aso.set('version', about.VERSION)
aso.set('ann', about.ANN)
gs.save_aso()
gs.focus(gs.dist_path('CHANGELOG.md'))
sublime.set_timeout(cb, 0)
def plugin_loaded():
from gosubl import about
from gosubl import sh
from gosubl import ev
from gosubl import gs
from gosubl import mg9
if VERSION != about.VERSION:
gs.show_output('GoSublime-main', '\n'.join([
'GoSublime has been updated.',
'New version: `%s`, current version: `%s`' % (VERSION, about.VERSION),
'Please restart Sublime Text to complete the update.',
execErr,
]))
return
if gs.attr('about.version'):
gs.show_output('GoSublime-main', '\n'.join([
'GoSublime appears to have been updated.',
'New ANNOUNCE: `%s`, current ANNOUNCE: `%s`' % (ANN, about.ANN),
'You may need to restart Sublime Text.',
]))
return
mods = [
('gs', gs),
('sh', sh),
('mg9', mg9),
]
gs.set_attr('about.version', VERSION)
gs.set_attr('about.ann', ANN)
for mod_name, mod in mods:
print('GoSublime %s: init mod(%s)' % (VERSION, mod_name))
try:
mod.gs_init({
'version': VERSION,
'ann': ANN,
'margo_exe': MARGO_EXE,
})
except TypeError:
# old versions didn't take an arg
mod.gs_init()
ev.init.post_add = lambda e, f: f()
ev.init()
def cb():
aso = gs.aso()
old_version = aso.get('version', '')
old_ann = aso.get('ann', '')
if about.VERSION > old_version or about.ANN > old_ann:
aso.set('version', about.VERSION)
aso.set('ann', about.ANN)
gs.save_aso()
gs.focus(gs.dist_path('CHANGELOG.md'))
sublime.set_timeout(cb, 0)
def plugin_loaded():
from gosubl import about
from gosubl import gs
from gosubl import mg9
gs.gs_init()
mg9.gs_init()
# we need the values in the file on-disk but we don't want any interference with the live env
try:
gs.set_attr('about.version', VERSION)
gs.set_attr('about.ann', ANN)
if about.VERSION != VERSION:
gs.show_output('GoSublime-source', '\n'.join([
'GoSublime source has been updated.',
'New version: `%s`, current version: `%s`' % (VERSION, about.VERSION),
'Please restart Sublime Text to complete the update.',
]))
except Exception:
pass
def cb():
aso = gs.aso()
old_version = aso.get('version', '')
old_ann = aso.get('ann', '')
if about.VERSION > old_version or about.ANN > old_ann:
aso.set('version', about.VERSION)
aso.set('ann', about.ANN)
gs.save_aso()
gs.focus(gs.dist_path('CHANGELOG.md'))
sublime.set_timeout(cb, 0)
def _recv():
while True:
try:
ln = gs.mg9_recv_q.get()
try:
ln = ln.strip()
if ln:
r, _ = gs.json_decode(ln, {})
token = r.get("token", "")
tag = r.get("tag", "")
k = REQUEST_PREFIX + token
req = gs.attr(k, {})
gs.del_attr(k)
if req and req.f:
if tag != TAG:
gs.notice(
DOMAIN,
"\n".join(
[
"GoSublime/MarGo appears to be out-of-sync.",
"Maybe restart Sublime Text.",
"Received tag `%s', expected tag `%s'. " % (tag, TAG),
]
),
)
err = r.get("error", "")
gs.debug(
DOMAIN,
"margo response: %s"
% {
"method": req.method,
"tag": tag,
"token": token,
"dur": "%0.3fs" % (time.time() - req.tm),
"err": err,
"size": "%0.1fK" % (len(ln) / 1024.0),
},
)
dat = expand_jdata(r.get("data", {}))
try:
keep = req.f(dat, err) is True
if keep:
req.tm = time.time()
gs.set_attr(k, req)
except Exception:
gs.error_traceback(DOMAIN)
else:
gs.debug(DOMAIN, "Ignoring margo: token: %s" % token)
except Exception:
gs.println(gs.traceback())
except Exception:
gs.println(gs.traceback())
break
def plugin_loaded():
from gosubl import about
from gosubl import gs
from gosubl import mg9
gs.gs_init()
mg9.gs_init()
gs.set_attr('about.version', about.VERSION)
gs.set_attr('about.ann', about.ANN)
def run(self, edit, pos, content, added_path=''): pos = int(pos) # un-f*****g-believable view = self.view dirty, err = gspatch.merge(view, pos, content, edit) if err: gs.notice_undo(DOMAIN, err, view, dirty) elif dirty: k = 'last_import_path.%s' % gs.view_fn(self.view) if added_path: gs.set_attr(k, added_path) else: gs.del_attr(k)
def _recv():
while True:
try:
ln = gs.mg9_recv_q.get()
try:
ln = ln.strip()
if ln:
r, _ = gs.json_decode(ln, {})
token = r.get('token', '')
tag = r.get('tag', '')
k = REQUEST_PREFIX + token
req = gs.attr(k, {})
gs.del_attr(k)
if req and req.f:
if tag != TAG:
gs.notice(
DOMAIN, "\n".join([
"GoSublime/MarGo appears to be out-of-sync.",
"Maybe restart Sublime Text.",
"Received tag `%s', expected tag `%s'. " %
(tag, TAG),
]))
err = r.get('error', '')
ev.debug(
DOMAIN, "margo response: %s" % {
'method': req.method,
'tag': tag,
'token': token,
'dur': '%0.3fs' % (time.time() - req.tm),
'err': err,
'size': '%0.1fK' % (len(ln) / 1024.0),
})
dat = expand_jdata(r.get('data', {}))
try:
keep = req.f(dat, err) is True
if keep:
req.tm = time.time()
gs.set_attr(k, req)
except Exception:
gs.error_traceback(DOMAIN)
else:
ev.debug(DOMAIN, 'Ignoring margo: token: %s' % token)
except Exception:
gs.println(gs.traceback())
except Exception:
gs.println(gs.traceback())
break
def run(self, edit, pos, content, added_path=''):
pos = int(pos) # un-f*****g-believable
view = self.view
dirty, err = gspatch.merge(view, pos, content, edit)
if err:
ui.error(DOMAIN, err)
if dirty:
sublime.set_timeout(lambda: view.run_command('undo'), 0)
elif dirty:
k = 'last_import_path.%s' % vu.V(view).vfn()
if added_path:
gs.set_attr(k, added_path)
else:
gs.del_attr(k)
def _send():
while True:
try:
try:
method, arg, cb = gs.mg9_send_q.get()
proc = gs.attr(PROC_ATTR_NAME)
if not proc or proc.poll() is not None:
killSrv()
maybe_install()
if not gs.checked(DOMAIN, 'launch _recv'):
gsq.launch(DOMAIN, _recv)
proc, _, err = gsshell.proc([_margo_bin(), '-poll=30'], stderr=gs.LOGFILE ,env={
'XDG_CONFIG_HOME': gs.home_path(),
})
gs.set_attr(PROC_ATTR_NAME, proc)
if not proc:
gs.notice(DOMAIN, 'Cannot start MarGo: %s' % err)
try:
cb({}, 'Abort. Cannot start MarGo')
except:
pass
continue
gsq.launch(DOMAIN, lambda: _read_stdout(proc))
req = Request(f=cb, method=method)
gs.set_attr(REQUEST_PREFIX+req.token, req)
gs.debug(DOMAIN, 'margo request: method: %s, token: %s' % (req.method, req.token))
header, _ = gs.json_encode({'method': method, 'token': req.token})
body, _ = gs.json_encode(arg)
ln = '%s %s\n' % (header, body)
if gs.PY3K:
proc.stdin.write(bytes(ln, 'UTF-8'))
else:
proc.stdin.write(ln)
except Exception:
killSrv()
gs.println(gs.traceback())
except Exception:
gs.println(gs.traceback())
break
def _recv():
while True:
try:
ln = gs.mg9_recv_q.get()
try:
ln = ln.strip()
if ln:
r, _ = gs.json_decode(ln, {})
token = r.get('token', '')
tag = r.get('tag', '')
k = REQUEST_PREFIX+token
req = gs.attr(k, {})
gs.del_attr(k)
if req and req.f:
if tag != TAG:
gs.notice(DOMAIN, "\n".join([
"GoSublime/MarGo appears to be out-of-sync.",
"Maybe restart Sublime Text.",
"Received tag `%s', expected tag `%s'. " % (tag, TAG),
]))
err = r.get('error', '')
ev.debug(DOMAIN, {
'_mode': 'response',
'method': req.method,
'tag': tag,
'token': token,
'dur': '%0.3fs' % (time.time() - req.tm),
'err': err,
'size': '%0.1fK' % (len(ln)/1024.0),
})
dat = expand_jdata(r.get('data', {}))
try:
keep = req.f(dat, err) is True
if keep:
req.tm = time.time()
gs.set_attr(k, req)
except Exception:
gs.error_traceback(DOMAIN)
else:
ev.debug(DOMAIN, 'Ignoring margo: token: %s' % token)
except Exception:
gs.print_traceback()
except Exception:
gs.print_traceback()
break
def plugin_loaded():
from gosubl import about
from gosubl import ev
from gosubl import gs
from gosubl import mg9
mods = [
('gs', gs),
('mg9', mg9),
]
gs.set_attr('about.version', VERSION)
gs.set_attr('about.ann', ANN)
for mod_name, mod in mods:
print('GoSublime %s: init mod(%s)' % (VERSION, mod_name))
try:
mod.gs_init({
'version': VERSION,
'ann': ANN,
'margo_exe': MARGO_EXE,
})
except TypeError:
# old versions didn't take an arg
mod.gs_init()
ev.init.post_add = lambda e, f: f()
ev.init()
def cb():
aso = gs.aso()
old_version = aso.get('version', '')
old_ann = aso.get('ann', '')
if about.VERSION > old_version or about.ANN > old_ann:
aso.set('version', about.VERSION)
aso.set('ann', about.ANN)
gs.save_aso()
gs.focus(gs.dist_path('CHANGELOG.md'))
sublime.set_timeout(cb, 0)
def plugin_loaded():
from gosubl import about
from gosubl import ev
from gosubl import gs
from gosubl import mg9
mods = [
('gs', gs),
('mg9', mg9),
]
gs.set_attr('about.version', VERSION)
gs.set_attr('about.ann', ANN)
for mod_name, mod in mods:
print('GoSublime %s: init mod(%s)' % (VERSION, mod_name))
try:
mod.gs_init({
'version': VERSION,
'ann': ANN,
'margo_exe': MARGO_EXE,
})
except TypeError:
# old versions didn't take an arg
mod.gs_init()
ev.init.post_add = lambda e, f: f()
ev.init()
def cb():
aso = gs.aso()
old_version = aso.get('version', '')
old_ann = aso.get('ann', '')
if about.VERSION > old_version or about.ANN > old_ann:
aso.set('version', about.VERSION)
aso.set('ann', about.ANN)
gs.save_aso()
gs.focus(gs.dist_path('CHANGELOG.md'))
sublime.set_timeout(cb, 0)
def do_sync_active_view(view):
fn = view.file_name() or ''
gs.set_attr('active_fn', fn)
if fn:
gs.set_attr('last_active_fn', fn)
if fn.lower().endswith('.go'):
gs.set_attr('last_active_go_fn', fn)
if gs.is_pkg_view(view):
m = {}
psettings = view.settings().get('GoSublime')
if psettings and gs.is_a(psettings, {}):
m = gs.mirror_settings(psettings)
gs.set_attr('last_active_project_settings', gs.dval(m, {}))
def do_sync_active_view(view):
fn = view.file_name() or ''
gs.set_attr('active_fn', fn)
if fn:
gs.set_attr('last_active_fn', fn)
if fn.lower().endswith('.go'):
gs.set_attr('last_active_go_fn', fn)
win = view.window()
if win is not None and view in win.views():
m = {}
psettings = view.settings().get('GoSublime')
if psettings and gs.is_a(psettings, {}):
psettings['env']['GOPATH'] = expand_template(psettings['env']['GOPATH'])
m = gs.mirror_settings(psettings)
gs.set_attr('last_active_project_settings', gs.dval(m, {}))
def _recv():
while True:
try:
ln = gs.mg9_recv_q.get()
try:
ln = ln.strip()
if ln:
r, _ = gs.json_decode(ln, {})
token = r.get('token', '')
k = REQUEST_PREFIX+token
req = gs.attr(k)
gs.del_attr(k)
if req and req.f:
gs.debug(DOMAIN, "margo response: method: %s, token: %s, dur: %0.3fs, err: `%s'" % (
req.method,
req.token,
(time.time() - req.tm),
r.get('error', ''),
))
dat = expand_jdata(r.get('data', {}))
err = r.get('error', '')
try:
keep = req.f(dat, err) is not True
if keep:
req.tm = time.time()
gs.set_attr(k, req)
except Exception:
gs.error_traceback(DOMAIN)
else:
gs.debug(DOMAIN, 'Ignoring margo: token: %s' % token)
except Exception:
gs.println(gs.traceback())
except Exception:
gs.println(gs.traceback())
break
def do_sync_active_view(view):
fn = view.file_name() or ''
gs.set_attr('active_fn', fn)
if fn:
gs.set_attr('last_active_fn', fn)
if fn.lower().endswith('.go'):
gs.set_attr('last_active_go_fn', fn)
win = view.window()
if win is not None and view in win.views():
m = {}
psettings = view.settings().get('GoSublime')
if psettings and gs.is_a(psettings, {}):
psettings['env']['GOPATH'] = expand_template(
psettings['env']['GOPATH'])
m = gs.mirror_settings(psettings)
gs.set_attr('last_active_project_settings', gs.dval(m, {}))
def _send():
while True:
try:
try:
method, arg, cb = gs.mg9_send_q.get()
proc = gs.attr(PROC_ATTR_NAME)
if not proc or proc.poll() is not None:
killSrv()
if gs.attr(_inst_name(), "") != "busy":
maybe_install()
if not gs.checked(DOMAIN, "launch _recv"):
gsq.launch(DOMAIN, _recv)
while gs.attr(_inst_name(), "") == "busy":
time.sleep(0.100)
mg_bin = _margo_bin()
cmd = [mg_bin, "-oom", gs.setting("margo_oom", 0), "-poll", 30, "-tag", TAG]
if os.path.exists(mg_bin):
c = sh.Command(cmd)
c.stderr = gs.LOGFILE
c.env = {"GOGC": 10, "XDG_CONFIG_HOME": gs.home_path()}
pr = c.proc()
if pr.ok:
proc = pr.p
err = ""
else:
proc = None
err = "Cannot start MarGo: %s" % pr.exc
else:
proc = None
err = "Can't find the MarGo binary at `%s`" % mg_bin
if err or not proc or proc.poll() is not None:
killSrv()
gs.notice(DOMAIN, "Cannot start MarGo:\n%s" % err)
try:
cb({}, "Abort. Cannot start MarGo")
except:
pass
continue
gs.set_attr(PROC_ATTR_NAME, proc)
gsq.launch(DOMAIN, lambda: _read_stdout(proc))
req = Request(f=cb, method=method)
gs.set_attr(REQUEST_PREFIX + req.token, req)
header, err = gs.json_encode(req.header())
if err:
_cb_err(cb, "Failed to construct ipc header: %s" % err)
continue
body, err = gs.json_encode(arg)
if err:
_cb_err(cb, "Failed to construct ipc body: %s" % err)
continue
ev.debug(DOMAIN, "margo request: %s " % header)
ln = "%s %s\n" % (header, body)
try:
if gs.PY3K:
proc.stdin.write(bytes(ln, "UTF-8"))
else:
proc.stdin.write(ln)
except Exception as ex:
_cb_err(cb, "Cannot talk to MarGo: %s" % err)
killSrv()
gs.println(gs.traceback())
except Exception:
killSrv()
gs.println(gs.traceback())
except Exception:
gs.println(gs.traceback())
break
def install(aso_install_vesion, force_install):
global INSTALL_EXE
if gs.attr(_inst_name(), '') != "":
gs.notify(
DOMAIN,
'Installation aborted. Install command already called for GoSublime %s.'
% INSTALL_VERSION)
return
_init_go_version()
INSTALL_EXE = INSTALL_EXE.replace('_%s.exe' % about.DEFAULT_GO_VERSION,
'_%s.exe' % GO_VERSION)
about.MARGO_EXE = INSTALL_EXE
is_update = about.VERSION != INSTALL_VERSION
gs.set_attr(_inst_name(), 'busy')
init_start = time.time()
if not is_update and not force_install and _bins_exist(
) and aso_install_vesion == INSTALL_VERSION:
m_out = 'no'
else:
gs.notify('GoSublime', 'Installing MarGo')
start = time.time()
go_bin = _go_bin()
if go_bin:
cmd = [go_bin, 'build', '-o', _margo_bin(INSTALL_EXE)]
cwd = _margo_src()
ev.debug('%s.build' % DOMAIN, {
'cmd': cmd,
'cwd': cwd,
})
m_out, err, _ = _run(cmd, cwd=cwd)
else:
m_out = ''
err = 'Cannot find the `go` exe'
m_out = gs.ustr(m_out)
err = gs.ustr(err)
m_out, m_ok = _so(m_out, err, start, time.time())
if m_ok:
def f():
gs.aso().set('install_version', INSTALL_VERSION)
gs.save_aso()
sublime.set_timeout(f, 0)
if not is_update:
gs.notify('GoSublime', 'Syncing environment variables')
out, err, _ = gsshell.run([INSTALL_EXE, '-env'],
cwd=gs.home_dir_path(),
shell=True)
# notify this early so we don't mask any notices below
gs.notify('GoSublime', 'Ready')
if err:
gs.notice(DOMAIN, 'Cannot run get env vars: %s' % (err))
else:
env, err = gs.json_decode(out, {})
if err:
gs.notice(
DOMAIN,
'Cannot load env vars: %s\nenv output: %s' % (err, out))
else:
gs.environ9.update(env)
gs.set_attr(_inst_name(), 'done')
if is_update:
gs.show_output(
'GoSublime-source', '\n'.join([
'GoSublime source has been updated.',
'New version: `%s`, current version: `%s`' %
(INSTALL_VERSION, about.VERSION),
'Please restart Sublime Text to complete the update.',
]))
else:
e = gs.env()
a = [
'GoSublime init %s (%0.3fs)' %
(INSTALL_VERSION, time.time() - init_start),
]
sl = [('install margo', m_out)]
sl.extend(sanity_check(e))
a.extend(sanity_check_sl(sl))
gs.println(*a)
missing = [k for k in ('GOROOT', 'GOPATH') if not e.get(k)]
if missing:
missing_message = '\n'.join([
'Missing required environment variables: %s' %
' '.join(missing),
'See the `Quirks` section of USAGE.md for info',
])
cb = lambda ok: gs.show_output(
DOMAIN, missing_message, merge_domain=True, print_output=False)
gs.error(DOMAIN, missing_message)
gs.focus(gs.dist_path('USAGE.md'), focus_pat='^Quirks', cb=cb)
killSrv()
start = time.time()
# acall('ping', {}, lambda res, err: gs.println('MarGo Ready %0.3fs' % (time.time() - start)))
report_x = lambda: gs.println(
"GoSublime: Exception while cleaning up old binaries",
gs.traceback())
try:
bin_dirs = [
gs.home_path('bin'),
os.path.join(sublime.packages_path(), 'User', 'GoSublime', '9',
'bin'),
]
l = []
for d in bin_dirs:
try:
for fn in os.listdir(d):
if fn != INSTALL_EXE and about.MARGO_EXE_PAT.match(fn):
l.append(os.path.join(d, fn))
except Exception:
pass
for fn in l:
try:
gs.println("GoSublime: removing old binary: `%s'" % fn)
os.remove(fn)
except Exception:
report_x()
except Exception:
report_x()
def plugin_loaded():
from gosubl import about
from gosubl import sh
from gosubl import ev
from gosubl import gs
from gosubl import mg9
if VERSION != about.VERSION:
gs.show_output(
"GoSublime-main",
"\n".join(
[
"GoSublime has been updated.",
"New version: `%s`, current version: `%s`" % (VERSION, about.VERSION),
"Please restart Sublime Text to complete the update.",
execErr,
]
),
)
return
if gs.attr("about.version"):
gs.show_output(
"GoSublime-main",
"\n".join(
[
"GoSublime appears to have been updated.",
"New ANNOUNCE: `%s`, current ANNOUNCE: `%s`" % (ANN, about.ANN),
"You may need to restart Sublime Text.",
]
),
)
return
mods = [("gs", gs), ("sh", sh), ("mg9", mg9)]
gs.set_attr("about.version", VERSION)
gs.set_attr("about.ann", ANN)
for mod_name, mod in mods:
print("GoSublime %s: init mod(%s)" % (VERSION, mod_name))
try:
mod.gs_init({"version": VERSION, "ann": ANN, "margo_exe": MARGO_EXE})
except TypeError:
# old versions didn't take an arg
mod.gs_init()
ev.init.post_add = lambda e, f: f()
ev.init()
def cb():
aso = gs.aso()
old_version = aso.get("version", "")
old_ann = aso.get("ann", "")
if about.VERSION > old_version or about.ANN > old_ann:
aso.set("version", about.VERSION)
aso.set("ann", about.ANN)
gs.save_aso()
gs.focus(gs.dist_path("CHANGELOG.md"))
sublime.set_timeout(cb, 0)
def _send():
"""Polls the mg9_send_q queue, sending requests to margo. If the margo
process is not running _send() starts it and sets the PROC_ATTR_NAME attr.
"""
# TODO: REFACTOR.
while True:
try:
try:
method, arg, cb = gs.mg9_send_q.get()
# CEV: proc should be the margo process.
proc = gs.attr(PROC_ATTR_NAME)
# CEV: Looks like this starts/restarts the margo process.
if not proc or proc.poll() is not None:
killSrv()
if _inst_state() != "busy":
maybe_install()
# TODO: Improve the handling of install state.
while _inst_state() == "busy":
time.sleep(0.100)
# Margo path and command line options.
mg_bin = _margo_bin()
cmd = [
mg_bin,
"-oom",
gs.setting("margo_oom", 0),
"-poll",
30,
"-tag",
TAG,
]
c = sh.Command(cmd)
c.stderr = gs.LOGFILE
c.env = {"GOGC": 10, "XDG_CONFIG_HOME": gs.home_path()}
pr = c.proc()
if pr.ok:
proc = pr.p
err = ""
else:
proc = None
err = "Exception: %s" % pr.exc
if err or not proc or proc.poll() is not None:
killSrv()
_call(cb, {}, "Abort. Cannot start MarGo: %s" % err)
continue
# Set the process name
gs.set_attr(PROC_ATTR_NAME, proc)
# Launch stdout feed.
gsq.launch(DOMAIN, lambda: _read_stdout(proc))
req = Request(f=cb, method=method)
gs.set_attr(REQUEST_PREFIX + req.token, req)
header, err = gs.json_encode(req.header())
if err:
_cb_err(cb, "Failed to construct ipc header: %s" % err)
continue
body, err = gs.json_encode(arg)
if err:
_cb_err(cb, "Failed to construct ipc body: %s" % err)
continue
ev.debug(DOMAIN, "margo request: %s " % header)
ln = "%s %s\n" % (header, body)
try:
if gs.PY3K:
proc.stdin.write(bytes(ln, "UTF-8"))
else:
proc.stdin.write(ln)
except Exception as ex:
_cb_err(cb, "Cannot talk to MarGo: %s" % err)
killSrv()
gs.println(gs.traceback())
except Exception:
killSrv()
gs.println(gs.traceback())
except Exception:
gs.println(gs.traceback())
break
def _send():
while True:
try:
try:
method, arg, cb = gs.mg9_send_q.get()
proc = gs.attr(PROC_ATTR_NAME)
if not proc or proc.poll() is not None:
killSrv()
if _inst_state() != "busy":
maybe_install()
while _inst_state() == "busy":
time.sleep(0.100)
mg_bin = _margo_bin()
cmd = [
mg_bin,
'-oom',
gs.setting('margo_oom', 0),
'-poll',
30,
'-tag',
TAG,
]
c = sh.Command(cmd)
c.stderr = gs.LOGFILE
c.env = {
'GOGC': 10,
'XDG_CONFIG_HOME': gs.home_path(),
}
pr = c.proc()
if pr.ok:
proc = pr.p
err = ''
else:
proc = None
err = 'Exception: %s' % pr.exc
if err or not proc or proc.poll() is not None:
killSrv()
_call(cb, {}, 'Abort. Cannot start MarGo: %s' % err)
continue
gs.set_attr(PROC_ATTR_NAME, proc)
gsq.launch(DOMAIN, lambda: _read_stdout(proc))
req = Request(f=cb, method=method)
gs.set_attr(REQUEST_PREFIX + req.token, req)
header, err = gs.json_encode(req.header())
if err:
_cb_err(cb, 'Failed to construct ipc header: %s' % err)
continue
body, err = gs.json_encode(arg)
if err:
_cb_err(cb, 'Failed to construct ipc body: %s' % err)
continue
ev.debug(DOMAIN, 'margo request: %s ' % header)
ln = '%s %s\n' % (header, body)
try:
if gs.PY3K:
proc.stdin.write(bytes(ln, 'UTF-8'))
else:
proc.stdin.write(ln)
except Exception as ex:
_cb_err(cb, 'Cannot talk to MarGo: %s' % err)
killSrv()
gs.println(gs.traceback())
except Exception:
killSrv()
gs.println(gs.traceback())
except Exception:
gs.println(gs.traceback())
break
def install(aso_install_vesion, force_install, _reinstall=False):
global INSTALL_EXE
if not _reinstall and _inst_state() != "":
gs.notify(
DOMAIN,
'Installation aborted. Install command already called for GoSublime %s.'
% INSTALL_VERSION)
return ''
INSTALL_EXE = INSTALL_EXE.replace('_%s.exe' % about.DEFAULT_GO_VERSION,
'_%s.exe' % sh.GO_VERSION)
about.MARGO_EXE = INSTALL_EXE
is_update = about.VERSION != INSTALL_VERSION
gs.set_attr(_inst_name(), 'busy')
init_start = time.time()
if not _reinstall and not is_update and not force_install and _bins_exist(
) and aso_install_vesion == INSTALL_VERSION:
m_out = 'no'
else:
gs.notify('GoSublime', 'Installing MarGo')
start = time.time()
cmd = sh.Command([
'go',
'build',
'-tags',
'gosublime' if ext_main_file() else '',
'-v',
'-o',
INSTALL_EXE,
'gosublime/cmd/margo',
])
cmd.wd = gs.home_dir_path('bin')
cmd.env = {
'CGO_ENABLED': '0',
'GOBIN': '',
'GOPATH': install_gopath(),
}
ev.debug('%s.build' % DOMAIN, {
'cmd': cmd.cmd_lst,
'cwd': cmd.wd,
})
cr = cmd.run()
m_out = 'cmd: `%s`\nstdout: `\n%s\n`\nstderr: `\n%s\n`\nexception: `%s`' % (
cr.cmd_lst,
cr.out.strip(),
cr.err.strip(),
cr.exc,
)
if cr.ok and _bins_exist():
def f():
gs.aso().set('install_version', INSTALL_VERSION)
gs.save_aso()
sublime.set_timeout(f, 0)
else:
err_prefix = 'MarGo build failed'
gs.error(DOMAIN, '%s\n%s' % (err_prefix, m_out))
sl = [('GoSublime error', '\n'.join((
err_prefix,
'This is possibly a bug or miss-configuration of your environment.',
'For more help, please file an issue with the following build output',
'at: https://github.com/DisposaBoy/GoSublime/issues/new',
'or alternatively, you may send an email to: [email protected]',
'\n',
m_out,
)))]
sl.extend(sanity_check({}, False))
gs.show_output('GoSublime', '\n'.join(sanity_check_sl(sl)))
gs.set_attr(_inst_name(), 'done')
if is_update:
gs.show_output(
'GoSublime-source', '\n'.join([
'GoSublime source has been updated.',
'New version: `%s`, current version: `%s`' %
(INSTALL_VERSION, about.VERSION),
'Please restart Sublime Text to complete the update.',
]))
else:
e = sh.env()
a = [
'GoSublime init %s (%0.3fs)' %
(INSTALL_VERSION, time.time() - init_start),
]
sl = [('install margo', m_out)]
sl.extend(sanity_check(e))
a.extend(sanity_check_sl(sl))
gs.println(*a)
missing = [k for k in ('GOROOT', 'GOPATH') if not e.get(k)]
if missing:
missing_message = '\n'.join([
'Missing required environment variables: %s' %
' '.join(missing),
'See the `Quirks` section of USAGE.md for info',
])
cb = lambda ok: gs.show_output(
DOMAIN, missing_message, merge_domain=True, print_output=False)
gs.error(DOMAIN, missing_message)
gs.focus(gs.dist_path('USAGE.md'), focus_pat='^Quirks', cb=cb)
killSrv()
start = time.time()
# acall('ping', {}, lambda res, err: gs.println('MarGo Ready %0.3fs' % (time.time() - start)))
report_x = lambda: gs.println(
"GoSublime: Exception while cleaning up old binaries",
gs.traceback())
try:
bin_dirs = [
gs.home_path('bin'),
]
l = []
for d in bin_dirs:
try:
for fn in os.listdir(d):
if fn != INSTALL_EXE and about.MARGO_EXE_PAT.match(fn):
l.append(os.path.join(d, fn))
except Exception:
pass
for fn in l:
try:
gs.println("GoSublime: removing old binary: `%s'" % fn)
os.remove(fn)
except Exception:
report_x()
except Exception:
report_x()
return m_out
def _send():
while True:
try:
try:
method, arg, cb = gs.mg9_send_q.get()
proc = gs.attr(PROC_ATTR_NAME)
if not proc or proc.poll() is not None:
killSrv()
if gs.attr(INSTALL_ATTR_NAME) != "busy":
maybe_install()
if not gs.checked(DOMAIN, 'launch _recv'):
gsq.launch(DOMAIN, _recv)
while gs.attr(INSTALL_ATTR_NAME) == "busy":
time.sleep(0.100)
proc, _, err = gsshell.proc([_margo_bin(), '-poll', 30, '-tag', TAG], stderr=gs.LOGFILE ,env={
'XDG_CONFIG_HOME': gs.home_path(),
})
gs.set_attr(PROC_ATTR_NAME, proc)
if not proc:
gs.notice(DOMAIN, 'Cannot start MarGo: %s' % err)
try:
cb({}, 'Abort. Cannot start MarGo')
except:
pass
continue
gsq.launch(DOMAIN, lambda: _read_stdout(proc))
req = Request(f=cb, method=method)
gs.set_attr(REQUEST_PREFIX+req.token, req)
header, err = gs.json_encode(req.header())
if err:
_cb_err('Failed to construct ipc header: ' % err)
continue
body, err = gs.json_encode(arg)
if err:
_cb_err(cb, 'Failed to construct ipc body: ' % err)
continue
gs.debug(DOMAIN, 'margo request: %s ' % header)
ln = '%s %s\n' % (header, body)
if gs.PY3K:
proc.stdin.write(bytes(ln, 'UTF-8'))
else:
proc.stdin.write(ln)
except Exception:
killSrv()
gs.println(gs.traceback())
except Exception:
gs.println(gs.traceback())
break
def plugin_loaded():
from gosubl import about
from gosubl import cfg
from gosubl import ui
from gosubl import vu
from gosubl import sh
from gosubl import ev
from gosubl import gs
from gosubl import mg9
from gosubl import hl
from gosubl import nineo
from gosubl import nineo_builtins
if VERSION != about.VERSION:
gs.show_output(
'GoSublime-main', '\n'.join([
'GoSublime has been updated.',
'New version: `%s`, current version: `%s`' %
(VERSION, about.VERSION),
'Please restart Sublime Text to complete the update.',
execErr,
]))
return
if gs.attr('about.version'):
gs.show_output(
'GoSublime-main', '\n'.join([
'GoSublime appears to have been updated.',
'New ANNOUNCE: `%s`, current ANNOUNCE: `%s`' %
(ANN, about.ANN),
'You may need to restart Sublime Text.',
]))
return
mods = [
('cfg', cfg),
('ui', ui),
('vu', vu),
('gs', gs),
('sh', sh),
('mg9', mg9),
('9o', nineo),
('hl', hl),
('9o-builtins', nineo_builtins),
]
gs.set_attr('about.version', VERSION)
gs.set_attr('about.ann', ANN)
m = {
'version': VERSION,
'ann': ANN,
}
for mod_name, mod in mods:
print('GoSublime %s: init mod(%s)' % (about.VERSION, mod_name))
try:
mod.gs_init(m)
except TypeError:
# old versions didn't take an arg
mod.gs_init()
ev.init.post_add = lambda e, f: f()
ev.init()
def cb():
aso = gs.aso()
if about.ANN != aso.get('ann', ''):
aso.set('ann', about.ANN)
gs.save_aso()
vu.open(gs.dist_path('CHANGELOG.md'))
sublime.set_timeout(cb, 0)
pd = os.path.join(gs.packages_dir(), 'User')
sys.path.insert(0, pd)
try:
import MyGoSublime
MyGoSublime.gs_init(m)
except AttributeError:
pass
except ImportError:
pass
finally:
sys.path.remove(pd)
def install(aso_install_vesion, force_install):
"""Install GoSublime margo.
"""
global INSTALL_EXE
if _inst_state() != "":
gs.notify(
DOMAIN,
"Installation aborted. Install command already called for GoSublime %s."
% INSTALL_VERSION,
)
return
INSTALL_EXE = INSTALL_EXE.replace(
"_%s.exe" % about.DEFAULT_GO_VERSION, "_%s.exe" % sh.GO_VERSION
)
about.MARGO_EXE = INSTALL_EXE
is_update = about.VERSION != INSTALL_VERSION
gs.set_attr(_inst_name(), "busy")
init_start = time.time()
if (
not is_update
and not force_install
and _bins_exist()
and aso_install_vesion == INSTALL_VERSION
):
m_out = "no"
else:
gs.notify("GoSublime", "Installing MarGo")
start = time.time()
# WARN (CEV): Hard coded GOPATH
# gopath = gs.dist_path() + os.pathsep + "/Users/Charlie/go"
gopath = gs.dist_path() + os.pathsep + sh.getenv("GOPATH")
cmd = sh.Command(
["go", "build", "-v", "-x", "-o", INSTALL_EXE, "gosubli.me/margo"]
)
cmd.wd = gs.home_dir_path("bin")
cmd.env = {"CGO_ENABLED": "0", "GOBIN": "", "GOPATH": gopath}
ev.debug("%s.build" % DOMAIN, {"cmd": cmd.cmd_lst, "cwd": cmd.wd})
cr = cmd.run()
m_out = "cmd: `%s`\nstdout: `%s`\nstderr: `%s`\nexception: `%s`" % (
cr.cmd_lst,
cr.out.strip(),
cr.err.strip(),
cr.exc,
)
if cr.ok and _bins_exist():
def f():
gs.aso().set("install_version", INSTALL_VERSION)
gs.save_aso()
sublime.set_timeout(f, 0)
else:
err_prefix = "MarGo build failed"
gs.error(DOMAIN, "%s\n%s" % (err_prefix, m_out))
sl = [
(
"GoSublime error",
"\n".join(
(
err_prefix,
"This is possibly a bug or miss-configuration of your environment.",
"For more help, please file an issue with the following build output",
"at: https://github.com/DisposaBoy/GoSublime/issues/new",
"or alternatively, you may send an email to: [email protected]",
"\n",
m_out,
)
),
)
]
sl.extend(sanity_check({}, False))
gs.show_output("GoSublime", "\n".join(sanity_check_sl(sl)))
gs.set_attr(_inst_name(), "done")
if is_update:
gs.show_output(
"GoSublime-source",
"\n".join(
[
"GoSublime source has been updated.",
"New version: `%s`, current version: `%s`"
% (INSTALL_VERSION, about.VERSION),
"Please restart Sublime Text to complete the update.",
]
),
)
else:
e = sh.env()
a = ["GoSublime init %s (%0.3fs)" % (INSTALL_VERSION, time.time() - init_start)]
sl = [("install margo", m_out)]
sl.extend(sanity_check(e))
a.extend(sanity_check_sl(sl))
gs.println(*a)
missing = [k for k in ("GOROOT", "GOPATH") if not e.get(k)]
if missing:
missing_message = "\n".join(
[
"Missing required environment variables: %s" % " ".join(missing),
"See the `Quirks` section of USAGE.md for info",
]
)
cb = lambda ok: gs.show_output(
DOMAIN, missing_message, merge_domain=True, print_output=False
)
gs.error(DOMAIN, missing_message)
gs.focus(gs.dist_path("USAGE.md"), focus_pat="^Quirks", cb=cb)
killSrv()
start = time.time()
# acall('ping', {}, lambda res, err: gs.println('MarGo Ready %0.3fs' % (time.time() - start)))
report_x = lambda: gs.println(
"GoSublime: Exception while cleaning up old binaries", gs.traceback()
)
try:
bin_dirs = [gs.home_path("bin")]
l = []
for d in bin_dirs:
try:
for fn in os.listdir(d):
if fn != INSTALL_EXE and about.MARGO_EXE_PAT.match(fn):
l.append(os.path.join(d, fn))
except Exception:
pass
for fn in l:
try:
gs.println("GoSublime: removing old binary: `%s'" % fn)
os.remove(fn)
except Exception:
report_x()
except Exception:
report_x()
def _recv():
"""Polls the mg9_recv_q queue parsing responses.
"""
# TODO: REFACTOR.
while True:
try:
ln = gs.mg9_recv_q.get()
try:
ln = ln.strip()
if ln:
r, _ = gs.json_decode(ln, {})
token = r.get("token", "")
tag = r.get("tag", "")
k = REQUEST_PREFIX + token
# TODO: try req = gs.del_attr(k)
req = gs.attr(k, {})
gs.del_attr(k)
if req and req.f:
if tag != TAG:
gs.notice(
DOMAIN,
"\n".join(
[
"GoSublime/MarGo appears to be out-of-sync.",
"Maybe restart Sublime Text.",
"Received tag `%s', expected tag `%s'. "
% (tag, TAG),
]
),
)
err = r.get("error", "")
# TODO: Check if debug is enabled (len()).
ev.debug(
DOMAIN,
"margo response: %s"
% {
"method": req.method,
"tag": tag,
"token": token,
"dur": "%0.3fs" % (time.time() - req.tm),
"err": err,
"size": "%0.1fK" % (len(ln) / 1024.0),
},
)
# CEV: req.f is the callback 'cb' set in _send().
#
dat = expand_jdata(r.get("data", {}))
try:
# Add request back to the attr dict.
#
# TODO: Document, which calls keep the request.
keep = req.f(dat, err) is True
if keep:
req.tm = time.time()
gs.set_attr(k, req)
except Exception:
gs.error_traceback(DOMAIN)
else:
ev.debug(DOMAIN, "Ignoring margo: token: %s" % token)
except Exception:
gs.println(gs.traceback())
except Exception:
gs.println(gs.traceback())
break
def _send():
while True:
try:
try:
method, arg, cb = gs.mg9_send_q.get()
proc = gs.attr(PROC_ATTR_NAME)
if not proc or proc.poll() is not None:
killSrv()
if _inst_state() != "busy":
maybe_install()
while _inst_state() == "busy":
time.sleep(0.100)
mg_bin = _margo_bin()
cmd = [
mg_bin,
'-oom', gs.setting('margo_oom', 0),
'-poll', 30,
'-tag', TAG,
]
c = sh.Command(cmd)
c.stderr = gs.LOGFILE
c.env = {
'GOGC': 10,
'XDG_CONFIG_HOME': gs.home_path(),
}
pr = c.proc()
if pr.ok:
proc = pr.p
err = ''
else:
proc = None
err = 'Exception: %s' % pr.exc
if err or not proc or proc.poll() is not None:
killSrv()
_call(cb, {}, 'Abort. Cannot start MarGo: %s' % err)
continue
gs.set_attr(PROC_ATTR_NAME, proc)
gsq.launch(DOMAIN, lambda: _read_stdout(proc))
req = Request(f=cb, method=method)
gs.set_attr(REQUEST_PREFIX+req.token, req)
header, err = gs.json_encode(req.header())
if err:
_cb_err(cb, 'Failed to construct ipc header: %s' % err)
continue
body, err = gs.json_encode(arg)
if err:
_cb_err(cb, 'Failed to construct ipc body: %s' % err)
continue
ev.debug(DOMAIN, 'margo request: %s ' % header)
ln = '%s %s\n' % (header, body)
try:
if gs.PY3K:
proc.stdin.write(bytes(ln, 'UTF-8'))
else:
proc.stdin.write(ln)
except Exception as ex:
_cb_err(cb, 'Cannot talk to MarGo: %s' % err)
killSrv()
gs.println(gs.traceback())
except Exception:
killSrv()
gs.println(gs.traceback())
except Exception:
gs.println(gs.traceback())
break
def plugin_loaded():
from gosubl import about
from gosubl import cfg
from gosubl import ui
from gosubl import vu
from gosubl import sh
from gosubl import ev
from gosubl import gs
from gosubl import mg9
from gosubl import hl
from gosubl import nineo
from gosubl import nineo_builtins
if VERSION != about.VERSION:
gs.show_output('GoSublime-main', '\n'.join([
'GoSublime has been updated.',
'New version: `%s`, current version: `%s`' % (VERSION, about.VERSION),
'Please restart Sublime Text to complete the update.',
execErr,
]))
return
if gs.attr('about.version'):
gs.show_output('GoSublime-main', '\n'.join([
'GoSublime appears to have been updated.',
'New ANNOUNCE: `%s`, current ANNOUNCE: `%s`' % (ANN, about.ANN),
'You may need to restart Sublime Text.',
]))
return
mods = [
('cfg', cfg),
('ui', ui),
('vu', vu),
('gs', gs),
('sh', sh),
('mg9', mg9),
('9o', nineo),
('hl', hl),
('9o-builtins', nineo_builtins),
]
gs.set_attr('about.version', VERSION)
gs.set_attr('about.ann', ANN)
m = {
'version': VERSION,
'ann': ANN,
}
for mod_name, mod in mods:
print('GoSublime %s: init mod(%s)' % (about.VERSION, mod_name))
try:
mod.gs_init(m)
except TypeError:
# old versions didn't take an arg
mod.gs_init()
ev.init.post_add = lambda e, f: f()
ev.init()
def cb():
aso = gs.aso()
if about.ANN != aso.get('ann', ''):
aso.set('ann', about.ANN)
gs.save_aso()
vu.open(gs.dist_path('CHANGELOG.md'))
sublime.set_timeout(cb, 0)
pd = os.path.join(gs.packages_dir(), 'User')
sys.path.insert(0, pd)
try:
import MyGoSublime
MyGoSublime.gs_init(m)
except AttributeError:
pass
except ImportError:
pass
finally:
sys.path.remove(pd)
def install(aso_install_vesion, force_install):
if gs.attr(_inst_name(), '') != "":
gs.notify(DOMAIN, 'Installation aborted. Install command already called for GoSublime %s.' % INSTALL_VERSION)
return
is_update = about.VERSION != INSTALL_VERSION
gs.set_attr(_inst_name(), 'busy')
init_start = time.time()
try:
os.makedirs(gs.home_path('bin'))
except:
pass
if not is_update and not force_install and _bins_exist() and aso_install_vesion == INSTALL_VERSION:
m_out = 'no'
else:
gs.notify('GoSublime', 'Installing MarGo')
start = time.time()
vars = ['%PATH%', '$PATH']
out, err, _ = gsshell.run('echo %s' % os.pathsep.join(vars), shell=True, stderr=subprocess.PIPE, env=gs.env())
if not err:
pl = []
for p in out.strip().split(os.pathsep):
p = os.path.normcase(p)
if p not in vars and p not in pl:
pl.append(p)
if pl:
gs.environ9.update({'PATH': os.pathsep.join(pl)})
go_exe = gs.which('go')
if go_exe:
cmd = [go_exe, 'build', '-o', _margo_bin(INSTALL_EXE)]
cwd = _margo_src()
ev.debug('%s.build' % DOMAIN, {
'cmd': cmd,
'cwd': cwd,
})
m_out, err, _ = _run(cmd, cwd=cwd)
else:
m_out = ''
err = 'Cannot find the `go` exe'
m_out = gs.ustr(m_out)
err = gs.ustr(err)
m_out, m_ok = _so(m_out, err, start, time.time())
if m_ok:
def f():
gs.aso().set('install_version', INSTALL_VERSION)
gs.save_aso()
sublime.set_timeout(f, 0)
if not is_update:
gs.notify('GoSublime', 'Syncing environment variables')
out, err, _ = gsshell.run([about.MARGO_EXE, '-env'], cwd=gs.home_path(), shell=True)
# notify this early so we don't mask any notices below
gs.notify('GoSublime', 'Ready')
if err:
gs.notice(DOMAIN, 'Cannot run get env vars: %s' % (err))
else:
env, err = gs.json_decode(out, {})
if err:
gs.notice(DOMAIN, 'Cannot load env vars: %s\nenv output: %s' % (err, out))
else:
gs.environ9.update(env)
gs.set_attr(_inst_name(), 'done')
if is_update:
gs.show_output('GoSublime-source', '\n'.join([
'GoSublime source has been updated.',
'New version: `%s`, current version: `%s`' % (INSTALL_VERSION, about.VERSION),
'Please restart Sublime Text to complete the update.',
]))
else:
e = gs.env()
a = [
'GoSublime init %s (%0.3fs)' % (INSTALL_VERSION, time.time() - init_start),
]
sl = [('install margo', m_out)]
sl.extend(sanity_check(e))
a.extend(sanity_check_sl(sl))
gs.println(*a)
missing = [k for k in ('GOROOT', 'GOPATH') if not e.get(k)]
if missing:
missing_message = '\n'.join([
'Missing required environment variables: %s' % ' '.join(missing),
'See the `Quirks` section of USAGE.md for info',
])
cb = lambda ok: gs.show_output(DOMAIN, missing_message, merge_domain=True, print_output=False)
gs.error(DOMAIN, missing_message)
gs.focus(gs.dist_path('USAGE.md'), focus_pat='^Quirks', cb=cb)
killSrv()
start = time.time()
# acall('ping', {}, lambda res, err: gs.println('MarGo Ready %0.3fs' % (time.time() - start)))
report_x = lambda: gs.println("GoSublime: Exception while cleaning up old binaries", gs.traceback())
try:
d = gs.home_path('bin')
old_pat = re.compile(r'^gosublime.r\d{2}.\d{2}.\d{2}-\d+.margo.exe$')
for fn in os.listdir(d):
try:
if fn != about.MARGO_EXE and (about.MARGO_EXE_PAT.match(fn) or old_pat.match(fn)):
fn = os.path.join(d, fn)
gs.println("GoSublime: removing old binary: %s" % fn)
os.remove(fn)
except Exception:
report_x()
except Exception:
report_x()
def _send():
while True:
try:
try:
method, arg, cb = gs.mg9_send_q.get()
proc = gs.attr(PROC_ATTR_NAME)
if not proc or proc.poll() is not None:
killSrv()
if gs.attr(_inst_name(), '') != "busy":
maybe_install()
if not gs.checked(DOMAIN, 'launch _recv'):
gsq.launch(DOMAIN, _recv)
while gs.attr(_inst_name(), '') == "busy":
time.sleep(0.100)
mg_bin = _margo_bin()
cmd = [
mg_bin,
'-oom', gs.setting('margo_oom', 0),
'-poll', 30,
'-tag', TAG,
]
if os.path.exists(mg_bin):
proc, _, err = gsshell.proc(cmd, stderr=gs.LOGFILE ,env={
'GOGC': 10,
'XDG_CONFIG_HOME': gs.home_path(),
})
else:
proc = None
err = "Can't find the MarGo binary at `%s`" % mg_bin
if err or not proc or proc.poll() is not None:
killSrv()
gs.notice(DOMAIN, 'Cannot start MarGo:\n%s' % err)
try:
cb({}, 'Abort. Cannot start MarGo')
except:
pass
continue
gs.set_attr(PROC_ATTR_NAME, proc)
gsq.launch(DOMAIN, lambda: _read_stdout(proc))
req = Request(f=cb, method=method)
gs.set_attr(REQUEST_PREFIX+req.token, req)
header, err = gs.json_encode(req.header())
if err:
_cb_err(cb, 'Failed to construct ipc header: %s' % err)
continue
body, err = gs.json_encode(arg)
if err:
_cb_err(cb, 'Failed to construct ipc body: %s' % err)
continue
ev.debug(DOMAIN, 'margo request: %s ' % header)
ln = '%s %s\n' % (header, body)
try:
if gs.PY3K:
proc.stdin.write(bytes(ln, 'UTF-8'))
else:
proc.stdin.write(ln)
except Exception as ex:
_cb_err(cb, 'Cannot talk to MarGo: %s' % err)
killSrv()
gs.println(gs.traceback())
except Exception:
killSrv()
gs.println(gs.traceback())
except Exception:
gs.println(gs.traceback())
break
def install(aso_tokens, force_install):
k = 'mg9.install.%s' % about.VERSION
if gs.attr(k, False):
gs.error(DOMAIN, 'Installation aborted. Install command already called for GoSublime %s.' % about.VERSION)
return
gs.set_attr(k, True)
init_start = time.time()
try:
os.makedirs(gs.home_path('bin'))
except:
pass
if not force_install and _bins_exist() and aso_tokens == _gen_tokens():
m_out = 'no'
else:
gs.notify('GoSublime', 'Installing MarGo')
start = time.time()
m_out, err, _ = _run(['go', 'build', '-o', _margo_bin()], cwd=_margo_src())
m_out, m_ok = _so(m_out, err, start, time.time())
if m_ok:
def f():
gs.aso().set('mg9_install_tokens', _gen_tokens())
gs.save_aso()
sublime.set_timeout(f, 0)
gs.notify('GoSublime', 'Syncing environment variables')
out, err, _ = gsshell.run([about.MARGO_EXE, '-env'], cwd=gs.home_path(), shell=True)
# notify this early so we don't mask any notices below
gs.notify('GoSublime', 'Ready')
_check_changes()
if err:
gs.notice(DOMAIN, 'Cannot run get env vars: %s' % (err))
else:
env, err = gs.json_decode(out, {})
if err:
gs.notice(DOMAIN, 'Cannot load env vars: %s\nenv output: %s' % (err, out))
else:
gs.environ9.update(env)
e = gs.env()
a = [
'GoSublime init (%0.3fs)' % (time.time() - init_start),
'| install margo: %s' % m_out,
]
a.extend(['| %14s: %s' % ln for ln in sanity_check(e)])
gs.println(*a)
missing = [k for k in ('GOROOT', 'GOPATH') if not e.get(k)]
if missing:
gs.notice(DOMAIN, "Missing environment variable(s): %s" % ', '.join(missing))
killSrv()
start = time.time()
# acall('ping', {}, lambda res, err: gs.println('MarGo Ready %0.3fs' % (time.time() - start)))
report_x = lambda: gs.println("GoSublime: Exception while cleaning up old binaries", gs.traceback())
try:
d = gs.home_path('bin')
for fn in os.listdir(d):
try:
if fn != about.MARGO_EXE and fn.startswith(('gosublime', 'gocode', 'margo')):
fn = os.path.join(d, fn)
gs.println("GoSublime: removing old binary: %s" % fn)
os.remove(fn)
except Exception:
report_x()
except Exception:
report_x()
def install(aso_install_vesion, force_install):
global INSTALL_EXE
if gs.attr(_inst_name(), "") != "":
gs.notify(DOMAIN, "Installation aborted. Install command already called for GoSublime %s." % INSTALL_VERSION)
return
INSTALL_EXE = INSTALL_EXE.replace("_%s.exe" % about.DEFAULT_GO_VERSION, "_%s.exe" % sh.GO_VERSION)
about.MARGO_EXE = INSTALL_EXE
is_update = about.VERSION != INSTALL_VERSION
gs.set_attr(_inst_name(), "busy")
init_start = time.time()
err = ""
if not is_update and not force_install and _bins_exist() and aso_install_vesion == INSTALL_VERSION:
m_out = "no"
else:
gs.notify("GoSublime", "Installing MarGo")
start = time.time()
cmd = sh.Command(["go", "build", "-v", "-x", "-o", _margo_bin(INSTALL_EXE)])
cmd.wd = _margo_src()
cmd.env = {"GOBIN": "", "GOPATH": gs.dist_path("something_borrowed")}
ev.debug("%s.build" % DOMAIN, {"cmd": cmd.cmd_lst, "cwd": cmd.wd})
cr = cmd.run()
m_out = "cmd: `%s`\nstdout: `%s`\nstderr: `%s`" % (cr.cmd_lst, cr.out.strip(), cr.err.strip())
if not cr.ok:
m_out = "%s\nexception: `%s`" % (m_out, cr.exc)
err = "MarGo build failure\n%s" % m_out
if not err and _bins_exist():
def f():
gs.aso().set("install_version", INSTALL_VERSION)
gs.save_aso()
sublime.set_timeout(f, 0)
gs.set_attr(_inst_name(), "done")
if err:
gs.error(DOMAIN, err)
else:
# notify this early so we don't mask any notices below
gs.notify("GoSublime", "Ready")
if is_update:
gs.show_output(
"GoSublime-source",
"\n".join(
[
"GoSublime source has been updated.",
"New version: `%s`, current version: `%s`" % (INSTALL_VERSION, about.VERSION),
"Please restart Sublime Text to complete the update.",
]
),
)
else:
e = sh.env()
a = ["GoSublime init %s (%0.3fs)" % (INSTALL_VERSION, time.time() - init_start)]
sl = [("install margo", m_out)]
sl.extend(sanity_check(e))
a.extend(sanity_check_sl(sl))
gs.println(*a)
missing = [k for k in ("GOROOT", "GOPATH") if not e.get(k)]
if missing:
missing_message = "\n".join(
[
"Missing required environment variables: %s" % " ".join(missing),
"See the `Quirks` section of USAGE.md for info",
]
)
cb = lambda ok: gs.show_output(DOMAIN, missing_message, merge_domain=True, print_output=False)
gs.error(DOMAIN, missing_message)
gs.focus(gs.dist_path("USAGE.md"), focus_pat="^Quirks", cb=cb)
killSrv()
start = time.time()
# acall('ping', {}, lambda res, err: gs.println('MarGo Ready %0.3fs' % (time.time() - start)))
report_x = lambda: gs.println("GoSublime: Exception while cleaning up old binaries", gs.traceback())
try:
bin_dirs = [gs.home_path("bin"), os.path.join(sublime.packages_path(), "User", "GoSublime", "9", "bin")]
l = []
for d in bin_dirs:
try:
for fn in os.listdir(d):
if fn != INSTALL_EXE and about.MARGO_EXE_PAT.match(fn):
l.append(os.path.join(d, fn))
except Exception:
pass
for fn in l:
try:
gs.println("GoSublime: removing old binary: `%s'" % fn)
os.remove(fn)
except Exception:
report_x()
except Exception:
report_x()
def install(aso_tokens, force_install):
if gs.attr(INSTALL_ATTR_NAME, '') != "":
gs.notify(DOMAIN, 'Installation aborted. Install command already called for GoSublime %s.' % about.VERSION)
return
gs.set_attr(INSTALL_ATTR_NAME, 'busy')
init_start = time.time()
try:
os.makedirs(gs.home_path('bin'))
except:
pass
if not force_install and _bins_exist() and aso_tokens == _gen_tokens():
m_out = 'no'
else:
gs.notify('GoSublime', 'Installing MarGo')
start = time.time()
m_out, err, _ = _run(['go', 'build', '-o', _margo_bin()], cwd=_margo_src())
m_out = gs.ustr(m_out)
err = gs.ustr(err)
m_out, m_ok = _so(m_out, err, start, time.time())
if m_ok:
def f():
gs.aso().set('mg9_install_tokens', _gen_tokens())
gs.save_aso()
sublime.set_timeout(f, 0)
gs.notify('GoSublime', 'Syncing environment variables')
out, err, _ = gsshell.run([about.MARGO_EXE, '-env'], cwd=gs.home_path(), shell=True)
# notify this early so we don't mask any notices below
gs.notify('GoSublime', 'Ready')
if err:
gs.notice(DOMAIN, 'Cannot run get env vars: %s' % (err))
else:
env, err = gs.json_decode(out, {})
if err:
gs.notice(DOMAIN, 'Cannot load env vars: %s\nenv output: %s' % (err, out))
else:
gs.environ9.update(env)
gs.set_attr(INSTALL_ATTR_NAME, 'done')
e = gs.env()
a = [
'GoSublime init (%0.3fs)' % (time.time() - init_start),
]
sl = [('install margo', m_out)]
sl.extend(sanity_check(e))
a.extend(sanity_check_sl(sl))
gs.println(*a)
missing = [k for k in ('GOROOT', 'GOPATH') if not e.get(k)]
if missing:
gs.notice(DOMAIN, "Missing environment variable(s): %s" % ', '.join(missing))
killSrv()
start = time.time()
# acall('ping', {}, lambda res, err: gs.println('MarGo Ready %0.3fs' % (time.time() - start)))
report_x = lambda: gs.println("GoSublime: Exception while cleaning up old binaries", gs.traceback())
try:
d = gs.home_path('bin')
old_pat = re.compile(r'^gosublime.r\d{2}.\d{2}.\d{2}-\d+.margo.exe$')
for fn in os.listdir(d):
try:
if fn != about.MARGO_EXE and (about.MARGO_EXE_PAT.match(fn) or old_pat.match(fn)):
fn = os.path.join(d, fn)
gs.println("GoSublime: removing old binary: %s" % fn)
os.remove(fn)
except Exception:
report_x()
except Exception:
report_x()
def on(token, cb):
req = Request(f=cb, token=token)
gs.set_attr(REQUEST_PREFIX + req.token, req)
def install(aso_install_vesion, force_install):
if gs.attr(_inst_name(), "") != "":
gs.notify(DOMAIN, "Installation aborted. Install command already called for GoSublime %s." % INSTALL_VERSION)
return
is_update = about.VERSION != INSTALL_VERSION
gs.set_attr(_inst_name(), "busy")
init_start = time.time()
try:
os.makedirs(gs.home_path("bin"))
except:
pass
if not is_update and not force_install and _bins_exist() and aso_install_vesion == INSTALL_VERSION:
m_out = "no"
else:
gs.notify("GoSublime", "Installing MarGo")
start = time.time()
vars = ["%PATH%", "$PATH"]
out, err, _ = gsshell.run("echo %s" % os.pathsep.join(vars), shell=True, stderr=subprocess.PIPE, env=gs.env())
if not err:
pl = []
for p in out.strip().split(os.pathsep):
p = os.path.normcase(p)
if p not in vars and p not in pl:
pl.append(p)
if pl:
gs.environ9.update({"PATH": os.pathsep.join(pl)})
go_exe = gs.which("go")
if go_exe:
cmd = [go_exe, "build", "-o", _margo_bin(INSTALL_EXE)]
cwd = _margo_src()
gs.debug("%s.build" % DOMAIN, {"cmd": cmd, "cwd": cwd})
m_out, err, _ = _run(cmd, cwd=cwd)
else:
m_out = ""
err = "Cannot find the `go` exe"
m_out = gs.ustr(m_out)
err = gs.ustr(err)
m_out, m_ok = _so(m_out, err, start, time.time())
if m_ok:
def f():
gs.aso().set("install_version", INSTALL_VERSION)
gs.save_aso()
sublime.set_timeout(f, 0)
if not is_update:
gs.notify("GoSublime", "Syncing environment variables")
out, err, _ = gsshell.run([about.MARGO_EXE, "-env"], cwd=gs.home_path(), shell=True)
# notify this early so we don't mask any notices below
gs.notify("GoSublime", "Ready")
if err:
gs.notice(DOMAIN, "Cannot run get env vars: %s" % (err))
else:
env, err = gs.json_decode(out, {})
if err:
gs.notice(DOMAIN, "Cannot load env vars: %s\nenv output: %s" % (err, out))
else:
gs.environ9.update(env)
gs.set_attr(_inst_name(), "done")
if is_update:
gs.show_output(
"GoSublime-source",
"\n".join(
[
"GoSublime source has been updated.",
"New version: `%s`, current version: `%s`" % (INSTALL_VERSION, about.VERSION),
"Please restart Sublime Text to complete the update.",
]
),
)
else:
e = gs.env()
a = ["GoSublime init %s (%0.3fs)" % (INSTALL_VERSION, time.time() - init_start)]
sl = [("install margo", m_out)]
sl.extend(sanity_check(e))
a.extend(sanity_check_sl(sl))
gs.println(*a)
missing = [k for k in ("GOROOT", "GOPATH") if not e.get(k)]
if missing:
missing_message = "\n".join(
[
"Missing required environment variables: %s" % " ".join(missing),
"See the `Quirks` section of USAGE.md for info",
]
)
cb = lambda ok: gs.show_output(DOMAIN, missing_message, merge_domain=True, print_output=False)
gs.error(DOMAIN, missing_message)
gs.focus(gs.dist_path("USAGE.md"), focus_pat="^Quirks", cb=cb)
killSrv()
start = time.time()
# acall('ping', {}, lambda res, err: gs.println('MarGo Ready %0.3fs' % (time.time() - start)))
report_x = lambda: gs.println("GoSublime: Exception while cleaning up old binaries", gs.traceback())
try:
d = gs.home_path("bin")
old_pat = re.compile(r"^gosublime.r\d{2}.\d{2}.\d{2}-\d+.margo.exe$")
for fn in os.listdir(d):
try:
if fn != about.MARGO_EXE and (about.MARGO_EXE_PAT.match(fn) or old_pat.match(fn)):
fn = os.path.join(d, fn)
gs.println("GoSublime: removing old binary: %s" % fn)
os.remove(fn)
except Exception:
report_x()
except Exception:
report_x()
def install(aso_install_vesion, force_install, _reinstall=False):
global INSTALL_EXE
if not _reinstall and _inst_state() != "":
gs.notify(DOMAIN, 'Installation aborted. Install command already called for GoSublime %s.' % INSTALL_VERSION)
return ''
INSTALL_EXE = INSTALL_EXE.replace('_%s.exe' % about.DEFAULT_GO_VERSION, '_%s.exe' % sh.GO_VERSION)
about.MARGO_EXE = INSTALL_EXE
is_update = about.VERSION != INSTALL_VERSION
gs.set_attr(_inst_name(), 'busy')
init_start = time.time()
if not _reinstall and not is_update and not force_install and _bins_exist() and aso_install_vesion == INSTALL_VERSION:
m_out = 'no'
else:
gs.notify('GoSublime', 'Installing MarGo')
start = time.time()
cmd = sh.Command([
'go', 'build',
'-tags', 'gosublime' if ext_main_file() else '',
'-v',
'-o', INSTALL_EXE,
'disposa.blue/cmd/margo',
])
cmd.wd = gs.home_dir_path('bin')
cmd.env = {
'CGO_ENABLED': '0',
'GOBIN': '',
'GOPATH': install_gopath(),
}
ev.debug('%s.build' % DOMAIN, {
'cmd': cmd.cmd_lst,
'cwd': cmd.wd,
})
cr = cmd.run()
m_out = 'cmd: `%s`\nstdout: `\n%s\n`\nstderr: `\n%s\n`\nexception: `%s`' % (
cr.cmd_lst,
cr.out.strip(),
cr.err.strip(),
cr.exc,
)
if cr.ok and _bins_exist():
def f():
gs.aso().set('install_version', INSTALL_VERSION)
gs.save_aso()
sublime.set_timeout(f, 0)
else:
err_prefix = 'MarGo build failed'
gs.error(DOMAIN, '%s\n%s' % (err_prefix, m_out))
sl = [
('GoSublime error', '\n'.join((
err_prefix,
'This is possibly a bug or miss-configuration of your environment.',
'For more help, please file an issue with the following build output',
'at: https://github.com/DisposaBoy/GoSublime/issues/new',
'or alternatively, you may send an email to: [email protected]',
'\n',
m_out,
)))
]
sl.extend(sanity_check({}, False))
gs.show_output('GoSublime', '\n'.join(sanity_check_sl(sl)))
gs.set_attr(_inst_name(), 'done')
if is_update:
gs.show_output('GoSublime-source', '\n'.join([
'GoSublime source has been updated.',
'New version: `%s`, current version: `%s`' % (INSTALL_VERSION, about.VERSION),
'Please restart Sublime Text to complete the update.',
]))
else:
e = sh.env()
a = [
'GoSublime init %s (%0.3fs)' % (INSTALL_VERSION, time.time() - init_start),
]
sl = [('install margo', m_out)]
sl.extend(sanity_check(e))
a.extend(sanity_check_sl(sl))
gs.println(*a)
missing = [k for k in ('GOROOT', 'GOPATH') if not e.get(k)]
if missing:
missing_message = '\n'.join([
'Missing required environment variables: %s' % ' '.join(missing),
'See the `Quirks` section of USAGE.md for info',
])
cb = lambda ok: gs.show_output(DOMAIN, missing_message, merge_domain=True, print_output=False)
gs.error(DOMAIN, missing_message)
gs.focus(gs.dist_path('USAGE.md'), focus_pat='^Quirks', cb=cb)
killSrv()
start = time.time()
# acall('ping', {}, lambda res, err: gs.println('MarGo Ready %0.3fs' % (time.time() - start)))
report_x = lambda: gs.println("GoSublime: Exception while cleaning up old binaries", gs.traceback())
try:
bin_dirs = [
gs.home_path('bin'),
]
l = []
for d in bin_dirs:
try:
for fn in os.listdir(d):
if fn != INSTALL_EXE and about.MARGO_EXE_PAT.match(fn):
l.append(os.path.join(d, fn))
except Exception:
pass
for fn in l:
try:
gs.println("GoSublime: removing old binary: `%s'" % fn)
os.remove(fn)
except Exception:
report_x()
except Exception:
report_x()
return m_out
def install(aso_install_vesion, force_install):
global INSTALL_EXE
if gs.attr(_inst_name(), '') != "":
gs.notify(DOMAIN, 'Installation aborted. Install command already called for GoSublime %s.' % INSTALL_VERSION)
return
_init_go_version()
INSTALL_EXE = INSTALL_EXE.replace('_%s.exe' % about.DEFAULT_GO_VERSION, '_%s.exe' % GO_VERSION)
about.MARGO_EXE = INSTALL_EXE
is_update = about.VERSION != INSTALL_VERSION
gs.set_attr(_inst_name(), 'busy')
init_start = time.time()
if not is_update and not force_install and _bins_exist() and aso_install_vesion == INSTALL_VERSION:
m_out = 'no'
else:
gs.notify('GoSublime', 'Installing MarGo')
start = time.time()
go_bin = _go_bin()
if go_bin:
cmd = [go_bin, 'build', '-o', _margo_bin(INSTALL_EXE)]
cwd = _margo_src()
ev.debug('%s.build' % DOMAIN, {
'cmd': cmd,
'cwd': cwd,
})
m_out, err, _ = _run(cmd, cwd=cwd)
else:
m_out = ''
err = 'Cannot find the `go` exe'
m_out = gs.ustr(m_out)
err = gs.ustr(err)
m_out, m_ok = _so(m_out, err, start, time.time())
if m_ok:
def f():
gs.aso().set('install_version', INSTALL_VERSION)
gs.save_aso()
sublime.set_timeout(f, 0)
if not is_update:
gs.notify('GoSublime', 'Syncing environment variables')
out, err, _ = gsshell.run([INSTALL_EXE, '-env'], cwd=gs.home_dir_path(), shell=True)
# notify this early so we don't mask any notices below
gs.notify('GoSublime', 'Ready')
if err:
gs.notice(DOMAIN, 'Cannot run get env vars: %s' % (err))
else:
env, err = gs.json_decode(out, {})
if err:
gs.notice(DOMAIN, 'Cannot load env vars: %s\nenv output: %s' % (err, out))
else:
gs.environ9.update(env)
gs.set_attr(_inst_name(), 'done')
if is_update:
gs.show_output('GoSublime-source', '\n'.join([
'GoSublime source has been updated.',
'New version: `%s`, current version: `%s`' % (INSTALL_VERSION, about.VERSION),
'Please restart Sublime Text to complete the update.',
]))
else:
e = gs.env()
a = [
'GoSublime init %s (%0.3fs)' % (INSTALL_VERSION, time.time() - init_start),
]
sl = [('install margo', m_out)]
sl.extend(sanity_check(e))
a.extend(sanity_check_sl(sl))
gs.println(*a)
missing = [k for k in ('GOROOT', 'GOPATH') if not e.get(k)]
if missing:
missing_message = '\n'.join([
'Missing required environment variables: %s' % ' '.join(missing),
'See the `Quirks` section of USAGE.md for info',
])
cb = lambda ok: gs.show_output(DOMAIN, missing_message, merge_domain=True, print_output=False)
gs.error(DOMAIN, missing_message)
gs.focus(gs.dist_path('USAGE.md'), focus_pat='^Quirks', cb=cb)
killSrv()
start = time.time()
# acall('ping', {}, lambda res, err: gs.println('MarGo Ready %0.3fs' % (time.time() - start)))
report_x = lambda: gs.println("GoSublime: Exception while cleaning up old binaries", gs.traceback())
try:
bin_dirs = [
gs.home_path('bin'),
os.path.join(sublime.packages_path(), 'User', 'GoSublime', '9', 'bin'),
]
l = []
for d in bin_dirs:
try:
for fn in os.listdir(d):
if fn != INSTALL_EXE and about.MARGO_EXE_PAT.match(fn):
l.append(os.path.join(d, fn))
except Exception:
pass
for fn in l:
try:
gs.println("GoSublime: removing old binary: `%s'" % fn)
os.remove(fn)
except Exception:
report_x()
except Exception:
report_x()
def on(token, cb): req = Request(f=cb, token=token) gs.set_attr(REQUEST_PREFIX+req.token, req)
def _send():
while True:
try:
try:
method, arg, cb = gs.mg9_send_q.get()
proc = gs.attr(PROC_ATTR_NAME)
if not proc or proc.poll() is not None:
killSrv()
if gs.attr(INSTALL_ATTR_NAME) != "busy":
maybe_install()
if not gs.checked(DOMAIN, 'launch _recv'):
gsq.launch(DOMAIN, _recv)
while gs.attr(INSTALL_ATTR_NAME) == "busy":
time.sleep(0.100)
proc, _, err = gsshell.proc(
[_margo_bin(), '-poll', 30, '-tag', TAG],
stderr=gs.LOGFILE,
env={
'XDG_CONFIG_HOME': gs.home_path(),
})
gs.set_attr(PROC_ATTR_NAME, proc)
if not proc:
gs.notice(DOMAIN, 'Cannot start MarGo: %s' % err)
try:
cb({}, 'Abort. Cannot start MarGo')
except:
pass
continue
gsq.launch(DOMAIN, lambda: _read_stdout(proc))
req = Request(f=cb, method=method)
gs.set_attr(REQUEST_PREFIX + req.token, req)
header, err = gs.json_encode(req.header())
if err:
_cb_err('Failed to construct ipc header: ' % err)
continue
body, err = gs.json_encode(arg)
if err:
_cb_err(cb, 'Failed to construct ipc body: ' % err)
continue
gs.debug(DOMAIN, 'margo request: %s ' % header)
ln = '%s %s\n' % (header, body)
if gs.PY3K:
proc.stdin.write(bytes(ln, 'UTF-8'))
else:
proc.stdin.write(ln)
except Exception:
killSrv()
gs.println(gs.traceback())
except Exception:
gs.println(gs.traceback())
break
