326 lines
8.7 KiB
Python
326 lines
8.7 KiB
Python
#!/usr/bin/env python
|
|
import argparse, sys, os, subprocess, time, re, json
|
|
from subprocess import call, Popen, PIPE, STDOUT
|
|
import readline
|
|
import glob
|
|
from io import StringIO
|
|
try:
|
|
from tabulate import tabulate
|
|
except ImportError:
|
|
print("Install tabulate with: pip install --user tabulate")
|
|
def tabulate(table, headers):
|
|
value = []
|
|
value.append("\t".join(headers))
|
|
for row in table:
|
|
value.append("\t".join([str(c) for c in row]))
|
|
value.append("\n\nGet nicer tables by installing 'tabulate' package!\n")
|
|
return "\n".join(value)
|
|
|
|
ROOTURL="{{ rooturl }}"
|
|
SHARE="{{ name }}"
|
|
TOKEN="{{ token }}"
|
|
|
|
|
|
class Completer(object):
|
|
|
|
def __init__(self, choices = []):
|
|
self.choices = choices
|
|
self.space = re.compile('.*\s+$', re.M)
|
|
|
|
def _listdir(self, path):
|
|
"List directory 'root' appending the path separator to subdirs."
|
|
files = []
|
|
for name in os.listdir(path):
|
|
file_path = os.path.join(path, name)
|
|
if os.path.isdir(file_path):
|
|
name += os.sep
|
|
files.append(name)
|
|
return files
|
|
|
|
def _complete_path(self, path=None):
|
|
"Perform completion of filesystem path."
|
|
if not path:
|
|
return self._listdir('.')
|
|
path = os.path.expanduser(path)
|
|
dirname, rest = os.path.split(path)
|
|
tmp = dirname if dirname else '.'
|
|
res = [os.path.join(dirname, p)
|
|
for p in self._listdir(tmp) if p.startswith(rest)]
|
|
# more than one match, or single match which does not exist (typo)
|
|
if len(res) > 1 or not os.path.exists(path):
|
|
return res
|
|
# resolved to a single directory, so return list of files below it
|
|
if os.path.isdir(path):
|
|
return [os.path.join(path, p) for p in self._listdir(path)]
|
|
# exact file match terminates this completion
|
|
return [path + ' ']
|
|
|
|
|
|
def complete(self, text, state):
|
|
"Generic readline completion entry point."
|
|
buffer = readline.get_line_buffer()
|
|
if len(self.choices) == 0:
|
|
return (self._complete_path(buffer) + [None])[state]
|
|
|
|
# show all commands
|
|
if len(buffer) == 0:
|
|
return [c + ' ' for c in self.choices][state]
|
|
# resolve command to the implementation function
|
|
cmd = buffer.strip()
|
|
results = [c + ' ' for c in self.choices if c.startswith(cmd)] + [None]
|
|
return results[state]
|
|
|
|
|
|
def download_file(file, opts):
|
|
print("Download " + file['name'])
|
|
cmd = [
|
|
'curl','--create-dirs',
|
|
'-o', file['name'],
|
|
'%s%s/%s/%s/%s'%(
|
|
opts.rooturl,
|
|
"download",
|
|
opts.share,
|
|
opts.token,
|
|
file['url']
|
|
),
|
|
]
|
|
p = Popen(
|
|
cmd,
|
|
stderr = PIPE,
|
|
)
|
|
for char in iter(lambda: p.stderr.read(1), ''):
|
|
if not char:
|
|
return
|
|
sys.stderr.write(char)
|
|
sys.stderr.flush()
|
|
return
|
|
|
|
|
|
def menu(opts):
|
|
commands = [
|
|
'Download',
|
|
'Upload'
|
|
]
|
|
print_title("Main menu")
|
|
for i,command in enumerate(commands):
|
|
print(" %d. %s"%( i+1, command, ))
|
|
comp = Completer(choices = ["1","2"])
|
|
readline.set_completer(comp.complete)
|
|
print("\n[Empty to exit]")
|
|
choice = user_input("Number of action: ").strip()
|
|
if choice == "1":
|
|
menu_download(opts)
|
|
if choice == "2":
|
|
menu_upload(opts)
|
|
if choice == "":
|
|
sys.exit(0)
|
|
|
|
|
|
def menu_download(opts):
|
|
while True:
|
|
print_title("Download files")
|
|
files = json.loads(run_command("file/details", opts))
|
|
file_table = []
|
|
for f in files:
|
|
file_table.append((
|
|
f['name'],
|
|
float(f['size'].replace(",","")),
|
|
f['mtime']
|
|
))
|
|
print(tabulate(file_table, headers = ("Name", "Size [Mb]", "Modified")))
|
|
name_list = [x['name'] for x in files]
|
|
comp = Completer(choices = name_list)
|
|
# we want to treat '/' as part of a word, so override the delimiters
|
|
readline.set_completer(comp.complete)
|
|
print("\n[Empty to return, * globs]")
|
|
choice = user_input('Download file: ').strip()
|
|
if choice == "":
|
|
return
|
|
if "*" in choice:
|
|
choice = choice.replace('*','.*')
|
|
choice_re = re.compile(choice)
|
|
choices = [i for i,x in enumerate(name_list) if choice_re.match(x)]
|
|
else:
|
|
if choice not in name_list:
|
|
print("No such file")
|
|
continue
|
|
choices = [ name_list.index(choice) ]
|
|
for choice in choices:
|
|
download_file(files[choice], opts)
|
|
|
|
|
|
def menu_upload(opts):
|
|
while True:
|
|
print_title("Upload")
|
|
files = sorted(os.listdir("."))
|
|
file_table = []
|
|
for f in files:
|
|
if f.startswith("."):
|
|
continue
|
|
if os.path.isfile(f):
|
|
file_size = round(float(os.path.getsize(f)) / 1024 / 1024, 2)
|
|
else:
|
|
file_size = "[DIR]"
|
|
f += "/"
|
|
file_table.append((f, file_size))
|
|
print(tabulate(file_table, headers = ("Name", "Size [Mb]")))
|
|
|
|
comp = Completer(choices = [])
|
|
# we want to treat '/' as part of a word, so override the delimiters
|
|
|
|
readline.set_completer(comp.complete)
|
|
print("\n[Empty to return, * globs]")
|
|
choice = user_input('Upload file: ').strip()
|
|
if choice == "":
|
|
return
|
|
if "*" in choice:
|
|
choices = glob.glob(choice)
|
|
else:
|
|
if not os.path.exists(choice):
|
|
print("No such file")
|
|
continue
|
|
choices = [ choice ]
|
|
for choice in choices:
|
|
upload_file(choice, opts)
|
|
|
|
|
|
def parse_options():
|
|
parser = argparse.ArgumentParser(description='Flees client')
|
|
parser.add_argument('-s', action="store", type=int, dest="split", default = 32,
|
|
help = "Split size in megabytes [%(default)s]"
|
|
)
|
|
parser.add_argument('--rooturl', action="store", dest="rooturl",
|
|
default = ROOTURL,
|
|
help = "Address of Flees server [%(default)s]"
|
|
)
|
|
parser.add_argument('--share', action="store", dest="share",
|
|
default = SHARE,
|
|
help = "Name of Flees share [%(default)s]"
|
|
)
|
|
parser.add_argument('--token', action="store", dest="token",
|
|
default = TOKEN,
|
|
help = "API token for the share [%(default)s]"
|
|
)
|
|
return parser.parse_args()
|
|
|
|
|
|
def print_title(title):
|
|
status = "Share: %s, Server: %s"%(
|
|
opts.share,
|
|
opts.rooturl
|
|
)
|
|
pad = " "*((len(status) - len(title))/2)
|
|
print("\n".join((
|
|
"",
|
|
"="*len(status),
|
|
status,
|
|
pad + title + pad,
|
|
"="*len(status)
|
|
)))
|
|
|
|
|
|
def read_output(stream):
|
|
for char in iter(lambda: stream.read(1), ''):
|
|
if not char:
|
|
break
|
|
sys.stderr.write(char)
|
|
sys.stderr.flush()
|
|
stream.close()
|
|
|
|
|
|
def run_command(command, opts):
|
|
p = Popen(
|
|
[
|
|
'curl','-s',
|
|
'%s%s/%s/%s'%(opts.rooturl, command, opts.share, opts.token)
|
|
],
|
|
stdout=PIPE,
|
|
stderr=PIPE
|
|
)
|
|
stdout_data, stderr_data = p.communicate()
|
|
return stdout_data
|
|
|
|
|
|
def run_loop(opts):
|
|
try:
|
|
while True:
|
|
menu(opts)
|
|
except KeyboardInterrupt:
|
|
print("")
|
|
return
|
|
|
|
|
|
def upload_file(file, opts):
|
|
print("Upload "+file)
|
|
p = Popen(
|
|
"curl -s %s%s/%s/%s | python -u - -s %d %s"%(
|
|
opts.rooturl,
|
|
"script/upload_split",
|
|
opts.share,
|
|
opts.token,
|
|
opts.split,
|
|
file
|
|
),
|
|
stdout = PIPE,
|
|
shell = True
|
|
)
|
|
read_output(p.stdout)
|
|
return
|
|
|
|
|
|
cmd1 = [
|
|
'curl','-s',
|
|
'%s%s/%s/%s'%(
|
|
opts.rooturl,
|
|
"script/upload_split",
|
|
opts.share,
|
|
opts.token,
|
|
),
|
|
]
|
|
cmd2 = [
|
|
'python', '-',
|
|
'-s', str(opts.split),
|
|
file
|
|
]
|
|
p1 = Popen(
|
|
cmd1,
|
|
stderr = PIPE,
|
|
stdout = PIPE,
|
|
)
|
|
script, stderr = p1.communicate()
|
|
p2 = Popen(
|
|
cmd2,
|
|
stdin = PIPE,
|
|
stdout = PIPE,
|
|
stderr = PIPE,
|
|
bufsize = 1
|
|
)
|
|
p2.stdin.write(script)
|
|
p2.stdin.close()
|
|
for char in iter(lambda: p2.stderr.read(1), ''):
|
|
if not char:
|
|
break
|
|
sys.stderr.write(char)
|
|
sys.stderr.flush()
|
|
|
|
return
|
|
|
|
|
|
def user_input(arg):
|
|
try:
|
|
return raw_input(arg)
|
|
except NameError:
|
|
return input(arg)
|
|
|
|
|
|
def write_input(stream, string):
|
|
stream.write(string)
|
|
stream.close()
|
|
|
|
|
|
if __name__ == "__main__":
|
|
readline.set_completer_delims(' \t\n;')
|
|
readline.parse_and_bind("tab: complete")
|
|
opts = parse_options()
|
|
run_loop(opts)
|