diff options
Diffstat (limited to 'caja-dropbox.in')
| -rwxr-xr-x | caja-dropbox.in | 1362 |
1 files changed, 1362 insertions, 0 deletions
diff --git a/caja-dropbox.in b/caja-dropbox.in new file mode 100755 index 0000000..abf7e82 --- /dev/null +++ b/caja-dropbox.in @@ -0,0 +1,1362 @@ +#!/usr/bin/python +# +# Copyright 2008 Evenflow, Inc. +# +# dropbox +# Dropbox frontend script +# This file is part of caja-dropbox @PACKAGE_VERSION@. +# +# caja-dropbox is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# caja-dropbox is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with caja-dropbox. If not, see <http://www.gnu.org/licenses/>. +# +from __future__ import with_statement + +import errno +import fcntl +import locale +import optparse +import os +import platform +import shutil +import socket +import StringIO +import subprocess +import sys +import tarfile +import tempfile +import threading +import time +import urllib + +try: + import gpgme +except ImportError: + gpgme = None + +from contextlib import closing, contextmanager +from posixpath import curdir, sep, pardir, join, abspath, commonprefix + +INFO = u"Dropbox is the easiest way to share and store your files online. Want to learn more? Head to" +LINK = u"http://www.dropbox.com/" +WARNING = u"In order to use Dropbox, you must download the proprietary daemon." +GPG_WARNING = u"Note: python-gpgme is not installed, we will not be able to verify binary signatures." + +DOWNLOADING = u"Downloading Dropbox... %d%%" +UNPACKING = u"Unpacking Dropbox... %d%%" + +PARENT_DIR = os.path.expanduser("~") +DROPBOXD_PATH = "%s/.dropbox-dist/dropboxd" % PARENT_DIR +DESKTOP_FILE = u"@DESKTOP_FILE_DIR@/dropbox.desktop" + +enc = locale.getpreferredencoding() + +# Available from http://linux.dropbox.com/fedora/rpm-public-key.asc +DROPBOX_PUBLIC_KEY = """ +-----BEGIN PGP PUBLIC KEY BLOCK----- +Version: SKS 1.1.0 + +mQENBEt0ibEBCACv4hZRPqwtpU6z8+BB5YZU1a3yjEvg2W68+a6hEwxtCa2U++4dzQ+7EqaU +q5ybQnwtbDdpFpsOi9x31J+PCpufPUfIG694/0rlEpmzl2GWzY8NqfdBFGGm/SPSSwvKbeNc +FMRLu5neo7W9kwvfMbGjHmvUbzBUVpCVKD0OEEf1q/Ii0Qcekx9CMoLvWq7ZwNHEbNnij7ec +nvwNlE2MxNsOSJj+hwZGK+tM19kuYGSKw4b5mR8IyThlgiSLIfpSBh1n2KX+TDdk9GR+57TY +vlRu6nTPu98P05IlrrCP+KF0hYZYOaMvQs9Rmc09tc/eoQlN0kkaBWw9Rv/dvLVc0aUXABEB +AAG0MURyb3Bib3ggQXV0b21hdGljIFNpZ25pbmcgS2V5IDxsaW51eEBkcm9wYm94LmNvbT6J +ATYEEwECACAFAkt0ibECGwMGCwkIBwMCBBUCCAMEFgIDAQIeAQIXgAAKCRD8kYszUESRLi/z +B/wMscEa15rS+0mIpsORknD7kawKwyda+LHdtZc0hD/73QGFINR2P23UTol/R4nyAFEuYNsF +0C4IAD6y4pL49eZ72IktPrr4H27Q9eXhNZfJhD7BvQMBx75L0F5gSQwuC7GdYNlwSlCD0AAh +Qbi70VBwzeIgITBkMQcJIhLvllYo/AKD7Gv9huy4RLaIoSeofp+2Q0zUHNPl/7zymOqu+5Ox +e1ltuJT/kd/8hU+N5WNxJTSaOK0sF1/wWFM6rWd6XQUP03VyNosAevX5tBo++iD1WY2/lFVU +JkvAvge2WFk3c6tAwZT/tKxspFy4M/tNbDKeyvr685XKJw9ei6GcOGHD +=5rWG +-----END PGP PUBLIC KEY BLOCK----- +""" + +# Futures + +def methodcaller(name, *args, **kwargs): + def caller(obj): + return getattr(obj, name)(*args, **kwargs) + return caller + +def relpath(path, start=curdir): + """Return a relative version of a path""" + + if not path: + raise ValueError("no path specified") + + if type(start) is unicode: + start_list = unicode_abspath(start).split(sep) + else: + start_list = abspath(start).split(sep) + + if type(path) is unicode: + path_list = unicode_abspath(path).split(sep) + else: + path_list = abspath(path).split(sep) + + # Work out how much of the filepath is shared by start and path. + i = len(commonprefix([start_list, path_list])) + + rel_list = [pardir] * (len(start_list)-i) + path_list[i:] + if not rel_list: + return curdir + return join(*rel_list) + +# End Futures + + +def console_print(st=u"", f=sys.stdout, linebreak=True): + global enc + assert type(st) is unicode + f.write(st.encode(enc)) + if linebreak: f.write(os.linesep) + +def console_flush(f=sys.stdout): + f.flush() + +def yes_no_question(question): + while True: + console_print(question, linebreak=False) + console_print(u" [y/n] ", linebreak=False) + console_flush() + text = raw_input() + if text.lower().startswith("y"): + return True + elif text.lower().startswith("n"): + return False + else: + console_print(u"Sorry, I didn't understand that. Please type yes or no.") + +def plat(): + if sys.platform.lower().startswith('linux'): + arch = platform.machine() + if (arch[0] == 'i' and + arch[1].isdigit() and + arch[2:4] == '86'): + plat = "x86" + elif arch == 'x86_64': + plat = arch + else: + FatalVisibleError("Platform not supported") + return "lnx.%s" % plat + else: + FatalVisibleError("Platform not supported") + +def is_dropbox_running(): + pidfile = os.path.expanduser("~/.dropbox/dropbox.pid") + + try: + with open(pidfile, "r") as f: + pid = int(f.read()) + with open("/proc/%d/cmdline" % pid, "r") as f: + cmdline = f.read().lower() + except: + cmdline = "" + + return "dropbox" in cmdline + +def unicode_abspath(path): + global enc + assert type(path) is unicode + # shouldn't pass unicode to this craphead, it appends with os.getcwd() which is always a str + return os.path.abspath(path.encode(sys.getfilesystemencoding())).decode(sys.getfilesystemencoding()) + +@contextmanager +def gpgme_context(keys): + gpg_conf_contents = '' + _gpghome = tempfile.mkdtemp(prefix='tmp.gpghome') + + try: + os.environ['GNUPGHOME'] = _gpghome + fp = open(os.path.join(_gpghome, 'gpg.conf'), 'wb') + fp.write(gpg_conf_contents) + fp.close() + ctx = gpgme.Context() + + loaded = [] + for key_file in keys: + result = ctx.import_(key_file) + key = ctx.get_key(result.imports[0][0]) + loaded.append(key) + + ctx.signers = loaded + + yield ctx + finally: + del os.environ['GNUPGHOME'] + shutil.rmtree(_gpghome, ignore_errors=True) + +def verify_signature(key_file, sig_file, plain_file): + with gpgme_context([key_file]) as ctx: + sigs = ctx.verify(sig_file, plain_file, None) + return sigs[0].status == None + +def download_file_chunk(socket, buf, size): + progress = 0 + with closing(socket) as f: + while True: + try: + chunk = os.read(f.fileno(), 4096) + progress += len(chunk) + buf.write(chunk) + yield (progress, True) + if progress == size: + break + except OSError, e: + if hasattr(e, 'errno') and e.errno == errno.EAGAIN: + # nothing left to read + yield (progress, False) + else: + raise + +def download_uri_to_buffer(uri): + try: + socket = urllib.urlopen(uri) + except IOError: + FatalVisibleError("Trouble connecting to Dropbox servers. Maybe your internet connection is down, or you need to set your http_proxy environment variable.") + + fcntl.fcntl(socket, fcntl.F_SETFL, os.O_NONBLOCK) + size = int(socket.info()['content-length']) + + buf = StringIO.StringIO() + download_chunk = download_file_chunk(socket, buf, size) + + for _ in download_chunk: + pass + + buf.seek(0) + return buf + +# This sets a custom User-Agent +class DropboxURLopener(urllib.FancyURLopener): + version = "DropboxLinuxDownloader/@PACKAGE_VERSION@" +urllib._urlopener = DropboxURLopener() + +class DownloadState(object): + def __init__(self): + try: + self.socket = urllib.urlopen("http://www.dropbox.com/download?plat=%s" % plat()) + except IOError: + FatalVisibleError("Trouble connecting to Dropbox servers. Maybe your internet connection is down, or you need to set your http_proxy environment variable") + + fcntl.fcntl(self.socket, fcntl.F_SETFL, os.O_NONBLOCK) + self.size = int(self.socket.info()['content-length']) + + self.local_file = StringIO.StringIO() + self.download_chunk = download_file_chunk(self.socket, self.local_file, self.size) + + def copy_data(self): + return self.download_chunk + + def unpack(self): + # download signature + signature = download_uri_to_buffer("http://www.dropbox.com/download?plat=%s&signature=1" % plat()) + + self.local_file.seek(0) + if gpgme: + if not verify_signature(StringIO.StringIO(DROPBOX_PUBLIC_KEY), signature, self.local_file): + FatalVisibleError("Downloaded binary does not match Dropbox signature, aborting install.") + + self.local_file.seek(0) + archive = tarfile.open(fileobj=self.local_file, mode='r:gz') + total_members = len(archive.getmembers()) + for i, member in enumerate(archive.getmembers()): + archive.extract(member, PARENT_DIR) + yield member.name, i, total_members + archive.close() + + def cancel(self): + if not self.local_file.closed: + self.local_file.close() + +def load_serialized_images(): + global box_logo_pixbuf, window_icon + import gtk + box_logo_pixbuf = @IMAGEDATA64@ + window_icon = @IMAGEDATA16@ + +GUI_AVAILABLE = os.environ.get("DISPLAY", '') + +if GUI_AVAILABLE: + def download(): + import pygtk + pygtk.require("2.0") + import gtk + import gobject + import pango + import webbrowser + + load_serialized_images() + + global FatalVisibleError + def FatalVisibleError(s): + error = gtk.MessageDialog(parent = None, + flags = gtk.DIALOG_MODAL, + type = gtk.MESSAGE_ERROR, + buttons = gtk.BUTTONS_OK, + message_format = s) + error.set_title("Error") + error.run() + gtk.main_quit() + sys.exit(-1) + + def gtk_flush_events(): + while gtk.events_pending(): + gtk.main_iteration() + + class DownloadDialog(gtk.Dialog): + def handle_delete_event(self, wid, ev, data=None): + self.handle_cancel(wid) + + def handle_dont_show_toggle(self, button, data=None): + reroll_autostart(not button.get_active()) + + def handle_cancel(self, button): + if self.watch: + gobject.source_remove(self.watch) + if self.download: + self.download.cancel() + gtk.main_quit() + self.user_cancelled = True + + def handle_ok(self, button): + # begin download + self.ok.hide() + self.download = DownloadState() + self.one_chunk = self.download.copy_data() + self.watch = gobject.io_add_watch(self.download.socket, + gobject.IO_IN | + gobject.IO_PRI | + gobject.IO_ERR | + gobject.IO_HUP, + self.handle_data_waiting) + self.label.hide() + self.dont_show_again_align.hide() + self.progress.show() + + def update_progress(self, text, fraction): + self.progress.set_text(text % int(fraction*100)) + self.progress.set_fraction(fraction) + gtk_flush_events() + + def handle_data_waiting(self, fd, condition): + if condition == gobject.IO_HUP: + FatalVisibleError("Connection to server unexpectedly closed.") + elif condition == gobject.IO_ERR: + FatalVisibleError("Unexpected error occurred with download.") + try: + while True: + progress, status = self.one_chunk.next() + if not status: + break + self.update_progress(DOWNLOADING, float(progress)/self.download.size) + except StopIteration: + self.update_progress(DOWNLOADING, 1.0) + self.unpack_dropbox() + return False + else: + self.update_progress(DOWNLOADING, float(progress)/self.download.size) + return True + + def unpack_dropbox(self): + one_member = self.download.unpack() + try: + while True: + name, i, total = one_member.next() + self.update_progress(UNPACKING, float(i)/total) + except StopIteration: + self.update_progress(UNPACKING, 1.0) + gtk.main_quit() + + def mouse_down(self, widget, event): + if self.hovering: + self.clicked_link = True + + def mouse_up(self, widget, event): + if self.clicked_link: + webbrowser.open(LINK) + self.clicked_link = False + + def label_motion(self, widget, event): + offx, offy = self.label.get_layout_offsets() + layout = self.label.get_layout() + index = layout.xy_to_index(int((offx+event.x)*pango.SCALE), + int((offy+event.y)*pango.SCALE))[0] + link_index = layout.get_text().find(LINK) + if index >= link_index and index < link_index+len(LINK): + self.hovering = True + self.label_box.window.set_cursor(gtk.gdk.Cursor(gtk.gdk.HAND2)) + else: + self.hovering = False + self.label_box.window.set_cursor(gtk.gdk.Cursor(gtk.gdk.ARROW)) + + + def __init__(self): + super(DownloadDialog, self).__init__(parent = None, + title = "Dropbox Installation") + + self.download = None + self.watch = None + self.hovering = False + self.clicked_link = False + self.user_cancelled = False + + self.ok = ok = gtk.Button(stock=gtk.STOCK_OK) + ok.connect('clicked', self.handle_ok) + self.action_area.add(ok) + ok.show() + + cancel = gtk.Button(stock=gtk.STOCK_CANCEL) + cancel.connect('clicked', self.handle_cancel) + self.action_area.add(cancel) + cancel.show() + + self.connect('delete_event', self.handle_delete_event) + + self.box_logo = gtk.image_new_from_pixbuf(box_logo_pixbuf) + self.box_logo.show() + + self.set_icon(window_icon) + + self.progress = gtk.ProgressBar() + self.progress.set_property('width-request', 300) + + self.label = gtk.Label() + GPG_WARNING_MSG = (u"\n\n" + GPG_WARNING) if not gpgme else u"" + self.label.set_markup('%s <span foreground="#000099" underline="single" weight="bold">%s</span>\n\n%s%s' % (INFO, LINK, WARNING, GPG_WARNING_MSG)) + self.label.set_line_wrap(True) + self.label.set_property('width-request', 300) + self.label.show() + + self.label_box = gtk.EventBox() + self.label_box.add(self.label) + self.label_box.connect("button-release-event", self.mouse_up) + self.label_box.connect("button-press-event", self.mouse_down) + self.label_box.connect("motion-notify-event", self.label_motion) + + self.label_box.show() + def on_realize(widget): + self.label_box.add_events(gtk.gdk.POINTER_MOTION_MASK) + self.label_box.connect("realize", on_realize) + + self.hbox = gtk.HBox(spacing=10) + self.hbox.set_property('border-width',10) + self.hbox.pack_start(self.box_logo, False, False) + self.hbox.pack_start(self.label_box, False, False) + self.hbox.pack_start(self.progress, False, False) + self.hbox.show() + + self.vbox.add(self.hbox) + + try: + if can_reroll_autostart(): + dont_show_again = gtk.CheckButton("_Don't show this again") + dont_show_again.connect('toggled', self.handle_dont_show_toggle) + dont_show_again.show() + + self.dont_show_again_align = gtk.Alignment(xalign=1.0, yalign=0.0, xscale=0.0, yscale=0.0) + self.dont_show_again_align.add(dont_show_again) + self.dont_show_again_align.show() + + hbox = gtk.HBox() + hbox.set_property('border-width', 10) + hbox.pack_start(self.dont_show_again_align, True, True) + hbox.show() + + self.vbox.add(hbox) + + self.set_resizable(False) + except: + import traceback + traceback.print_exc() + + self.ok.grab_focus() + + dialog = DownloadDialog() + dialog.show() + gtk.main() + if dialog.user_cancelled: + raise Exception("user cancelled download!!!") +else: + def download(): + global FatalVisibleError + def FatalVisibleError(s): + console_print(u"\nError: %s" % s, f=sys.stderr) + sys.exit(-1) + + + ESC = "\x1b" + save = ESC+"7" + unsave = ESC+"8" + clear = ESC+"[2J" + erase_to_start = ESC+"[1K" + write = sys.stdout.write + flush = sys.stdout.flush + + last_progress = [None, None] + def setprogress(text, frac): + if last_progress == [text, frac]: + return + if sys.stdout.isatty(): + write(erase_to_start) + write(unsave) + console_print(text % int(100*frac), linebreak=not sys.stdout.isatty()) + if sys.stdout.isatty(): + flush() + last_progress[0], last_progress[1] = text, frac + + console_print() + if sys.stdout.isatty(): + write(save) + flush() + console_print(u"%s %s\n" % (INFO, LINK)) + GPG_WARNING_MSG = (u"\n%s" % GPG_WARNING) if not gpgme else u"" + + if not yes_no_question("%s%s" % (WARNING, GPG_WARNING_MSG)): + return + + download = DownloadState() + one_chunk = download.copy_data() + + try: + while True: + progress = one_chunk.next()[0] + setprogress(DOWNLOADING, float(progress)/download.size) + except StopIteration: + setprogress(DOWNLOADING, 1.0) + console_print() + write(save) + + one_member = download.unpack() + + try: + while True: + name, i, total = one_member.next() + setprogress(UNPACKING, float(i)/total) + except StopIteration: + setprogress(UNPACKING, 1.0) + + console_print() + +class CommandTicker(threading.Thread): + def __init__(self): + threading.Thread.__init__(self) + self.stop_event = threading.Event() + + def stop(self): + self.stop_event.set() + + def run(self): + ticks = ['[. ]', '[.. ]', '[...]', '[ ..]', '[ .]', '[ ]'] + i = 0 + first = True + while True: + self.stop_event.wait(0.25) + if self.stop_event.isSet(): break + if i == len(ticks): + first = False + i = 0 + if not first: + sys.stderr.write("\r%s\r" % ticks[i]) + sys.stderr.flush() + i += 1 + sys.stderr.flush() + + +class DropboxCommand(object): + class CouldntConnectError(Exception): pass + class BadConnectionError(Exception): pass + class EOFError(Exception): pass + class CommandError(Exception): pass + + def __init__(self, timeout=5): + self.s = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) + self.s.settimeout(timeout) + try: + self.s.connect(os.path.expanduser(u'~/.dropbox/command_socket')) + except socket.error, e: + raise DropboxCommand.CouldntConnectError() + self.f = self.s.makefile("r+", 4096) + + def close(self): + self.f.close() + self.s.close() + + def __readline(self): + try: + toret = self.f.readline().decode('utf8').rstrip(u"\n") + except socket.error, e: + raise DropboxCommand.BadConnectionError() + if toret == '': + raise DropboxCommand.EOFError() + else: + return toret + + # atttribute doesn't exist, i know what you want + def send_command(self, name, args): + self.f.write(name.encode('utf8')) + self.f.write(u"\n".encode('utf8')) + self.f.writelines((u"\t".join([k] + (list(v) + if hasattr(v, '__iter__') else + [v])) + u"\n").encode('utf8') + for k,v in args.iteritems()) + self.f.write(u"done\n".encode('utf8')) + + self.f.flush() + + # Start a ticker + ticker_thread = CommandTicker() + ticker_thread.start() + + # This is the potentially long-running call. + try: + ok = self.__readline() == u"ok" + except KeyboardInterrupt: + raise DropboxCommand.BadConnectionError("Keyboard interruption detected") + finally: + # Tell the ticker to stop. + ticker_thread.stop() + ticker_thread.join() + + if ok: + toret = {} + for i in range(21): + if i == 20: + raise Exception(u"close this connection!") + + line = self.__readline() + if line == u"done": + break + + argval = line.split(u"\t") + toret[argval[0]] = argval[1:] + + return toret + else: + problems = [] + for i in range(21): + if i == 20: + raise Exception(u"close this connection!") + + line = self.__readline() + if line == u"done": + break + + problems.append(line) + + raise DropboxCommand.CommandError(u"\n".join(problems)) + + # this is the hotness, auto marshalling + def __getattr__(self, name): + try: + return super(DropboxCommand, self).__getattr__(name) + except: + def __spec_command(**kw): + return self.send_command(unicode(name), kw) + self.__setattr__(name, __spec_command) + return __spec_command + +commands = {} +aliases = {} + +def command(meth): + global commands, aliases + assert meth.__doc__, "All commands need properly formatted docstrings (even %r!!)" % meth + if hasattr(meth, 'im_func'): # bound method, if we ever have one + meth = meth.im_func + commands[meth.func_name] = meth + meth_aliases = [unicode(alias) for alias in aliases.iterkeys() if aliases[alias].func_name == meth.func_name] + if meth_aliases: + meth.__doc__ += u"\nAliases: %s" % ",".join(meth_aliases) + return meth + +def alias(name): + def decorator(meth): + global commands, aliases + assert name not in commands, "This alias is the name of a command." + aliases[name] = meth + return meth + return decorator + +def requires_dropbox_running(meth): + def newmeth(*n, **kw): + if is_dropbox_running(): + return meth(*n, **kw) + else: + console_print(u"Dropbox isn't running!") + newmeth.func_name = meth.func_name + newmeth.__doc__ = meth.__doc__ + return newmeth + +def start_dropbox(): + db_path = os.path.expanduser(u"~/.dropbox-dist/dropboxd").encode(sys.getfilesystemencoding()) + if os.access(db_path, os.X_OK): + f = open("/dev/null", "w") + # we don't reap the child because we're gonna die anyway, let init do it + a = subprocess.Popen([db_path], preexec_fn=os.setsid, cwd=os.path.expanduser("~"), + stderr=sys.stderr, stdout=f, close_fds=True) + + # in seconds + interval = 0.5 + wait_for = 60 + for i in xrange(int(wait_for / interval)): + if is_dropbox_running(): + return True + # back off from connect for a while + time.sleep(interval) + + return False + else: + return False + +# Extracted and modified from os.cmd.Cmd +def columnize(list, display_list=None, display_width=None): + if not list: + console_print(u"<empty>") + return + + non_unicode = [i for i in range(len(list)) if not (isinstance(list[i], unicode))] + if non_unicode: + raise TypeError, ("list[i] not a string for i in %s" % + ", ".join(map(unicode, non_unicode))) + + if not display_width: + d = os.popen('stty size', 'r').read().split() + if d: + display_width = int(d[1]) + else: + for item in list: + console_print(item) + return + + if not display_list: + display_list = list + + size = len(list) + if size == 1: + console_print(display_list[0]) + return + + for nrows in range(1, len(list)): + ncols = (size+nrows-1) // nrows + colwidths = [] + totwidth = -2 + for col in range(ncols): + colwidth = 0 + for row in range(nrows): + i = row + nrows*col + if i >= size: + break + x = list[i] + colwidth = max(colwidth, len(x)) + colwidths.append(colwidth) + totwidth += colwidth + 2 + if totwidth > display_width: + break + if totwidth <= display_width: + break + else: + nrows = len(list) + ncols = 1 + colwidths = [0] + lines = [] + for row in range(nrows): + texts = [] + display_texts = [] + for col in range(ncols): + i = row + nrows*col + if i >= size: + x = "" + y = "" + else: + x = list[i] + y = display_list[i] + texts.append(x) + display_texts.append(y) + while texts and not texts[-1]: + del texts[-1] + original_texts = texts[:] + for col in range(len(texts)): + texts[col] = texts[col].ljust(colwidths[col]) + line = u"%s" % " ".join(texts) + for i, text in enumerate(original_texts): + line = line.replace(text, display_texts[i]) + lines.append(line) + for line in lines: + console_print(line) + +@command +@requires_dropbox_running +@alias('stat') +def filestatus(args): + u"""get current sync status of one or more files +dropbox filestatus [-l] [-a] [FILE]... + +Prints the current status of each FILE. + +options: + -l --list prints out information in a format similar to ls. works best when your console supports color :) + -a --all do not ignore entries starting with . +""" + global enc + + oparser = optparse.OptionParser() + oparser.add_option("-l", "--list", action="store_true", dest="list") + oparser.add_option("-a", "--all", action="store_true", dest="all") + (options, args) = oparser.parse_args(args) + + try: + with closing(DropboxCommand()) as dc: + if options.list: + # Listing. + + # Separate directories from files. + if len(args) == 0: + dirs, nondirs = [u"."], [] + else: + dirs, nondirs = [], [] + + for a in args: + try: + (dirs if os.path.isdir(a) else nondirs).append(a.decode(enc)) + except UnicodeDecodeError: + continue + + if len(dirs) == 0 and len(nondirs) == 0: + #TODO: why? + exit(1) + + dirs.sort(key=methodcaller('lower')) + nondirs.sort(key=methodcaller('lower')) + + # Gets a string representation for a path. + def path_to_string(file_path): + if not os.path.exists(file_path): + path = u"%s (File doesn't exist!)" % os.path.basename(file_path) + return (path, path) + try: + status = dc.icon_overlay_file_status(path=file_path).get(u'status', [None])[0] + except DropboxCommand.CommandError, e: + path = u"%s (%s)" % (os.path.basename(file_path), e) + return (path, path) + + env_term = os.environ.get('TERM','') + supports_color = (sys.stderr.isatty() and ( + env_term.startswith('vt') or + env_term.startswith('linux') or + 'xterm' in env_term or + 'color' in env_term + ) + ) + + # TODO: Test when you don't support color. + if not supports_color: + path = os.path.basename(file_path) + return (path, path) + + if status == u"up to date": + init, cleanup = "\x1b[32;1m", "\x1b[0m" + elif status == u"syncing": + init, cleanup = "\x1b[36;1m", "\x1b[0m" + elif status == u"unsyncable": + init, cleanup = "\x1b[41;1m", "\x1b[0m" + elif status == u"selsync": + init, cleanup = "\x1b[37;1m", "\x1b[0m" + else: + init, cleanup = '', '' + + path = os.path.basename(file_path) + return (path, u"%s%s%s" % (init, path, cleanup)) + + # Prints a directory. + def print_directory(name): + clean_paths = [] + formatted_paths = [] + for subname in sorted(os.listdir(name), key=methodcaller('lower')): + if type(subname) != unicode: + continue + + if not options.all and subname[0] == u'.': + continue + + try: + clean, formatted = path_to_string(unicode_abspath(os.path.join(name, subname))) + clean_paths.append(clean) + formatted_paths.append(formatted) + except (UnicodeEncodeError, UnicodeDecodeError), e: + continue + + columnize(clean_paths, formatted_paths) + + try: + if len(dirs) == 1 and len(nondirs) == 0: + print_directory(dirs[0]) + else: + nondir_formatted_paths = [] + nondir_clean_paths = [] + for name in nondirs: + try: + clean, formatted = path_to_string(unicode_abspath(name)) + nondir_clean_paths.append(clean) + nondir_formatted_paths.append(formatted) + except (UnicodeEncodeError, UnicodeDecodeError), e: + continue + + if nondir_clean_paths: + columnize(nondir_clean_paths, nondir_formatted_paths) + + if len(nondirs) == 0: + console_print(dirs[0] + u":") + print_directory(dirs[0]) + dirs = dirs[1:] + + for name in dirs: + console_print() + console_print(name + u":") + print_directory(name) + + except DropboxCommand.EOFError: + console_print(u"Dropbox daemon stopped.") + except DropboxCommand.BadConnectionError, e: + console_print(u"Dropbox isn't responding!") + else: + if len(args) == 0: + args = [name for name in sorted(os.listdir(u"."), key=methodcaller('lower')) if type(name) == unicode] + indent = max(len(st)+1 for st in args) + for file in args: + + try: + if type(file) is not unicode: + file = file.decode(enc) + fp = unicode_abspath(file) + except (UnicodeEncodeError, UnicodeDecodeError), e: + continue + if not os.path.exists(fp): + console_print(u"%-*s %s" % \ + (indent, file+':', "File doesn't exist")) + continue + + try: + status = dc.icon_overlay_file_status(path=fp).get(u'status', [u'unknown'])[0] + console_print(u"%-*s %s" % (indent, file+':', status)) + except DropboxCommand.CommandError, e: + console_print(u"%-*s %s" % (indent, file+':', e)) + except DropboxCommand.CouldntConnectError, e: + console_print(u"Dropbox isn't running!") + +@command +@requires_dropbox_running +def ls(args): + u"""list directory contents with current sync status +dropbox ls [FILE]... + +This is an alias for filestatus -l +""" + return filestatus(["-l"] + args) + +@command +@requires_dropbox_running +def puburl(args): + u"""get public url of a file in your dropbox +dropbox puburl FILE + +Prints out a public url for FILE. +""" + if len(args) != 1: + console_print(puburl.__doc__,linebreak=False) + return + + try: + with closing(DropboxCommand()) as dc: + try: + console_print(dc.get_public_link(path=unicode_abspath(args[0].decode(sys.getfilesystemencoding()))).get(u'link', [u'No Link'])[0]) + except DropboxCommand.CommandError, e: + console_print(u"Couldn't get public url: " + str(e)) + except DropboxCommand.BadConnectionError, e: + console_print(u"Dropbox isn't responding!") + except DropboxCommand.EOFError: + console_print(u"Dropbox daemon stopped.") + except DropboxCommand.CouldntConnectError, e: + console_print(u"Dropbox isn't running!") + +@command +@requires_dropbox_running +def status(args): + u"""get current status of the dropboxd +dropbox status + +Prints out the current status of the Dropbox daemon. +""" + if len(args) != 0: + console_print(status.__doc__,linebreak=False) + return + + try: + with closing(DropboxCommand()) as dc: + try: + lines = dc.get_dropbox_status()[u'status'] + if len(lines) == 0: + console_print(u'Idle') + else: + for line in lines: + console_print(line) + except KeyError: + console_print(u"Couldn't get status: daemon isn't responding") + except DropboxCommand.CommandError, e: + console_print(u"Couldn't get status: " + str(e)) + except DropboxCommand.BadConnectionError, e: + console_print(u"Dropbox isn't responding!") + except DropboxCommand.EOFError: + console_print(u"Dropbox daemon stopped.") + except DropboxCommand.CouldntConnectError, e: + console_print(u"Dropbox isn't running!") + +@command +def running(argv): + u"""return whether dropbox is running +dropbox running + +Returns 1 if running 0 if not running. +""" + return int(is_dropbox_running()) + +@command +@requires_dropbox_running +def stop(args): + u"""stop dropboxd +dropbox stop + +Stops the dropbox daemon. +""" + try: + with closing(DropboxCommand()) as dc: + try: + dc.tray_action_hard_exit() + except DropboxCommand.BadConnectionError, e: + console_print(u"Dropbox isn't responding!") + except DropboxCommand.EOFError: + console_print(u"Dropbox daemon stopped.") + except DropboxCommand.CouldntConnectError, e: + console_print(u"Dropbox isn't running!") + +#returns true if link is necessary +def grab_link_url_if_necessary(): + try: + with closing(DropboxCommand()) as dc: + try: + link_url = dc.needs_link().get(u"link_url", None) + if link_url is not None: + console_print(u"To link this computer to a dropbox account, visit the following url:\n%s" % link_url[0]) + return True + else: + return False + except DropboxCommand.CommandError, e: + pass + except DropboxCommand.BadConnectionError, e: + console_print(u"Dropbox isn't responding!") + except DropboxCommand.EOFError: + console_print(u"Dropbox daemon stopped.") + except DropboxCommand.CouldntConnectError, e: + console_print(u"Dropbox isn't running!") + +@command +@requires_dropbox_running +def lansync(argv): + u"""enables or disables LAN sync +dropbox lansync [y/n] + +options: + y dropbox will use LAN sync (default) + n dropbox will not use LAN sync +""" + if len(argv) != 1: + console_print(lansync.__doc__, linebreak=False) + return + + s = argv[0].lower() + if s.startswith('y') or s.startswith('-y'): + should_lansync = True + elif s.startswith('n') or s.startswith('-n'): + should_lansync = False + else: + should_lansync = None + + if should_lansync is None: + console_print(lansync.__doc__,linebreak=False) + else: + with closing(DropboxCommand()) as dc: + dc.set_lan_sync(lansync='enabled' if should_lansync else 'disabled') + + +@command +@requires_dropbox_running +def exclude(args): + u"""ignores/excludes a directory from syncing +dropbox exclude [list] +dropbox exclude add [DIRECTORY] [DIRECTORY] ... +dropbox exclude remove [DIRECTORY] [DIRECTORY] ... + +"list" prints a list of directories currently excluded from syncing. +"add" adds one or more directories to the exclusion list, then resynchronizes Dropbox. +"remove" removes one or more directories from the exclusion list, then resynchronizes Dropbox. +With no arguments, executes "list". +Any specified path must be within Dropbox. +""" + if len(args) == 0: + try: + with closing(DropboxCommand()) as dc: + try: + lines = [relpath(path) for path in dc.get_ignore_set()[u'ignore_set']] + lines.sort() + if len(lines) == 0: + console_print(u'No directories are being ignored.') + else: + console_print(u'Excluded: ') + for line in lines: + console_print(unicode(line)) + except KeyError: + console_print(u"Couldn't get ignore set: daemon isn't responding") + except DropboxCommand.CommandError, e: + if e.args[0].startswith(u"No command exists by that name"): + console_print(u"This version of the client does not support this command.") + else: + console_print(u"Couldn't get ignore set: " + str(e)) + except DropboxCommand.BadConnectionError, e: + console_print(u"Dropbox isn't responding!") + except DropboxCommand.EOFError: + console_print(u"Dropbox daemon stopped.") + except DropboxCommand.CouldntConnectError, e: + console_print(u"Dropbox isn't running!") + elif len(args) == 1 and args[0] == u"list": + exclude([]) + elif len(args) >= 2: + sub_command = args[0] + paths = args[1:] + absolute_paths = [unicode_abspath(path.decode(sys.getfilesystemencoding())) for path in paths] + if sub_command == u"add": + try: + with closing(DropboxCommand(timeout=None)) as dc: + try: + result = dc.ignore_set_add(paths=absolute_paths) + if result[u"ignored"]: + console_print(u"Excluded: ") + lines = [relpath(path) for path in result[u"ignored"]] + for line in lines: + console_print(unicode(line)) + except KeyError: + console_print(u"Couldn't add ignore path: daemon isn't responding") + except DropboxCommand.CommandError, e: + if e.args[0].startswith(u"No command exists by that name"): + console_print(u"This version of the client does not support this command.") + else: + console_print(u"Couldn't get ignore set: " + str(e)) + except DropboxCommand.BadConnectionError, e: + console_print(u"Dropbox isn't responding! [%s]" % e) + except DropboxCommand.EOFError: + console_print(u"Dropbox daemon stopped.") + except DropboxCommand.CouldntConnectError, e: + console_print(u"Dropbox isn't running!") + elif sub_command == u"remove": + try: + with closing(DropboxCommand(timeout=None)) as dc: + try: + result = dc.ignore_set_remove(paths=absolute_paths) + if result[u"removed"]: + console_print(u"No longer excluded: ") + lines = [relpath(path) for path in result[u"removed"]] + for line in lines: + console_print(unicode(line)) + except KeyError: + console_print(u"Couldn't remove ignore path: daemon isn't responding") + except DropboxCommand.CommandError, e: + if e.args[0].startswith(u"No command exists by that name"): + console_print(u"This version of the client does not support this command.") + else: + console_print(u"Couldn't get ignore set: " + str(e)) + except DropboxCommand.BadConnectionError, e: + console_print(u"Dropbox isn't responding! [%s]" % e) + except DropboxCommand.EOFError: + console_print(u"Dropbox daemon stopped.") + except DropboxCommand.CouldntConnectError, e: + console_print(u"Dropbox isn't running!") + else: + console_print(exclude.__doc__, linebreak=False) + return + else: + console_print(exclude.__doc__, linebreak=False) + return + +@command +def start(argv): + u"""start dropboxd +dropbox start [-i] + +Starts the dropbox daemon, dropboxd. If dropboxd is already running, this will do nothing. + +options: + -i --install auto install dropboxd if not available on the system +""" + + should_install = "-i" in argv or "--install" in argv + + # first check if dropbox is already running + if is_dropbox_running(): + if not grab_link_url_if_necessary(): + console_print(u"Dropbox is already running!") + return + + console_print(u"Starting Dropbox...", linebreak=False) + console_flush() + if not start_dropbox(): + if not should_install: + console_print() + console_print(u"The Dropbox daemon is not installed!") + console_print(u"Run \"dropbox start -i\" to install the daemon") + return + + # install dropbox!!! + try: + download() + except: + pass + else: + if GUI_AVAILABLE: + start_dropbox() + console_print(u"Done!") + else: + if start_dropbox(): + if not grab_link_url_if_necessary(): + console_print(u"Done!") + else: + if not grab_link_url_if_necessary(): + console_print(u"Done!") + + +def can_reroll_autostart(): + return u".config" in os.listdir(os.path.expanduser(u'~')) + +def reroll_autostart(should_autostart): + home_dir = os.path.expanduser(u'~') + contents = os.listdir(home_dir) + + # UBUNTU + if u".config" in contents: + autostart_dir = os.path.join(home_dir, u".config", u"autostart") + autostart_link = os.path.join(autostart_dir, u"dropbox.desktop") + if should_autostart: + if os.path.exists(DESKTOP_FILE): + if not os.path.exists(autostart_dir): + os.makedirs(autostart_dir) + shutil.copyfile(DESKTOP_FILE, autostart_link) + elif os.path.exists(autostart_link): + os.remove(autostart_link) + + + +@command +def autostart(argv): + u"""automatically start dropbox at login +dropbox autostart [y/n] + +options: + n dropbox will not start automatically at login + y dropbox will start automatically at login (default) + +Note: May only work on current Ubuntu distributions. +""" + if len(argv) != 1: + console_print(''.join(autostart.__doc__.split('\n', 1)[1:]).decode('ascii')) + return + + s = argv[0].lower() + if s.startswith('y') or s.startswith('-y'): + should_autostart = True + elif s.startswith('n') or s.startswith('-n'): + should_autostart = False + else: + should_autostart = None + + if should_autostart is None: + console_print(autostart.__doc__,linebreak=False) + else: + reroll_autostart(should_autostart) + +@command +def help(argv): + u"""provide help +dropbox help [COMMAND] + +With no arguments, print a list of commands and a short description of each. With a command, print descriptive help on how to use the command. +""" + if not argv: + return usage(argv) + for command in commands: + if command == argv[0]: + console_print(commands[command].__doc__.split('\n', 1)[1].decode('ascii')) + return + for alias in aliases: + if alias == argv[0]: + console_print(aliases[alias].__doc__.split('\n', 1)[1].decode('ascii')) + return + console_print(u"unknown command '%s'" % argv[0], f=sys.stderr) + +def usage(argv): + console_print(u"Dropbox command-line interface\n") + console_print(u"commands:\n") + console_print(u"Note: use dropbox help <command> to view usage for a specific command.\n") + out = [] + for command in commands: + out.append((command, commands[command].__doc__.splitlines()[0])) + spacing = max(len(o[0])+3 for o in out) + for o in out: + console_print(" %-*s%s" % (spacing, o[0], o[1])) + console_print() + +def main(argv): + global commands + + # now we need to find out if one of the commands are in the + # argv list, and if so split the list at the point to + # separate the argv list at that point + cut = None + for i in range(len(argv)): + if argv[i] in commands or argv[i] in aliases: + cut = i + break + + if cut == None: + usage(argv) + os._exit(0) + return + + # lol no options for now + globaloptionparser = optparse.OptionParser() + globaloptionparser.parse_args(argv[0:i]) + + # now dispatch and run + result = None + if argv[i] in commands: + result = commands[argv[i]](argv[i+1:]) + elif argv[i] in aliases: + result = aliases[argv[i]](argv[i+1:]) + + # flush, in case output is rerouted to a file. + console_flush() + + # done + return result + +if __name__ == "__main__": + ret = main(sys.argv) + if ret is not None: + sys.exit(ret) |