def get_workspace_window():
workspace_window = None
for w in sublime.windows():
for f in w.folders():
if utils.unfuck_path(f) == utils.unfuck_path(G.PROJECT_PATH):
workspace_window = w
break
return workspace_window
def get_workspace_window():
workspace_window = None
for w in sublime.windows():
for f in w.folders():
if utils.unfuck_path(f) == utils.unfuck_path(
G.PROJECT_PATH):
workspace_window = w
break
return workspace_window
def __init__(self, owner, workspace, auth, upload=None):
self.username = auth.get('username')
self.secret = auth.get('secret')
self.api_key = auth.get('api_key')
# BaseHandler calls reload_settings()
super(FlooHandler, self).__init__()
self.owner = owner
self.workspace = workspace
self.upload_path = upload and utils.unfuck_path(upload)
self.reset()
def __init__(self, owner, workspace, auth, upload=None):
self.username = auth.get('username')
self.secret = auth.get('secret')
self.api_key = auth.get('api_key')
# BaseHandler calls reload_settings()
super(FlooHandler, self).__init__()
self.owner = owner
self.workspace = workspace
self.upload_path = upload and utils.unfuck_path(upload)
self.reset()
def share_dir(self, context, dir_to_share, api_args):
utils.reload_settings()
if not utils.can_auth():
success = yield self.create_or_link_account, context, G.DEFAULT_HOST, False
if not success:
return
utils.reload_settings()
dir_to_share = os.path.expanduser(dir_to_share)
dir_to_share = os.path.realpath(dir_to_share)
dir_to_share = utils.unfuck_path(dir_to_share)
if os.path.isfile(dir_to_share):
dir_to_share = os.path.dirname(dir_to_share)
workspace_name = os.path.basename(dir_to_share)
msg.debug('', workspace_name, dir_to_share)
if os.path.isfile(dir_to_share):
dir_to_share = os.path.dirname(dir_to_share)
try:
utils.mkdir(dir_to_share)
except Exception:
msg.error("The directory", dir_to_share,
"doesn't exist and I can't create it.")
return
info = utils.read_floo_file(dir_to_share)
def prejoin(workspace_url):
try:
return self.prejoin_workspace(workspace_url, dir_to_share,
api_args)
except ValueError:
pass
workspace_url = info.get('url')
if workspace_url:
parsed_url = prejoin(workspace_url)
if parsed_url:
self.remote_connect(context, parsed_url['host'],
parsed_url['owner'],
parsed_url['workspace'], dir_to_share)
return
parsed_url = utils.get_workspace_by_path(dir_to_share, prejoin)
if parsed_url:
self.remote_connect(context, parsed_url['host'],
parsed_url['owner'], parsed_url['workspace'],
dir_to_share)
return
host = yield self._get_host, context
if not host:
return
try:
r = api.get_orgs_can_admin(host)
except IOError as e:
editor.error_message('Error getting org list: %s' % str_e(e))
return
choices = [G.AUTH[host]['username']]
if r.code >= 400:
editor.error_message('Error getting org list: %s' % r.body)
elif r.body:
choices += [org['name'] for org in r.body]
if len(choices) == 1:
owner = choices[0]
else:
little = ['Create workspace owned by %s' % s for s in choices]
(
owner, index
) = yield self.user_select, context, 'Create workspace owned by', choices, little
if not owner:
return
self.create_workspace(context, host, owner, workspace_name, api_args,
dir_to_share)
def share_dir(self, context, dir_to_share, api_args):
utils.reload_settings()
if not utils.can_auth():
success = yield self.create_or_link_account, context, G.DEFAULT_HOST, False
if not success:
return
utils.reload_settings()
dir_to_share = os.path.expanduser(dir_to_share)
dir_to_share = os.path.realpath(dir_to_share)
dir_to_share = utils.unfuck_path(dir_to_share)
if os.path.isfile(dir_to_share):
dir_to_share = os.path.dirname(dir_to_share)
workspace_name = os.path.basename(dir_to_share)
msg.debug('', workspace_name, dir_to_share)
if os.path.isfile(dir_to_share):
dir_to_share = os.path.dirname(dir_to_share)
try:
utils.mkdir(dir_to_share)
except Exception:
msg.error("The directory", dir_to_share, "doesn't exist and I can't create it.")
return
info = utils.read_floo_file(dir_to_share)
def prejoin(workspace_url):
try:
return self.prejoin_workspace(workspace_url, dir_to_share, api_args)
except ValueError:
pass
workspace_url = info.get('url')
if workspace_url:
parsed_url = prejoin(workspace_url)
if parsed_url:
self.remote_connect(context, parsed_url['host'], parsed_url['owner'], parsed_url['workspace'], dir_to_share)
return
parsed_url = utils.get_workspace_by_path(dir_to_share, prejoin)
if parsed_url:
self.remote_connect(context, parsed_url['host'], parsed_url['owner'], parsed_url['workspace'], dir_to_share)
return
host = yield self._get_host, context
if not host:
return
try:
r = api.get_orgs_can_admin(host)
except IOError as e:
editor.error_message('Error getting org list: %s' % str_e(e))
return
choices = [G.AUTH[host]['username']]
if r.code >= 400:
editor.error_message('Error getting org list: %s' % r.body)
elif r.body:
choices += [org['name'] for org in r.body]
if len(choices) == 1:
owner = choices[0]
else:
little = ['Create workspace owned by %s' % s for s in choices]
(owner, index) = yield self.user_select, context, 'Create workspace owned by', choices, little
if not owner:
return
self.create_workspace(context, host, owner, workspace_name, api_args, dir_to_share)
def on_input(self, dir_to_share):
file_to_share = None
dir_to_share = os.path.expanduser(dir_to_share)
dir_to_share = os.path.realpath(utils.unfuck_path(dir_to_share))
workspace_name = os.path.basename(dir_to_share)
workspace_url = None
print(G.COLAB_DIR, G.USERNAME, workspace_name)
def find_workspace(workspace_url):
try:
api.get_workspace_by_url(workspace_url)
except HTTPError:
try:
result = utils.parse_url(workspace_url)
d = utils.get_persistent_data()
del d['workspaces'][result['owner']][result['name']]
utils.update_persistent_data(d)
except Exception as e:
msg.debug(unicode(e))
return False
on_room_info_waterfall.add(on_room_info_msg)
on_room_info_waterfall.add(ignore.create_flooignore, dir_to_share)
on_room_info_waterfall.add(Listener.create_buf, dir_to_share)
return True
if os.path.isfile(dir_to_share):
file_to_share = dir_to_share
dir_to_share = os.path.dirname(dir_to_share)
else:
try:
utils.mkdir(dir_to_share)
except Exception:
return sublime.error_message('The directory %s doesn\'t exist and I can\'t make it.' % dir_to_share)
floo_file = os.path.join(dir_to_share, '.floo')
info = {}
try:
floo_info = open(floo_file, 'rb').read().decode('utf-8')
info = json.loads(floo_info)
except (IOError, OSError):
pass
except Exception:
print('Couldn\'t read the floo_info file: %s' % floo_file)
workspace_url = info.get('url')
try:
result = utils.parse_url(workspace_url)
except Exception:
workspace_url = None
if workspace_url and find_workspace(workspace_url):
add_workspace_to_persistent_json(result['owner'], result['workspace'], workspace_url, dir_to_share)
return self.window.run_command('floobits_join_workspace', {
'workspace_url': workspace_url,
'agent_conn_kwargs': {'get_bufs': False}})
for owner, workspaces in utils.get_persistent_data()['workspaces'].items():
for name, workspace in workspaces.items():
if workspace['path'] == dir_to_share:
workspace_url = workspace['url']
if find_workspace(workspace_url):
return self.window.run_command('floobits_join_workspace', {
'workspace_url': workspace_url,
'agent_conn_kwargs': {'get_bufs': False}})
# make & join workspace
on_room_info_waterfall.add(ignore.create_flooignore, dir_to_share)
on_room_info_waterfall.add(Listener.create_buf, file_to_share or dir_to_share)
def on_done(owner):
self.window.run_command('floobits_create_workspace', {
'workspace_name': workspace_name,
'dir_to_share': dir_to_share,
'api_args': self.api_args,
'owner': owner[0],
})
orgs = api.get_orgs_can_admin()
orgs = json.loads(orgs.read().decode('utf-8'))
if len(orgs) == 0:
return on_done([G.USERNAME])
orgs = [[org['name'], 'Create workspace under %s' % org['name']] for org in orgs]
orgs.insert(0, [G.USERNAME, 'Create workspace under %s' % G.USERNAME])
self.window.show_quick_panel(orgs, lambda index: index < 0 or on_done(orgs[index]))
def floobits_share_dir(dir_to_share, perms):
utils.reload_settings()
workspace_name = os.path.basename(dir_to_share)
G.PROJECT_PATH = os.path.realpath(dir_to_share)
msg.debug('%s %s %s' % (G.USERNAME, workspace_name, G.PROJECT_PATH))
file_to_share = None
dir_to_share = os.path.expanduser(dir_to_share)
dir_to_share = utils.unfuck_path(dir_to_share)
dir_to_share = os.path.abspath(dir_to_share)
dir_to_share = os.path.realpath(dir_to_share)
workspace_name = os.path.basename(dir_to_share)
if os.path.isfile(dir_to_share):
file_to_share = dir_to_share
dir_to_share = os.path.dirname(dir_to_share)
try:
utils.mkdir(dir_to_share)
except Exception:
return msg.error("The directory %s doesn't exist and I can't create it." % dir_to_share)
if not os.path.isdir(dir_to_share):
return msg.error('The directory %s doesn\'t appear to exist' % dir_to_share)
floo_file = os.path.join(dir_to_share, '.floo')
# look for the .floo file for hints about previous behavior
info = {}
try:
floo_info = open(floo_file, 'rb').read().decode('utf-8')
info = json.loads(floo_info)
except (IOError, OSError):
pass
except Exception:
msg.warn('couldn\'t read the floo_info file: %s' % floo_file)
workspace_url = info.get('url')
if workspace_url:
parsed_url = api.prejoin_workspace(workspace_url, dir_to_share, {'perms': perms})
if parsed_url:
return floobits_join_workspace(workspace_url, dir_to_share, upload_path=file_to_share or dir_to_share)
filter_func = lambda workspace_url: api.prejoin_workspace(workspace_url, dir_to_share, {'perms': perms})
parsed_url = utils.get_workspace_by_path(dir_to_share, filter_func)
if parsed_url:
return floobits_join_workspace(workspace_url, dir_to_share, upload_path=file_to_share or dir_to_share)
try:
r = api.get_orgs_can_admin()
except IOError as e:
return editor.error_message('Error getting org list: %s' % str(e))
if r.code >= 400 or len(r.body) == 0:
workspace_name = vim_input('Workspace name:', workspace_name, "file")
return create_workspace(workspace_name, dir_to_share, G.USERNAME, perms, upload_path=file_to_share or dir_to_share)
orgs = r.body
if len(orgs) == 0:
return create_workspace(workspace_name, dir_to_share, G.USERNAME, perms, upload_path=file_to_share or dir_to_share)
choices = []
choices.append(G.USERNAME)
for o in orgs:
choices.append(o['name'])
owner = vim_choice('Create workspace for:', G.USERNAME, choices)
if owner:
return create_workspace(workspace_name, dir_to_share, owner, perms, upload_path=file_to_share or dir_to_share)
def on_input(self, dir_to_share):
file_to_share = None
dir_to_share = os.path.expanduser(dir_to_share)
dir_to_share = os.path.realpath(utils.unfuck_path(dir_to_share))
workspace_name = os.path.basename(dir_to_share)
workspace_url = None
print(G.COLAB_DIR, G.USERNAME, workspace_name)
def find_workspace(workspace_url):
r = api.get_workspace_by_url(workspace_url)
if r.code < 400:
on_room_info_waterfall.add(ignore.create_flooignore, dir_to_share)
on_room_info_waterfall.add(lambda: G.AGENT.upload(dir_to_share, on_room_info_msg))
return r
try:
result = utils.parse_url(workspace_url)
d = utils.get_persistent_data()
del d['workspaces'][result['owner']][result['name']]
utils.update_persistent_data(d)
except Exception as e:
msg.debug(unicode(e))
return
def join_workspace(workspace_url):
try:
w = find_workspace(workspace_url)
except Exception as e:
sublime.error_message('Error: %s' % str(e))
return False
if not w:
return False
msg.debug('workspace: %s', json.dumps(w.body))
# if self.api_args:
anon_perms = w.body.get('perms', {}).get('AnonymousUser', [])
new_anon_perms = self.api_args.get('perms').get('AnonymousUser', [])
if set(anon_perms) != set(new_anon_perms):
msg.debug(str(anon_perms), str(new_anon_perms))
w.body['perms']['AnonymousUser'] = new_anon_perms
response = api.update_workspace(w.body['owner'], w.body['name'], w.body)
msg.debug(str(response.body))
utils.add_workspace_to_persistent_json(w.body['owner'], w.body['name'], workspace_url, dir_to_share)
self.window.run_command('floobits_join_workspace', {
'workspace_url': workspace_url,
'agent_conn_kwargs': {'get_bufs': False}})
return True
if os.path.isfile(dir_to_share):
file_to_share = dir_to_share
dir_to_share = os.path.dirname(dir_to_share)
try:
utils.mkdir(dir_to_share)
except Exception:
return sublime.error_message('The directory %s doesn\'t exist and I can\'t make it.' % dir_to_share)
floo_file = os.path.join(dir_to_share, '.floo')
info = {}
try:
floo_info = open(floo_file, 'r').read()
info = json.loads(floo_info)
except (IOError, OSError):
pass
except Exception:
msg.error('Couldn\'t read the floo_info file: %s' % floo_file)
workspace_url = info.get('url')
try:
utils.parse_url(workspace_url)
except Exception:
workspace_url = None
if workspace_url and join_workspace(workspace_url):
return
for owner, workspaces in utils.get_persistent_data()['workspaces'].items():
for name, workspace in workspaces.items():
if workspace['path'] == dir_to_share:
workspace_url = workspace['url']
if join_workspace(workspace_url):
return
# make & join workspace
on_room_info_waterfall.add(ignore.create_flooignore, dir_to_share)
on_room_info_waterfall.add(lambda: G.AGENT.upload(file_to_share or dir_to_share, on_room_info_msg))
def on_done(owner):
self.window.run_command('floobits_create_workspace', {
'workspace_name': workspace_name,
'dir_to_share': dir_to_share,
'api_args': self.api_args,
'owner': owner[0],
})
try:
r = api.get_orgs_can_admin()
except IOError as e:
return sublime.error_message('Error getting org list: %s' % str(e))
if r.code >= 400 or len(r.body) == 0:
return on_done([G.USERNAME])
orgs = [[org['name'], 'Create workspace under %s' % org['name']] for org in r.body]
orgs.insert(0, [G.USERNAME, 'Create workspace under %s' % G.USERNAME])
self.window.show_quick_panel(orgs, lambda index: index < 0 or on_done(orgs[index]))
def on_input(self, dir_to_share):
file_to_share = None
dir_to_share = os.path.expanduser(dir_to_share)
dir_to_share = os.path.realpath(utils.unfuck_path(dir_to_share))
workspace_name = os.path.basename(dir_to_share)
workspace_url = None
# TODO: use prejoin_workspace instead
def find_workspace(workspace_url):
r = api.get_workspace_by_url(workspace_url)
if r.code < 400:
return r
try:
result = utils.parse_url(workspace_url)
d = utils.get_persistent_data()
del d['workspaces'][result['owner']][result['name']]
utils.update_persistent_data(d)
except Exception as e:
msg.debug(str_e(e))
def join_workspace(workspace_url):
try:
w = find_workspace(workspace_url)
except Exception as e:
sublime.error_message('Error: %s' % str_e(e))
return False
if not w:
return False
msg.debug('workspace: %s', json.dumps(w.body))
# if self.api_args:
anon_perms = w.body.get('perms', {}).get('AnonymousUser', [])
new_anon_perms = self.api_args.get('perms').get('AnonymousUser', [])
# TODO: warn user about making a private workspace public
if set(anon_perms) != set(new_anon_perms):
msg.debug(str(anon_perms), str(new_anon_perms))
w.body['perms']['AnonymousUser'] = new_anon_perms
response = api.update_workspace(workspace_url, w.body)
msg.debug(str(response.body))
utils.add_workspace_to_persistent_json(w.body['owner'], w.body['name'], workspace_url, dir_to_share)
self.window.run_command('floobits_join_workspace', {'workspace_url': workspace_url})
return True
if os.path.isfile(dir_to_share):
file_to_share = dir_to_share
dir_to_share = os.path.dirname(dir_to_share)
try:
utils.mkdir(dir_to_share)
except Exception:
sublime.error_message('The directory %s doesn\'t exist and I can\'t create it.' % dir_to_share)
return
floo_file = os.path.join(dir_to_share, '.floo')
info = {}
try:
floo_info = open(floo_file, 'r').read()
info = json.loads(floo_info)
except (IOError, OSError):
pass
except Exception:
msg.error('Couldn\'t read the floo_info file: %s' % floo_file)
workspace_url = info.get('url')
try:
utils.parse_url(workspace_url)
except Exception:
workspace_url = None
if workspace_url and join_workspace(workspace_url):
return
for owner, workspaces in utils.get_persistent_data()['workspaces'].items():
for name, workspace in workspaces.items():
if workspace['path'] == dir_to_share:
workspace_url = workspace['url']
if join_workspace(workspace_url):
return
auth = yield editor.select_auth, self.window, G.AUTH
if not auth:
return
username = auth.get('username')
host = auth['host']
def on_done(owner):
msg.log('Colab dir: %s, Username: %s, Workspace: %s/%s' % (G.COLAB_DIR, username, owner[0], workspace_name))
self.window.run_command('floobits_create_workspace', {
'workspace_name': workspace_name,
'dir_to_share': dir_to_share,
'upload': file_to_share or dir_to_share,
'api_args': self.api_args,
'owner': owner[0],
'host': host,
})
try:
r = api.get_orgs_can_admin(host)
except IOError as e:
sublime.error_message('Error getting org list: %s' % str_e(e))
return
if r.code >= 400 or len(r.body) == 0:
on_done([username])
return
orgs = [[org['name'], 'Create workspace owned by %s' % org['name']] for org in r.body]
orgs.insert(0, [username, 'Create workspace owned by %s' % username])
self.window.show_quick_panel(orgs, lambda index: index < 0 or on_done(orgs[index]))
def on_input(self, dir_to_share):
file_to_share = None
dir_to_share = os.path.expanduser(dir_to_share)
dir_to_share = os.path.realpath(utils.unfuck_path(dir_to_share))
workspace_name = os.path.basename(dir_to_share)
workspace_url = None
print(G.COLAB_DIR, G.USERNAME, workspace_name)
def find_workspace(workspace_url):
try:
api.get_workspace_by_url(workspace_url)
except HTTPError:
try:
result = utils.parse_url(workspace_url)
d = utils.get_persistent_data()
del d['workspaces'][result['owner']][result['name']]
utils.update_persistent_data(d)
except Exception as e:
msg.debug(unicode(e))
return False
on_room_info_waterfall.add(on_room_info_msg)
on_room_info_waterfall.add(ignore.create_flooignore, dir_to_share)
on_room_info_waterfall.add(Listener.create_buf, dir_to_share)
return True
if os.path.isfile(dir_to_share):
file_to_share = dir_to_share
dir_to_share = os.path.dirname(dir_to_share)
else:
try:
utils.mkdir(dir_to_share)
except Exception:
return sublime.error_message(
'The directory %s doesn\'t exist and I can\'t make it.' %
dir_to_share)
floo_file = os.path.join(dir_to_share, '.floo')
info = {}
try:
floo_info = open(floo_file, 'rb').read().decode('utf-8')
info = json.loads(floo_info)
except (IOError, OSError):
pass
except Exception:
print('Couldn\'t read the floo_info file: %s' % floo_file)
workspace_url = info.get('url')
try:
result = utils.parse_url(workspace_url)
except Exception:
workspace_url = None
if workspace_url and find_workspace(workspace_url):
add_workspace_to_persistent_json(result['owner'],
result['workspace'],
workspace_url, dir_to_share)
return self.window.run_command(
'floobits_join_workspace', {
'workspace_url': workspace_url,
'agent_conn_kwargs': {
'get_bufs': False
}
})
for owner, workspaces in utils.get_persistent_data(
)['workspaces'].items():
for name, workspace in workspaces.items():
if workspace['path'] == dir_to_share:
workspace_url = workspace['url']
if find_workspace(workspace_url):
return self.window.run_command(
'floobits_join_workspace', {
'workspace_url': workspace_url,
'agent_conn_kwargs': {
'get_bufs': False
}
})
# make & join workspace
on_room_info_waterfall.add(ignore.create_flooignore, dir_to_share)
on_room_info_waterfall.add(Listener.create_buf, file_to_share
or dir_to_share)
def on_done(owner):
self.window.run_command(
'floobits_create_workspace', {
'workspace_name': workspace_name,
'dir_to_share': dir_to_share,
'api_args': self.api_args,
'owner': owner[0],
})
orgs = api.get_orgs_can_admin()
orgs = json.loads(orgs.read().decode('utf-8'))
if len(orgs) == 0:
return on_done([G.USERNAME])
orgs = [[org['name'],
'Create workspace under %s' % org['name']] for org in orgs]
orgs.insert(0, [G.USERNAME, 'Create workspace under %s' % G.USERNAME])
self.window.show_quick_panel(
orgs, lambda index: index < 0 or on_done(orgs[index]))
def share_dir(self, dir_to_share, perms=None):
dir_to_share = os.path.expanduser(dir_to_share)
dir_to_share = utils.unfuck_path(dir_to_share)
workspace_name = os.path.basename(dir_to_share)
G.PROJECT_PATH = os.path.realpath(dir_to_share)
msg.debug('%s %s %s' % (G.USERNAME, workspace_name, G.PROJECT_PATH))
if os.path.isfile(dir_to_share):
return msg.error('%s is a file. Give me a directory please.' % dir_to_share)
try:
utils.mkdir(dir_to_share)
except Exception:
return msg.error("The directory %s doesn't exist and I can't make it." % dir_to_share)
floo_file = os.path.join(dir_to_share, '.floo')
info = {}
try:
floo_info = open(floo_file, 'rb').read().decode('utf-8')
info = json.loads(floo_info)
except (IOError, OSError):
pass
except Exception:
msg.debug("Couldn't read the floo_info file: %s" % floo_file)
workspace_url = info.get('url')
if workspace_url:
try:
result = utils.parse_url(workspace_url)
except Exception as e:
msg.error(str(e))
else:
workspace_name = result['workspace']
try:
# TODO: blocking. beachballs sublime 2 if API is super slow
api.get_workspace_by_url(workspace_url)
except HTTPError:
workspace_url = None
workspace_name = os.path.basename(dir_to_share)
else:
utils.add_workspace_to_persistent_json(result['owner'], result['workspace'], workspace_url, dir_to_share)
workspace_url = utils.get_workspace_by_path(dir_to_share) or workspace_url
if workspace_url:
try:
api.get_workspace_by_url(workspace_url)
except HTTPError:
pass
else:
return self.remote_connect(workspace_url, lambda this: this.protocol.create_buf(dir_to_share))
def on_done(data, choices=None):
self.create_workspace({}, workspace_name, dir_to_share, owner=data.get('response'), perms=perms)
orgs = api.get_orgs_can_admin()
orgs = json.loads(orgs.read().decode('utf-8'))
if len(orgs) == 0:
return on_done({'response': G.USERNAME})
i = 0
choices = []
choices.append([G.USERNAME, i])
for o in orgs:
i += 1
choices.append([o['name'], i])
self.get_input('Create workspace for [press tab for completion]: ', '', on_done, choices=choices)
def __init__(self, owner, workspace, auth, upload=None):
super(FlooHandler, self).__init__(auth)
self.owner = owner
self.workspace = workspace
self.upload_path = upload and utils.unfuck_path(upload)
self.reset()
def share_dir(dir_to_share):
dir_to_share = os.path.expanduser(dir_to_share)
dir_to_share = utils.unfuck_path(dir_to_share)
dir_to_share = os.path.abspath(dir_to_share)
workspace_name = os.path.basename(dir_to_share)
floo_workspace_dir = os.path.join(G.COLAB_DIR, G.USERNAME, workspace_name)
if os.path.isfile(dir_to_share):
return msg.error('give me a directory please')
if not os.path.isdir(dir_to_share):
return msg.error('The directory %s doesn\'t appear to exist' %
dir_to_share)
floo_file = os.path.join(dir_to_share, '.floo')
# look for the .floo file for hints about previous behavior
info = {}
try:
floo_info = open(floo_file, 'rb').read().decode('utf-8')
info = json.loads(floo_info)
except (IOError, OSError):
pass
except Exception:
msg.warn("couldn't read the floo_info file: %s" % floo_file)
workspace_url = info.get('url')
if workspace_url:
try:
result = utils.parse_url(workspace_url)
except Exception as e:
msg.error(str(e))
else:
workspace_name = result['workspace']
floo_workspace_dir = os.path.join(G.COLAB_DIR, result['owner'],
result['workspace'])
# they have previously joined the workspace
if os.path.realpath(floo_workspace_dir) == os.path.realpath(
dir_to_share):
# it could have been deleted, try to recreate it if possible
# TODO: org or something here?
if result['owner'] == G.USERNAME:
try:
api.create_workspace({'name': workspace_name})
msg.debug('Created workspace %s' % workspace_url)
except Exception as e:
msg.debug('Tried to create workspace' + str(e))
# they wanted to share teh dir, so always share it
return join_workspace(
workspace_url,
lambda x: agent.protocol.create_buf(dir_to_share,
force=True))
# link to what they want to share
try:
utils.mkdir(os.path.dirname(floo_workspace_dir))
os.symlink(dir_to_share, floo_workspace_dir)
except OSError as e:
if e.errno != 17:
raise
except Exception as e:
return msg.error("Couldn't create symlink from %s to %s: %s" %
(dir_to_share, floo_workspace_dir, str(e)))
# make & join workspace
create_workspace(workspace_name, floo_workspace_dir, dir_to_share)
def on_input(self, dir_to_share):
file_to_share = None
dir_to_share = os.path.expanduser(dir_to_share)
dir_to_share = os.path.realpath(utils.unfuck_path(dir_to_share))
workspace_name = os.path.basename(dir_to_share)
workspace_url = None
# TODO: use prejoin_workspace instead
def find_workspace(workspace_url):
r = api.get_workspace_by_url(workspace_url)
if r.code < 400:
return r
try:
result = utils.parse_url(workspace_url)
d = utils.get_persistent_data()
del d['workspaces'][result['owner']][result['name']]
utils.update_persistent_data(d)
except Exception as e:
msg.debug(str_e(e))
def join_workspace(workspace_url):
try:
w = find_workspace(workspace_url)
except Exception as e:
sublime.error_message('Error: %s' % str_e(e))
return False
if not w:
return False
msg.debug('workspace: %s', json.dumps(w.body))
# if self.api_args:
anon_perms = w.body.get('perms', {}).get('AnonymousUser', [])
new_anon_perms = self.api_args.get('perms').get(
'AnonymousUser', [])
# TODO: warn user about making a private workspace public
if set(anon_perms) != set(new_anon_perms):
msg.debug(str(anon_perms), str(new_anon_perms))
w.body['perms']['AnonymousUser'] = new_anon_perms
response = api.update_workspace(workspace_url, w.body)
msg.debug(str(response.body))
utils.add_workspace_to_persistent_json(w.body['owner'],
w.body['name'],
workspace_url, dir_to_share)
self.window.run_command('floobits_join_workspace',
{'workspace_url': workspace_url})
return True
if os.path.isfile(dir_to_share):
file_to_share = dir_to_share
dir_to_share = os.path.dirname(dir_to_share)
try:
utils.mkdir(dir_to_share)
except Exception:
sublime.error_message(
'The directory %s doesn\'t exist and I can\'t create it.' %
dir_to_share)
return
floo_file = os.path.join(dir_to_share, '.floo')
info = {}
try:
floo_info = open(floo_file, 'r').read()
info = json.loads(floo_info)
except (IOError, OSError):
pass
except Exception:
msg.error('Couldn\'t read the floo_info file: %s' % floo_file)
workspace_url = info.get('url')
try:
utils.parse_url(workspace_url)
except Exception:
workspace_url = None
if workspace_url and join_workspace(workspace_url):
return
for owner, workspaces in utils.get_persistent_data(
)['workspaces'].items():
for name, workspace in workspaces.items():
if workspace['path'] == dir_to_share:
workspace_url = workspace['url']
if join_workspace(workspace_url):
return
auth = yield editor.select_auth, self.window, G.AUTH
if not auth:
return
username = auth.get('username')
host = auth['host']
def on_done(owner):
msg.log('Colab dir: %s, Username: %s, Workspace: %s/%s' %
(G.COLAB_DIR, username, owner[0], workspace_name))
self.window.run_command(
'floobits_create_workspace', {
'workspace_name': workspace_name,
'dir_to_share': dir_to_share,
'upload': file_to_share or dir_to_share,
'api_args': self.api_args,
'owner': owner[0],
'host': host,
})
try:
r = api.get_orgs_can_admin(host)
except IOError as e:
sublime.error_message('Error getting org list: %s' % str_e(e))
return
if r.code >= 400 or len(r.body) == 0:
on_done([username])
return
orgs = [[org['name'],
'Create workspace owned by %s' % org['name']]
for org in r.body]
orgs.insert(0, [username, 'Create workspace owned by %s' % username])
self.window.show_quick_panel(
orgs, lambda index: index < 0 or on_done(orgs[index]))
def floobits_share_dir(dir_to_share, perms):
utils.reload_settings()
workspace_name = os.path.basename(dir_to_share)
G.PROJECT_PATH = os.path.realpath(dir_to_share)
msg.debug('%s %s %s' % (G.USERNAME, workspace_name, G.PROJECT_PATH))
file_to_share = None
dir_to_share = os.path.expanduser(dir_to_share)
dir_to_share = utils.unfuck_path(dir_to_share)
dir_to_share = os.path.abspath(dir_to_share)
dir_to_share = os.path.realpath(dir_to_share)
workspace_name = os.path.basename(dir_to_share)
if os.path.isfile(dir_to_share):
file_to_share = dir_to_share
dir_to_share = os.path.dirname(dir_to_share)
try:
utils.mkdir(dir_to_share)
except Exception:
return msg.error(
"The directory %s doesn't exist and I can't create it." %
dir_to_share)
if not os.path.isdir(dir_to_share):
return msg.error('The directory %s doesn\'t appear to exist' %
dir_to_share)
floo_file = os.path.join(dir_to_share, '.floo')
# look for the .floo file for hints about previous behavior
info = {}
try:
floo_info = open(floo_file, 'rb').read().decode('utf-8')
info = json.loads(floo_info)
except (IOError, OSError):
pass
except Exception:
msg.warn('couldn\'t read the floo_info file: %s' % floo_file)
workspace_url = info.get('url')
if workspace_url:
parsed_url = api.prejoin_workspace(workspace_url, dir_to_share,
{'perms': perms})
if parsed_url:
return floobits_join_workspace(workspace_url,
dir_to_share,
upload_path=file_to_share
or dir_to_share)
filter_func = lambda workspace_url: api.prejoin_workspace(
workspace_url, dir_to_share, {'perms': perms})
parsed_url = utils.get_workspace_by_path(dir_to_share, filter_func)
if parsed_url:
return floobits_join_workspace(workspace_url,
dir_to_share,
upload_path=file_to_share
or dir_to_share)
try:
r = api.get_orgs_can_admin()
except IOError as e:
return editor.error_message('Error getting org list: %s' % str(e))
if r.code >= 400 or len(r.body) == 0:
workspace_name = vim_input('Workspace name:', workspace_name, "file")
return create_workspace(workspace_name,
dir_to_share,
G.USERNAME,
perms,
upload_path=file_to_share or dir_to_share)
orgs = r.body
if len(orgs) == 0:
return create_workspace(workspace_name,
dir_to_share,
G.USERNAME,
perms,
upload_path=file_to_share or dir_to_share)
choices = []
choices.append(G.USERNAME)
for o in orgs:
choices.append(o['name'])
owner = vim_choice('Create workspace for:', G.USERNAME, choices)
if owner:
return create_workspace(workspace_name,
dir_to_share,
owner,
perms,
upload_path=file_to_share or dir_to_share)