def sanity_check(env={}, error_log=False):
if not env:
env = gs.env()
ns = "(not set)"
sl = [
("install state", gs.attr(_inst_name(), "")),
("sublime.version", sublime.version()),
("sublime.channel", sublime.channel()),
("about.ann", gs.attr("about.ann", "")),
("about.version", gs.attr("about.version", "")),
("version", about.VERSION),
("platform", about.PLATFORM),
("~bin", "%s" % gs.home_path("bin")),
("margo.exe", "%s (%s)" % _tp(_margo_bin())),
("go.exe", "%s (%s)" % _tp(gs.which("go") or "go")),
("GOROOT", "%s" % env.get("GOROOT", ns)),
("GOPATH", "%s" % env.get("GOPATH", ns)),
("GOBIN", "%s (should usually be `%s`)" % (env.get("GOBIN", ns), ns)),
]
if error_log:
try:
with open(gs.home_path("log.txt"), "r") as f:
s = f.read().strip()
sl.append(("error log", s))
except Exception:
pass
return sl
def sanity_check(env={}, error_log=False):
if not env:
env = gs.env()
ns = '(not set)'
sl = [
('install state', gs.attr(_inst_name(), '')),
('sublime.version', sublime.version()),
('sublime.channel', sublime.channel()),
('about.ann', gs.attr('about.ann', '')),
('about.version', gs.attr('about.version', '')),
('version', about.VERSION),
('platform', about.PLATFORM),
('~bin', '%s' % gs.home_path('bin')),
('margo.exe', '%s (%s)' % _tp(_margo_bin())),
('go.exe', '%s (%s)' % _tp(gs.which('go') or 'go')),
('GOROOT', '%s' % env.get('GOROOT', ns)),
('GOPATH', '%s' % env.get('GOPATH', ns)),
('GOBIN', '%s (should usually be `%s`)' % (env.get('GOBIN', ns), ns)),
]
if error_log:
try:
with open(gs.home_path('log.txt'), 'r') as f:
s = f.read().strip()
sl.append(('error log', s))
except Exception:
pass
return sl
def sanity_check(env={}, error_log=False):
if not env:
env = sh.env()
ns = '(not set)'
sl = [
('install state', _inst_state()),
('sublime.version', sublime.version()),
('sublime.channel', sublime.channel()),
('about.ann', gs.attr('about.ann', '')),
('about.version', gs.attr('about.version', '')),
('version', about.VERSION),
('platform', about.PLATFORM),
('~bin', '%s' % sh.bin_dir()),
('go.exe', '%s (%s)' % _tp(sh.which('go') or 'go')),
('margo.exe', '%s (%s)' % _tp(sh.which('margo') or 'margo')),
('go.version', sh.GO_VERSION),
('GOROOT', '%s' % env.get('GOROOT', ns)),
('GOPATH', '%s' % env.get('GOPATH', ns)),
('GOBIN', env.get('GOBIN', ns)),
('set.shell', str(gs.lst(gs.setting('shell')))),
('env.shell', env.get('SHELL', '')),
('shell.cmd', str(sh.cmd('${CMD}'))),
]
if error_log:
try:
with open(gs.home_path('log.txt'), 'r') as f:
s = f.read().strip()
sl.append(('error log', s))
except Exception:
pass
return sl
def sanity_check(env={}, error_log=False):
if not env:
env = sh.env()
ns = '(not set)'
sl = [
('install state', _inst_state()),
('sublime.version', sublime.version()),
('sublime.channel', sublime.channel()),
('about.ann', gs.attr('about.ann', '')),
('about.version', gs.attr('about.version', '')),
('version', about.VERSION),
('platform', about.PLATFORM),
('~bin', '%s' % gs.home_dir_path('bin')),
('margo.exe', '%s (%s)' % _tp(_margo_bin())),
('go.exe', '%s (%s)' % _tp(sh.which('go') or 'go')),
('go.version', sh.GO_VERSION),
('GOROOT', '%s' % env.get('GOROOT', ns)),
('GOPATH', '%s' % env.get('GOPATH', ns)),
('GOBIN', '%s' % env.get('GOBIN', ns)),
('set.shell', str(gs.lst(gs.setting('shell')))),
('env.shell', env.get('SHELL', '')),
('shell.cmd', str(sh.cmd('${CMD}'))),
]
if error_log:
try:
with open(gs.home_path('log.txt'), 'r') as f:
s = f.read().strip()
sl.append(('error log', s))
except Exception:
pass
return sl
def _complete_opts(fn, src, pos):
home = gs.home_path()
builtins = gs.setting("autocomplete_builtins") is True or gs.setting("complete_builtins") is True
return {
"Dir": gs.basedir_or_cwd(fn),
"Builtins": builtins,
"Fn": fn or "",
"Src": src or "",
"Pos": pos or 0,
"Home": home,
"Env": gs.env({"XDG_CONFIG_HOME": home}),
}
def _complete_opts(fn, src, pos):
home = gs.home_path()
builtins = (gs.setting('autocomplete_builtins') is True or gs.setting('complete_builtins') is True)
return {
'Dir': gs.basedir_or_cwd(fn),
'Builtins': builtins,
'Fn': fn or '',
'Src': src or '',
'Pos': pos or 0,
'Home': home,
'Env': gs.env({
'XDG_CONFIG_HOME': home,
}),
}
def sanity_check(env={}):
if not env:
env = gs.env()
ns = '(not set)'
return [
('version', about.VERSION),
('~bin', '%s' % gs.home_path('bin')),
('MarGo', '%s (%s)' % _tp(_margo_bin())),
('GOROOT', '%s' % env.get('GOROOT', ns)),
('GOPATH', '%s' % env.get('GOPATH', ns)),
('GOBIN', '%s (should usually be `%s`)' % (env.get('GOBIN', ns), ns)),
]
def sanity_check(env={}):
if not env:
env = gs.env()
ns = '(not set)'
return [
('version', about.VERSION),
('platform', about.PLATFORM),
('~bin', '%s' % gs.home_path('bin')),
('MarGo', '%s (%s)' % _tp(_margo_bin())),
('GOROOT', '%s' % env.get('GOROOT', ns)),
('GOPATH', '%s' % env.get('GOPATH', ns)),
('GOBIN', '%s (should usually be `%s`)' % (env.get('GOBIN', ns), ns)),
]
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 complete(fn, src, pos):
home = gs.home_path()
builtins = (gs.setting('autocomplete_builtins') is True or gs.setting('complete_builtins') is True)
res, err = bcall('gocode_complete', {
'Dir': gs.basedir_or_cwd(fn),
'Builtins': builtins,
'Fn': fn or '',
'Src': src or '',
'Pos': pos or 0,
'Home': home,
'Env': gs.env({
'XDG_CONFIG_HOME': home,
}),
})
res = gs.dval(res.get('completions'), [])
return res, err
def complete(fn, src, pos):
home = gs.home_path()
builtins = (gs.setting('autocomplete_builtins') is True or gs.setting('complete_builtins') is True)
res, err = bcall('gocode_complete', {
'Dir': gs.basedir_or_cwd(fn),
'Builtins': builtins,
'Fn': fn or '',
'Src': src or '',
'Pos': pos or 0,
'Home': home,
'Env': gs.env({
'XDG_CONFIG_HOME': home,
}),
})
res = gs.dval(res.get('completions'), [])
return res, err
def _margo_bin():
return gs.home_path('bin', about.MARGO_EXE)
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 _sb(s):
bdir = gs.home_path("bin")
if s.startswith(bdir):
s = "~bin%s" % (s[len(bdir) :])
return s
def _margo_bin(exe=""):
return gs.home_path("bin", exe or INSTALL_EXE)
def _margo_bin(exe=''):
return gs.home_path('bin', exe or about.MARGO_EXE)
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 _sb(s):
bdir = gs.home_path('bin')
if s.startswith(bdir):
s = '~bin%s' % (s[len(bdir):])
return s
def run(self, fn): self.window.open_file(gs.home_path(fn))
def _margo_bin():
return gs.home_path('bin', about.MARGO_EXE)
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 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 _margo_bin(exe=""):
return gs.home_path("bin", exe or about.MARGO_EXE)
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 _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 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 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 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 _margo_bin(exe=''):
return gs.home_path('bin', exe or INSTALL_EXE)
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 _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 _margo_bin(exe=""):
"""Returns the path of the margo executable.
"""
return gs.home_path("bin", exe or INSTALL_EXE)
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 _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):
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 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 _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 _margo_bin(exe=''):
return gs.home_path('bin', exe or INSTALL_EXE)
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