def sanity_check(env={}, error_log=False):
if not env:
env = gs.env()
ns = '(not set)'
sl = [
('install state', gs.attr(INSTALL_ATTR_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', '%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)),
]
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 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 (should usually be `%s`)" % (env.get("GOBIN", ns), 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 = 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' % 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 (should usually be `%s`)' % (env.get('GOBIN', ns), 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 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 jump_to_imports(self):
view = gs.active_valid_go_view()
if not view:
return
last_import = gs.attr('last_import_path.%s' % gs.view_fn(view), '')
r = None
if last_import:
offset = len(last_import) + 2
last_import = re.escape(last_import)
pat = '(?s)import.*?(?:"%s"|`%s`)' % (last_import, last_import)
r = view.find(pat, 0)
if not r:
offset = 1
pat = '(?s)import.*?["`]'
r = view.find(pat, 0)
if not r:
gs.notice(DOMAIN, "cannot find import declarations")
return
pt = r.end() - offset
row, col = view.rowcol(pt)
loc = Loc(view.file_name(), row, col)
self.jump_to((view, loc))
def jump_to_imports(self):
view = gs.active_valid_go_view()
if not view:
return
last_import = gs.attr('last_import_path.%s' % gs.view_fn(view), '')
r = None
if last_import:
offset = len(last_import) + 2
last_import = re.escape(last_import)
pat = '(?s)import.*?(?:"%s"|`%s`)' % (last_import, last_import)
r = view.find(pat, 0)
if not r:
offset = 1
pat = '(?s)import.*?["`]'
r = view.find(pat, 0)
if not r:
gs.notice(DOMAIN, "cannot find import declarations")
return
pt = r.end() - offset
row, col = view.rowcol(pt)
loc = Loc(view.file_name(), row, col)
self.jump_to((view, loc))
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 _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 bcall(method, arg):
if gs.attr(_inst_name(), '') != "done":
return {}, 'Blocking call(%s) aborted: Install is not done' % method
q = gs.queue.Queue()
acall(method, arg, lambda r,e: q.put((r, e)))
try:
res, err = q.get(True, 1)
return res, err
except:
return {}, 'Blocking Call(%s): Timeout' % method
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 _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 _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', '')
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 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 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_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_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 _inst_state():
"""Returns install state from gs.attr.
"""
# TODO: Improve the handling of install state.
return gs.attr(_inst_name(), "")
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 _inst_state():
return gs.attr(_inst_name(), '')
def _inst_state(): return gs.attr(_inst_name(), '')
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 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 _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_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):
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_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 _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 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():
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 _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 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 _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
