class DropBoxStorage(Storage):
"""DropBox Storage class for Django pluggable storage system."""
def generate_url(self, name):
url = self.client.share(name, name)
url = url['url']
f = request.urlopen(url)
path = f.geturl()
return re.sub('www.dropbox.com','dl.dropboxusercontent.com', path)
def url(self, name):
return name #
def __init__(self, oauth2_access_token=setting('DROPBOX_OAUTH2_TOKEN')):
if oauth2_access_token is None:
raise ImproperlyConfigured("You must configure a token auth at"
"'settings.DROPBOX_OAUTH2_TOKEN'.")
self.client = DropboxClient(oauth2_access_token)
def delete(self, name):
self.client.file_delete(name)
def exists(self, name):
response = self.client.search('/', name, file_limit=1)
return bool(response)
def listdir(self, path):
directories, files = [], []
metadata = self.client.metadata(path)
for entry in metadata['contents']:
if entry['is_dir']:
directories.append(entry['path'])
else:
files.append(entry['path'])
return directories, files
def size(self, name):
metadata = self.client.metadata(name)
return metadata['bytes']
def modified_time(self, name):
metadata = self.client.metadata(name)
mod_time = datetime.strptime(metadata['modified'], DATE_FORMAT)
return mod_time
def accessed_time(self, name):
metadata = self.client.metadata(name)
acc_time = datetime.strptime(metadata['client_mtime'], DATE_FORMAT)
return acc_time
def _open(self, name, mode='rb'):
remote_file = DropBoxFile(name, self)
return remote_file
def _save(self, name, content):
self.client.put_file(name, content)
return name
def _read(self, name, num_bytes=None):
data = self.client.get_file(name)
return data.read(num_bytes)
class DropboxStorage(Storage):
def __init__(self):
flow = DropboxOAuth2FlowNoRedirect(settings.APP_KEY,
settings.APP_SECRET)
#authorize_url = flow.start()
#access_token, user_id = flow.finish(settings.ACCESS_TOKEN)
self.client = DropboxClient(settings.ACCESS_TOKEN)
def _open(self, name, mode='rb'):
return File(name, mode=mode)
def _save(self, name, content):
response = self.client.put_file(name, content, overwrite=True)
return response['path']
def delete(self, name):
self.client.file_delete(name)
def exists(self, name):
try:
self.client.metadata(name)
except ErrorResponse as e:
if e.status == 404:
return False
raise e
return True
def size(self, name):
return self.client.metadata(name)['bytes']
def url(self, name):
return self.client.metadata(name)
class DropBoxStorage(Storage):
"""DropBox Storage class for Django pluggable storage system."""
def __init__(self, oauth2_access_token=setting('DROPBOX_OAUTH2_TOKEN')):
if oauth2_access_token is None:
raise ImproperlyConfigured("You must configure a token auth at"
"'settings.DROPBOX_OAUTH2_TOKEN'.")
self.client = DropboxClient(oauth2_access_token)
def delete(self, name):
self.client.file_delete(name)
def exists(self, name):
try:
return bool(self.client.metadata(name))
except ErrorResponse:
return False
def listdir(self, path):
directories, files = [], []
metadata = self.client.metadata(path)
for entry in metadata['contents']:
if entry['is_dir']:
directories.append(entry['path'])
else:
files.append(entry['path'])
return directories, files
def size(self, name):
metadata = self.client.metadata(name)
return metadata['bytes']
def modified_time(self, name):
metadata = self.client.metadata(name)
mod_time = datetime.strptime(metadata['modified'], DATE_FORMAT)
return mod_time
def accessed_time(self, name):
metadata = self.client.metadata(name)
acc_time = datetime.strptime(metadata['client_mtime'], DATE_FORMAT)
return acc_time
def url(self, name):
media = self.client.media(name)
return media['url']
def _open(self, name, mode='rb'):
remote_file = DropBoxFile(name, self)
return remote_file
def _save(self, name, content):
self.client.put_file(name, content)
return name
def _read(self, name, num_bytes=None):
data = self.client.get_file(name)
return data.read(num_bytes)
def get(self):
client = DropboxClient(self.get_secure_cookie("access_token"))
try:
client.file_delete('/blog.db')
client.file_delete('/settings.py')
except:
print("Can't find any backup")
finally:
with open(os.path.join(os.path.abspath(os.path.dirname("__file__")), 'blog.db'), 'rb') as f:
response = client.put_file('/blog.db', f)
with open(os.path.join(os.path.abspath(os.path.dirname("__file__")), 'settings.py'), 'rb') as f:
response = client.put_file('/settings.py', f)
self.redirect("/admin/dropbox?message=Backup successfully")
def _rotate(self, client: DropboxClient, files: list):
""" Rotate Dropbox in order to save storage.
"""
total_size = sum(item['size'] for item in files)
files_history = sorted(files, key=itemgetter('modified'))
for file in files_history:
if total_size < self.max_size:
break
try:
client.file_delete(file['file'])
print("{} was deleted from Dropbox.".format(file['file']))
total_size -= file['size']
except (MaxRetryError, ErrorResponse):
pass
def get(self):
client = DropboxClient(self.get_secure_cookie("access_token"))
try:
client.file_delete('/blog.db')
client.file_delete('/settings.py')
except:
print("Can't find any backup")
finally:
with open(
os.path.join(os.path.abspath(os.path.dirname("__file__")),
'blog.db'), 'rb') as f:
response = client.put_file('/blog.db', f)
with open(
os.path.join(os.path.abspath(os.path.dirname("__file__")),
'settings.py'), 'rb') as f:
response = client.put_file('/settings.py', f)
self.redirect("/admin/dropbox?message=Backup successfully")
def post(self):
session = SessionData.get(self.request.get('session_key'))
conference_data = ConferenceData.get(self.request.get('conf_key'))
db_path = self.request.get('db_path')
try:
client = DropboxClient(conference_data.dbox_access_token, "en_US", rest_client=None)
logging.info('DB client created %s' % client)
except:
logging.info("DB Client was not created, access token is %s"% conference_data.dbox_access_token)
return None
try:
client.file_delete(session.dbox_path)
logging.info('File %s was deleted' % session.dbox_path)
except:
logging.error('File %s not deleted'% session.dbox_path)
return
session.dbox_path = None
data_cache.set('%s-sessions'% session.module, None)
return
class DropboxSyncClient:
def __init__(self, oauth2_access_token):
self.access_token = oauth2_access_token
self._client = DropboxClient(oauth2_access_token)
def upload_file(self, dropbox_file_path, local_file_path, replace=False):
f = open(local_file_path, 'rb')
response = self._client.put_file(dropbox_file_path, f, replace)
return 1, response['path']
def generate_public_url(self, dropbox_file_path):
return self._client.share(dropbox_file_path)['url']
def delete_file(self, dropbox_file_path):
self._client.file_delete(dropbox_file_path)
return 1, None
def update_local_to_cloud(self, dropbox_file_path, local_file_path):
return 1, self.upload_file(dropbox_file_path, local_file_path, replace=True)
def update_cloud_to_local(self, dropbox_file_path, local_file_path):
try:
try:
os.makedirs(os.path.dirname(local_file_path))
except Exception as e:
pass
open(local_file_path, 'wb').write(self._client.get_file(dropbox_file_path).read())
return 1, None
except Exception as e:
print e
return 1, None
def get_file_list(self, dropbox_folder_path):
folder_metadata = self._client.metadata(dropbox_folder_path)
return [content['path'] for content in folder_metadata['contents']]
def set_access_token(self, access_token):
self._client = DropboxClient(access_token)
def get_remaining_space(self):
quota_info = self._client.account_info()['quota_info']
return quota_info['total'] - (quota_info['shared'] + quota_info['normal'])
def oauth_callback():
'''Callback function for when the user returns from OAuth.'''
access_token, uid, extras = get_flow().finish(request.args)
session['uid'] = uid
# Extract and store the access token for this user
redis_client.hset('tokens', uid, access_token)
# Create folder tree, put random easter eggs in it.
# OAuth token for the user
token = redis_client.hget('tokens', uid)
client = DropboxClient(token)
# Set up the Easter hunt area!
try:
client.file_delete('/Yard')
except Exception, e:
pass
class DropBox(clouddrive.CloudDrive):
name = "DropBox"
def __init__(self, access_token):
self.client = DropboxClient(access_token)
self.access_token = access_token
clouddrive.CloudDrive.__init__(self, access_token)
@staticmethod
def auth():
#app_key = 'knbyx2adg14kkn5'
#app_secret = 'kh3ulgqry8jffqp'
app_key = 'eif0l7bgnpb06di'
app_secret = 'qa02jhdo4jrwaid'
global Auth_DROPMytoken
global Auth_Drop_Running_true
def keep_running():
global Auth_Drop_Running_true
return Auth_Drop_Running_true
class AuthHandler(BaseHTTPServer.BaseHTTPRequestHandler):
def do_HEAD(s):
s.send_response(200)
s.send_header("Content-type", "text/html")
s.end_headers()
def do_GET(s):
s.send_response(200)
s.send_header("Content-type", "text/html")
s.end_headers()
if s.path.find("code=") != -1:
global Auth_DROPMytoken
global Auth_Drop_Running_true
Auth_DROPMytoken = s.path
Auth_Drop_Running_true = False
s.wfile.write("ok see command line")
return
class MYrequest:
def __init__(self, url):
self.url = url
def get(self, mystring):
if self.url.find(mystring) == -1:
return
item = self.url.split(mystring + "=")[1]
if item.find("&") != -1:
item = item.split("&")[0]
return urllib.unquote(item).decode()
redirect_url = "http://localhost:8787"
my_session = {}
Auth_Drop_Running_true = True
flow = DropboxOAuth2Flow(app_key, app_secret, redirect_url, my_session, "dropbox-auth-csrf-token")
authorize_url = flow.start()
webbrowser.open(authorize_url)
try:
httpd = BaseHTTPServer.HTTPServer(("", 8787), AuthHandler)
while keep_running():
httpd.handle_request()
except KeyboardInterrupt:
pass
httpd.server_close()
token, user_id, url_state = flow.finish(MYrequest(Auth_DROPMytoken))
clouddrive.CloudDrive.access_token = token
return token
def read(self, filename):
try:
data=[]
with self.client.get_file(filename) as f:
data+=f.read()
except:
return -1
return ''.join(data)
def write(self, filename, data):
try:
response = self.client.put_file(filename, data,True)
except:
return -1
return 1
def mkdir(self, dirname):
try:
self.client.file_create_folder(dirname)
except:
return -1
return 1
def delete(self, filename):
try:
self.client.file_delete(filename)
except:
return -1
return 1
def capacity(self):
try:
a=self.client.account_info()["quota_info"]
except:
return -1
return a["quota"]-a["shared"]-a["normal"]
def listing (self, path="/") :
lists=self.client.metadata(path)
filelist=[]
for x in lists["contents"] :
filelist.append((x['path'],x['is_dir']))
return filelist
class DropboxStorage(Storage):
"""
A storage class providing access to resources in a Dropbox Public folder.
"""
def __init__(self, location='/Public'):
session = DropboxSession(CONSUMER_KEY, CONSUMER_SECRET, ACCESS_TYPE, locale=None)
session.set_token(ACCESS_TOKEN, ACCESS_TOKEN_SECRET)
self.client = DropboxClient(session)
self.account_info = self.client.account_info()
self.location = location
self.base_url = 'http://dl.dropbox.com/u/{uid}/'.format(**self.account_info)
def _client_metadata(self, path):
"""
Get client metadata from cache based on the DROPBOX_CACHE setting.
"""
if DROPBOX_CACHE and isinstance(DROPBOX_CACHE, int):
cache_key = _cache_key(path)
meta = cache.get(cache_key, None)
if not meta:
meta = self.client.metadata(path)
cache.set(cache_key, meta, DROPBOX_CACHE)
return meta
return self.client.metadata(path)
def _get_abs_path(self, name):
return os.path.realpath(os.path.join(self.location, name))
def _open(self, name, mode='rb'):
name = self._get_abs_path(name)
remote_file = DropboxFile(name, self, mode=mode)
return remote_file
def _save(self, name, content):
name = self._get_abs_path(name)
directory = os.path.dirname(name)
if not self.exists(directory) and directory:
self.client.file_create_folder(directory)
response = self._client_metadata(directory)
if not response['is_dir']:
raise IOError("%s exists and is not a directory." % directory)
abs_name = os.path.realpath(os.path.join(self.location, name))
self.client.put_file(abs_name, content)
_clear_cache(abs_name)
return name
def delete(self, name):
name = self._get_abs_path(name)
self.client.file_delete(name)
_clear_cache(name)
def exists(self, name):
name = self._get_abs_path(name)
try:
metadata = self._client_metadata(name)
if metadata.get('is_deleted'):
return False
except ErrorResponse as e:
if e.status == 404: # not found
return False
raise e
return True
def listdir(self, path):
path = self._get_abs_path(path)
response = self._client_metadata(path)
directories = []
files = []
for entry in response.get('contents', []):
if entry['is_dir']:
directories.append(os.path.basename(entry['path']))
else:
files.append(os.path.basename(entry['path']))
return directories, files
def size(self, name):
path = os.path.realpath(os.path.join(self.location, name))
return self._client_metadata(path)['bytes']
def url(self, name):
if name.startswith(self.location):
name = name[len(self.location) + 1:]
if self.base_url is None:
raise ValueError("This file is not accessible via a URL.")
return urlparse.urljoin(self.base_url, filepath_to_uri(name))
def get_available_name(self, name):
"""
Returns a filename that's free on the target storage system, and
available for new content to be written to.
"""
name = self._get_abs_path(name)
dir_name, file_name = os.path.split(name)
file_root, file_ext = os.path.splitext(file_name)
# If the filename already exists, add an underscore and a number (before
# the file extension, if one exists) to the filename until the generated
# filename doesn't exist.
count = itertools.count(1)
while self.exists(name):
# file_ext includes the dot.
name = os.path.join(dir_name, "%s_%s%s" % (file_root, count.next(), file_ext))
return name
class DropboxAPI(StorageAPI, AppendOnlyLog):
"dropbox@auth : dropbox.com account with auth info"
def __init__(self):
from params import AUTH_DIR
authdir = AUTH_DIR
self.auth_file = os.path.join(authdir, 'dropbox.auth')
try:
with open(self.auth_file, 'r') as file:
ACCESS_TOKEN = file.readline().rstrip()
USER_ID = file.readline().rstrip()
except IOError:
ACCESS_TOKEN, USER_ID = self._authorize()
self.client = DropboxClient(ACCESS_TOKEN)
def sid(self):
return util.md5("dropbox") % 10000
def copy(self):
return DropboxAPI()
def _authorize(self):
dbg.info('Request access token from Dropbox')
flow = DropboxOAuth2FlowNoRedirect(APP_KEY, APP_SECRET)
authorize_url = flow.start()
# print 'Open auth url:', authorize_url
#browser = webdriver.PhantomJS(service_log_path=os.path.join(tempfile.gettempdir(), 'ghostdriver.log'))
#browser = webdriver.PhantomJS(service_log_path=os.path.join(tempfile.gettempdir(), 'ghostdriver.log'), service_args=['--ignore-ssl-errors=true', '--ssl-protocol=tlsv1'])
# Change to rely on browser
print(
"We need to authorize access to Dropbox. Please visit the following URL and authorize the access:"
)
print(authorize_url)
print("")
code = raw_input("Input the code you got: ").strip()
#code = #raw_input("Enter the authorization code here: ").strip()
access_token, user_id = flow.finish(code)
with open(self.auth_file, 'w') as file:
file.write(access_token + "\n")
file.write(user_id + "\n")
dbg.info('Authentication successful')
return (access_token, user_id)
# return: list of file paths
def listdir(self, path):
dic = self.client.metadata(path)
lst = map(lambda x: x["path"], dic["contents"])
lst = map(lambda x: x.split("/")[-1], lst)
return lst
def exists(self, path):
try:
dic = self.client.metadata(path)
if (dic.has_key("is_deleted") and dic["is_deleted"]): return False
return True
except:
return False
def get(self, path):
"""Get the file content
Args:
path: string
Returns:
content: string
"""
conn = self.client.get_file(path)
content = conn.read()
conn.close()
return content
def get_file_rev(self, path, rev):
# get file of a previous version with rev hash_id
content = None
try:
conn = self.client.get_file(path, rev=rev)
content = conn.read()
conn.close()
except ErrorResponse as detail:
#print "[get_file_rev] File doesn't exist", detail
return None
return content
def put(self, path, content):
"""Upload the file
Args:
path: string
content: string, size <= 4MB
Returns: None
"""
from dropbox.rest import ErrorResponse
strobj = StringIO(content)
try:
metadata = self.client.put_file(path,
strobj,
overwrite=False,
autorename=False)
except ErrorResponse as e:
if e.status == 409:
raise ItemAlreadyExists(e.status, e.reason)
else:
raise APIError(e.status, e.reason)
return True
def putdir(self, path):
self.client.file_create_folder(path)
def update(self, path, content):
"""Update the file
Args and returns same as put
"""
strobj = StringIO(content)
metadata = self.client.put_file(path, strobj, overwrite=True)
return True
def rm(self, path):
"""Delete the file
Args:
path: string
"""
self.client.file_delete(path)
def rmdir(self, path):
self.client.file_delete(path)
def metadata(self, path):
# only for file, not dir
_md = self.client.metadata(path)
md = {}
md['size'] = _md['bytes']
md['mtime'] = util.convert_time(_md['modified'])
return md
def delta(self, path=None, cursor=None):
resp = self.client.delta(cursor=cursor, path_prefix=path)
cursor = resp['cursor']
changes = []
for entry in resp['entries']:
event = {}
if entry[1]:
# we don't care about delete event
event['path'] = entry[0]
if entry[1]['is_dir']:
event['type'] = 'folder'
else:
event['type'] = 'file'
changes.append(event)
return cursor, changes
def poll(self, path=None, cursor=None, timeout=30):
# timeout max 480
import requests
import time
from error import PollError
beg_time = time.time()
end_time = beg_time + timeout
curr_time = beg_time
url = 'https://api-notify.dropbox.com/1/longpoll_delta'
params = {}
changes = []
if path:
path = util.format_path(path)
if not cursor:
cursor, _ = self.delta(path)
curr_time = time.time()
while True:
params['cursor'] = cursor
params['timeout'] = max(30, int(end_time -
curr_time)) # minimum 30 second
resp = requests.request('GET', url, params=params)
obj = resp.json()
if 'error' in obj:
raise PollError(resp.status_code, resp.text)
if obj['changes']:
cursor, _delta = self.delta(path, cursor)
changes.extend(_delta)
if changes:
break
curr_time = time.time()
if curr_time > end_time:
break
return cursor, changes
def init_log(self, path):
if not self.exists(path):
self.put(path, '')
def reset_log(self, path):
if self.exists(path):
self.rm(path)
def append(self, path, msg):
self.update(path, msg)
def get_logs(self, path, last_clock):
length = 5
# latest revision comes first
revisions = self.client.revisions(path, rev_limit=length)
if not revisions:
return [], None
new_logs = []
new_clock = revisions[0]['rev']
end = False # if reach to end
while True:
for metadata in revisions:
if last_clock and metadata['rev'] == last_clock:
end = True
break
if end: break
if len(revisions) < length: break
# still have logs unread, double the length
length *= 2
revisions = self.client.revisions(path, rev_limit=length)
# download the content of unseen rev
for metadata in revisions:
if last_clock and metadata['rev'] == last_clock:
break
if 'is_deleted' in metadata and metadata['is_deleted']: continue
msg = self.get_file_rev(path, metadata['rev'])
if len(msg) > 0:
new_logs.insert(0, msg)
return new_logs, new_clock
def __msg_index(self, fn):
return eval(fn[3:])
def init_log2(self, path):
if not self.exists(path):
self.putdir(path)
def append2(self, path, msg):
path = util.format_path(path)
lst = sorted(self.listdir(path))
if lst:
index = self.__msg_index(lst[-1]) + 1
else:
index = 0
while True:
fn = 'msg%d' % index
fpath = path + '/' + fn
try:
self.put(fpath, msg)
except ItemAlreadyExists:
index += 1
else:
break
def get_logs2(self, path, last_clock):
path = util.format_path(path)
lst = self.listdir(path)
if not lst:
return [], None
srt = {}
for fn in lst:
srt[self.__msg_index(fn)] = fn
lst = [srt[i] for i in sorted(srt.keys(), reverse=True)]
new_logs = []
new_clock = self.__msg_index(lst[0])
for fn in lst:
if last_clock == None and self.__msg_index(fn) == last_clock: break
msg = self.get(path + '/' + fn)
new_logs.insert(0, msg)
return new_logs, new_clock
def share(self, path, target_email):
url = "https://www.dropbox.com/"
print 'Get access token from Dropbox'
print 'Open auth url:', url
browser = webdriver.PhantomJS(
service_log_path=os.path.join(tempfile.gettempdir(),
'ghostdriver.log'),
service_args=['--ignore-ssl-errors=true', '--ssl-protocol=tlsv1'])
browser.get(url)
try:
wait = WebDriverWait(browser, 30)
btn = wait.until(
EC.element_to_be_clickable(
(By.XPATH, "//div[@id='sign-in']/a")))
btn.click()
email = wait.until(
EC.element_to_be_clickable(
(By.XPATH, "//input[@id='login_email']")))
email.send_keys(raw_input("Enter your Dropbox email:"))
pwd = browser.find_element_by_xpath(
"//input[@id='login_password']")
pwd.send_keys(getpass.getpass("Enter your Dropbox password:"******"//a[text()='%s']" % path)))
target_folder.click()
wait.until(EC.title_contains("%s" % path))
share_btn = browser.find_element_by_xpath(
"//a[@id='global_share_button']")
share_btn.click()
target = wait.until(
EC.element_to_be_clickable((
By.XPATH,
"//form[@class='invite-more-form']//input[@spellcheck][@type='text']"
)))
target.send_keys(target_email)
confirm_btn = browser.find_element_by_xpath(
"//form[@class='invite-more-form']//input[@type='button'][1]")
confirm_btn.click()
except:
print(browser.title)
assert False
# print(browser.current_url)
# print(browser.page_source)
pass
logging.info(__INFOFILE__.format(cnt_add = str(len(file_to_be_added)), cnt_delete = str(len(file_to_be_removed))))
""" Is there any faster way to get multiple files from the FTP Server? """
for f in file_to_be_added:
try:
fp = cStringIO.StringIO()
nasclient.getFile(f,fp)
dropboxclient.put_file(path.join(__DROPBOXDIR__,f).replace("\\","/"),fp)
fp.close()
logging.info(__FILESUCCMSG__.format(filename = f, action = "ADD"))
except Exception as e:
logging.info(__ERRMSG3__.format(filename = f,device="Dropbox",raisemsg = str(e)))
anyerror = True
continue
for f in file_to_be_removed:
try:
dropboxclient.file_delete(path.join(__DROPBOXDIR__,f).replace("\\","/"))
logging.info(__FILESUCCMSG__.format(filename = f, action = "REMOVE"))
except Exception as e:
logging.info(__ERRMSG4__.format(filename = f,device="Dropbox",raisemsg = str(e)))
anyerror = True
continue
if anyerror:
logging.info(__SUCCWARNMSG__)
else:
logging.info(__SUCCMSG__)
class DropboxAPI(StorageAPI, AppendOnlyLog):
"dropbox@auth : dropbox.com account with auth info"
def __init__(self):
from params import AUTH_DIR
authdir = AUTH_DIR
self.auth_file = os.path.join(authdir, 'dropbox.auth')
try:
with open(self.auth_file, 'r') as file:
ACCESS_TOKEN = file.readline().rstrip()
USER_ID = file.readline().rstrip()
except IOError:
ACCESS_TOKEN, USER_ID = self._authorize()
self.client = DropboxClient(ACCESS_TOKEN)
def sid(self):
return util.md5("dropbox") % 10000
def copy(self):
return DropboxAPI()
def _authorize(self):
dbg.info('Request access token from Dropbox')
flow = DropboxOAuth2FlowNoRedirect(APP_KEY, APP_SECRET)
authorize_url = flow.start()
# print 'Open auth url:', authorize_url
#browser = webdriver.PhantomJS(service_log_path=os.path.join(tempfile.gettempdir(), 'ghostdriver.log'))
#browser = webdriver.PhantomJS(service_log_path=os.path.join(tempfile.gettempdir(), 'ghostdriver.log'), service_args=['--ignore-ssl-errors=true', '--ssl-protocol=tlsv1'])
# Change to rely on browser
print("We need to authorize access to Dropbox. Please visit the following URL and authorize the access:")
print(authorize_url)
print("")
code = raw_input("Input the code you got: ").strip()
#code = #raw_input("Enter the authorization code here: ").strip()
access_token, user_id = flow.finish(code)
with open(self.auth_file, 'w') as file:
file.write(access_token + "\n")
file.write(user_id + "\n")
dbg.info('Authentication successful')
return (access_token, user_id)
# return: list of file paths
def listdir(self, path):
dic = self.client.metadata(path)
lst = map(lambda x:x["path"], dic["contents"])
lst = map(lambda x:x.split("/")[-1], lst)
return lst
def exists(self, path):
try:
dic = self.client.metadata(path)
if(dic.has_key("is_deleted") and dic["is_deleted"]): return False
return True
except:
return False
def get(self, path):
"""Get the file content
Args:
path: string
Returns:
content: string
"""
conn = self.client.get_file(path)
content = conn.read()
conn.close()
return content
def get_file_rev(self, path, rev):
# get file of a previous version with rev hash_id
content = None
try:
conn = self.client.get_file(path, rev=rev)
content = conn.read()
conn.close()
except ErrorResponse as detail:
#print "[get_file_rev] File doesn't exist", detail
return None
return content
def put(self, path, content):
"""Upload the file
Args:
path: string
content: string, size <= 4MB
Returns: None
"""
from dropbox.rest import ErrorResponse
strobj = StringIO(content)
try:
metadata = self.client.put_file(path, strobj, overwrite=False, autorename=False)
except ErrorResponse as e:
if e.status == 409:
raise ItemAlreadyExists(e.status, e.reason)
else:
raise APIError(e.status, e.reason)
return True
def putdir(self, path):
self.client.file_create_folder(path)
def update(self, path, content):
"""Update the file
Args and returns same as put
"""
strobj = StringIO(content)
metadata = self.client.put_file(path, strobj, overwrite=True)
return True
def rm(self, path):
"""Delete the file
Args:
path: string
"""
self.client.file_delete(path)
def rmdir(self, path):
self.client.file_delete(path)
def metadata(self, path):
# only for file, not dir
_md = self.client.metadata(path)
md = {}
md['size'] = _md['bytes']
md['mtime'] = util.convert_time(_md['modified'])
return md
def delta(self, path=None, cursor=None):
resp = self.client.delta(cursor=cursor, path_prefix=path)
cursor = resp['cursor']
changes = []
for entry in resp['entries']:
event = {}
if entry[1]:
# we don't care about delete event
event['path'] = entry[0]
if entry[1]['is_dir']:
event['type'] = 'folder'
else:
event['type'] = 'file'
changes.append(event)
return cursor, changes
def poll(self, path=None, cursor=None, timeout=30):
# timeout max 480
import requests
import time
from error import PollError
beg_time = time.time()
end_time = beg_time + timeout
curr_time = beg_time
url = 'https://api-notify.dropbox.com/1/longpoll_delta'
params = {}
changes = []
if path:
path = util.format_path(path)
if not cursor:
cursor, _ = self.delta(path)
curr_time = time.time()
while True:
params['cursor'] = cursor
params['timeout'] = max(30, int(end_time - curr_time)) # minimum 30 second
resp = requests.request('GET', url, params=params)
obj = resp.json()
if 'error' in obj:
raise PollError(resp.status_code, resp.text)
if obj['changes']:
cursor, _delta = self.delta(path, cursor)
changes.extend(_delta)
if changes:
break
curr_time = time.time()
if curr_time > end_time:
break
return cursor, changes
def init_log(self, path):
if not self.exists(path):
self.put(path, '')
def reset_log(self, path):
if self.exists(path):
self.rm(path)
def append(self, path, msg):
self.update(path, msg)
def get_logs(self, path, last_clock):
length = 5
# latest revision comes first
revisions = self.client.revisions(path, rev_limit=length)
if not revisions:
return [], None
new_logs = []
new_clock = revisions[0]['rev']
end = False # if reach to end
while True:
for metadata in revisions:
if last_clock and metadata['rev'] == last_clock:
end = True
break
if end: break
if len(revisions) < length: break
# still have logs unread, double the length
length *= 2
revisions = self.client.revisions(path, rev_limit=length)
# download the content of unseen rev
for metadata in revisions:
if last_clock and metadata['rev'] == last_clock:
break
if 'is_deleted' in metadata and metadata['is_deleted']: continue
msg = self.get_file_rev(path, metadata['rev'])
if len(msg) > 0:
new_logs.insert(0, msg)
return new_logs, new_clock
def __msg_index(self, fn):
return eval(fn[3:])
def init_log2(self, path):
if not self.exists(path):
self.putdir(path)
def append2(self, path, msg):
path = util.format_path(path)
lst = sorted(self.listdir(path))
if lst:
index = self.__msg_index(lst[-1]) + 1
else:
index = 0
while True:
fn = 'msg%d' % index
fpath = path + '/' + fn
try:
self.put(fpath, msg)
except ItemAlreadyExists:
index += 1
else:
break
def get_logs2(self, path, last_clock):
path = util.format_path(path)
lst = self.listdir(path)
if not lst:
return [], None
srt = {}
for fn in lst:
srt[self.__msg_index(fn)] = fn
lst = [srt[i] for i in sorted(srt.keys(), reverse=True)]
new_logs = []
new_clock = self.__msg_index(lst[0])
for fn in lst:
if last_clock == None and self.__msg_index(fn) == last_clock: break
msg = self.get(path + '/' + fn)
new_logs.insert(0, msg)
return new_logs, new_clock
def share(self, path, target_email):
url = "https://www.dropbox.com/"
print 'Get access token from Dropbox'
print 'Open auth url:', url
browser = webdriver.PhantomJS(service_log_path=os.path.join(tempfile.gettempdir(), 'ghostdriver.log'), service_args=['--ignore-ssl-errors=true', '--ssl-protocol=tlsv1'])
browser.get(url)
try:
wait = WebDriverWait(browser, 30)
btn = wait.until(EC.element_to_be_clickable((By.XPATH, "//div[@id='sign-in']/a")))
btn.click()
email = wait.until(EC.element_to_be_clickable((By.XPATH, "//input[@id='login_email']")))
email.send_keys(raw_input("Enter your Dropbox email:"))
pwd = browser.find_element_by_xpath("//input[@id='login_password']")
pwd.send_keys(getpass.getpass("Enter your Dropbox password:"******"//a[text()='%s']" % path)))
target_folder.click()
wait.until(EC.title_contains("%s" % path))
share_btn = browser.find_element_by_xpath("//a[@id='global_share_button']")
share_btn.click()
target = wait.until(EC.element_to_be_clickable((By.XPATH, "//form[@class='invite-more-form']//input[@spellcheck][@type='text']")))
target.send_keys(target_email)
confirm_btn = browser.find_element_by_xpath("//form[@class='invite-more-form']//input[@type='button'][1]")
confirm_btn.click()
except:
print(browser.title)
assert False
# print(browser.current_url)
# print(browser.page_source)
pass
class DropboxNoteProvider(RemoteNoteProvider):
__DAY_ONE_EXTENSION= ".doentry"
def __init__(self, accessToken, folder, proxyHost=None, proxyPort=None, proxyUser=None, proxyPassword=None):
self.__token= accessToken
self.__notesPath= folder + "/entries"
self.__removedNotesPath= self.__notesPath + "/deleted"
self.__photosPath= folder + "/photos"
self.__removedPhotosPath= self.__photosPath + "/deleted"
self.__client= DropboxClient(self.__token, rest_client=_restClient(proxyHost, proxyPort, proxyUser, proxyPassword))
self.__notesCache= {}
self.__dayOneFlavor= folder == SyncFolder.DayOne
def requiresReverseUpdate(self):
return True
@online
@expires
def sync(self):
notes= self.__list(self.__notesPath, False)
removedNotes= self.__list(self.__removedNotesPath, True)
#Clean inconsistent files
for uuid in list(notes.keys()):
if uuid in removedNotes:
if removedNotes[uuid].lastModified >= notes[uuid].lastModified:
self.__client.file_delete(self.__notePath(uuid))
if notes[uuid].hasPhoto:
self.__client.file_delete(self.__photoPath(uuid))
del notes[uuid]
else:
self.__client.file_delete(self.__removedNotePath(uuid))
del removedNotes[uuid]
notes.update(removedNotes)
self.__notesCache= notes
return notes
@online
@expires
def get(self, uuid):
response, metadata= self.__client.get_file_and_metadata(self.__notePath(uuid))
with response:
note= unmarshalNote(response.read(), getLastModified(metadata))
if uuid not in self.__notesCache or self.__notesCache[uuid].hasPhoto:
try:
with self.__client.get_file(self.__photoPath(uuid)) as response:
note.photo= response.read()
except ErrorResponse as e:
if e.status == 404: #Photo does not exist
pass
else:
raise e
return renderHtml(note)
@online
@expires
def add(self, note):
"""
The note lastModified time is updated from Dropbox when the operations succeeds (unfortunately there's no way to
set the modified time in Dropbox).
"""
uuid= note.uuid
result= self.__client.put_file(self.__notePath(uuid), marshalNote(note))
if len(result["path"]) != len(self.__notePath(uuid)):
try:
self.__client.file_delete(result["path"])
except ErrorResponse:
pass
raise RuntimeError("Note[uuid=%s] already exists" % uuid)
note.lastModified= getLastModified(result)
if note.photo:
self.__client.put_file(self.__photoPath(uuid), note.photo, overwrite=True)
elif uuid in self.__notesCache and self.__notesCache[uuid].hasPhoto:
try:
self.__client.file_delete(self.__photoPath(uuid))
except ErrorResponse:
pass
renderHtml(note)
#Clean removed note if exists
if uuid in self.__notesCache and self.__notesCache[uuid].removed:
try:
self.__client.file_delete(self.__removedNotePath(uuid))
except ErrorResponse:
pass
@online
@expires
def update(self, note):
"""
The note lastModified time is updated from Dropbox when the operations succeeds (unfortunately there's no way to
set the modified time in Dropbox).
"""
uuid= note.uuid
#Check if note exists
if self.__notesCache and (uuid not in self.__notesCache or self.__notesCache[uuid].removed):
raise RuntimeError("Note[uuid=%s] does not exist" % uuid)
result= self.__client.put_file(self.__notePath(uuid), marshalNote(note), overwrite=True)
note.lastModified= getLastModified(result)
if note.photo:
self.__client.put_file(self.__photoPath(uuid), note.photo, overwrite=True)
elif uuid not in self.__notesCache or self.__notesCache[uuid].hasPhoto:
try:
self.__client.file_delete(self.__photoPath(uuid))
except ErrorResponse:
pass
renderHtml(note)
@online
@expires
def remove(self, note):
"""
The note lastModified time is updated from Dropbox when the operations succeeds (unfortunately there's no way to
set the modified time in Dropbox).
"""
uuid= note.uuid
#Remove note if exists
if uuid in self.__notesCache and not self.__notesCache[uuid].removed:
try:
self.__client.file_delete(self.__notePath(uuid))
except ErrorResponse:
pass
#Remove photo if exists
if uuid in self.__notesCache and self.__notesCache[uuid].hasPhoto:
try:
self.__client.file_delete(self.__photoPath(uuid))
except ErrorResponse:
pass
result= self.__client.put_file(self.__removedNotePath(uuid), b"", overwrite=True)
note.lastModified= getLastModified(result)
def __list(self, path, removed):
folder= self.__client.metadata(path)
if not folder["is_dir"]:
raise RuntimeError("Path is not a folder")
notes= {}
pos= len(path) + 1
for file in folder["contents"]:
if not file["is_dir"]:
name= self.__fileUuid(file["path"][pos:])
if isUuid(name):
notes[name]= NoteStatus(name, getLastModified(file), removed)
if not removed:
folder= self.__client.metadata(self.__photosPath)
if not folder["is_dir"]:
raise RuntimeError("Path is not a folder")
pos= len(self.__photosPath) + 1
for file in folder["contents"]:
name= file["path"][pos:]
if not file["is_dir"] and name.endswith(".jpg"):
name= name[:-4]
if name in notes:
notes[name].hasPhoto= True
return notes
def __fileUuid(self, filename):
if self.__dayOneFlavor and filename.endswith(self.__DAY_ONE_EXTENSION):
return filename[:-(len(self.__DAY_ONE_EXTENSION))]
return filename
def __buildNotePath(self, parentPath, uuid):
path= parentPath + "/" + uuid
if self.__dayOneFlavor:
path+= self.__DAY_ONE_EXTENSION
return path
def __notePath(self, uuid):
return self.__buildNotePath(self.__notesPath, uuid)
def __removedNotePath(self, uuid):
return self.__buildNotePath(self.__removedNotesPath, uuid)
def __photoPath(self, uuid):
return self.__photosPath + "/" + uuid + ".jpg"
class DropboxStorage(Storage):
"""
A storage class providing access to resources in a Dropbox Public folder.
"""
def __init__(self, location='/Public'):
session = DropboxSession(CONSUMER_KEY,
CONSUMER_SECRET,
ACCESS_TYPE,
locale=None)
session.set_token(ACCESS_TOKEN, ACCESS_TOKEN_SECRET)
self.client = DropboxClient(session)
self.account_info = self.client.account_info()
self.location = location
self.base_url = 'http://dl.dropbox.com/u/{uid}/'.format(
**self.account_info)
def _get_abs_path(self, name):
return os.path.realpath(os.path.join(self.location, name))
def _open(self, name, mode='rb'):
name = self._get_abs_path(name)
remote_file = DropboxFile(name, self, mode=mode)
return remote_file
def _save(self, name, content):
name = self._get_abs_path(name)
directory = os.path.dirname(name)
if not self.exists(directory) and directory:
self.client.file_create_folder(directory)
response = self.client.metadata(directory)
if not response['is_dir']:
raise IOError("%s exists and is not a directory." % directory)
abs_name = os.path.realpath(os.path.join(self.location, name))
self.client.put_file(abs_name, content)
return name
def delete(self, name):
name = self._get_abs_path(name)
self.client.file_delete(name)
def exists(self, name):
name = self._get_abs_path(name)
try:
metadata = self.client.metadata(name)
if metadata.get('is_deleted'):
return False
except ErrorResponse as e:
if e.status == 404: # not found
return False
raise e
return True
def listdir(self, path):
path = self._get_abs_path(path)
response = self.client.metadata(path)
directories = []
files = []
for entry in response.get('contents', []):
if entry['is_dir']:
directories.append(os.path.basename(entry['path']))
else:
files.append(os.path.basename(entry['path']))
return directories, files
def size(self, name):
cache_key = 'django-dropbox-size:%s' % filepath_to_uri(name)
size = cache.get(cache_key)
if not size:
size = self.client.metadata(filepath_to_uri(name))['bytes']
cache.set(cache_key, size, CACHE_TIMEOUT)
return size
def url(self, name):
cache_key = 'django-dropbox-url:%s' % filepath_to_uri(name)
url = cache.get(cache_key)
if not url:
url = self.client.share(filepath_to_uri(name),
short_url=False)['url'] + '?dl=1'
cache.set(cache_key, url, CACHE_TIMEOUT)
return url
def get_available_name(self, name):
"""
Returns a filename that's free on the target storage system, and
available for new content to be written to.
"""
name = self._get_abs_path(name)
dir_name, file_name = os.path.split(name)
file_root, file_ext = os.path.splitext(file_name)
# If the filename already exists, add an underscore and a number (before
# the file extension, if one exists) to the filename until the generated
# filename doesn't exist.
count = itertools.count(1)
while self.exists(name):
# file_ext includes the dot.
name = os.path.join(
dir_name, "%s_%s%s" % (file_root, count.next(), file_ext))
return name
class DropboxStorage(Storage):
"""
A storage class providing access to resources in a Dropbox Public folder.
"""
def __init__(self, location=None):
session = DropboxSession(DROPBOX.app_key, DROPBOX.app_secret, DROPBOX.access_type, locale=None)
session.set_token(DROPBOX.access_key, DROPBOX.access_secret)
self.client = DropboxClient(session)
self.overwrite_mode = DROPBOX.overwrite_mode
self._location = location
@prepend_path_with_attr("_location")
def delete(self, name):
self.client.file_delete(name)
@prepend_path_with_attr("_location")
def exists(self, name):
try:
metadata = self.client.metadata(name, list=False)
return not metadata.get('is_deleted')
except ErrorResponse as e:
if 404 == e.status: # not found
return False
raise e
return True
@prepend_path_with_attr("_location")
def listdir(self, name, query_filter=None):
if query_filter is None or len(query_filter) < 3:
metadata = self.client.metadata(name)
else:
metadata = self.client.search(name, query_filter, file_limit=25000)
directories = []
files = []
for entry in metadata.get('contents', []):
if entry['is_dir']:
directories.append(os.path.basename(entry['path']))
else:
files.append(os.path.basename(entry['path']))
return directories, files
@prepend_path_with_attr("_location")
def open(self, name, mode='rb'):
return DropboxFile(name, self, mode)
@prepend_path_with_attr("_location")
def save(self, name, content):
metadata = self.client.put_file(name, content)
return metadata['path']
@prepend_path_with_attr("_location")
def size(self, name):
return self.client.metadata(name, list=False)['bytes']
@prepend_path_with_attr("_location")
def url(self, name):
try:
return self.client.share(name)['url']
except ErrorResponse as e:
if 404 == e.status: # not found
return None
raise e
@prepend_path_with_attr("_location")
def get_available_name(self, name):
"""
Returns a filename that's free on the target storage system, and
available for new content to be written to.
"""
if self.overwrite_mode:
return name
if self.exists(name):
dir_name, file_name = os.path.split(name)
file_root, file_ext = os.path.splitext(file_name)
# If the filename already exists, add an underscore and a number (before
# the file extension, if one exists) to the filename until the generated
# filename doesn't exist.
dir_contents = self.listdir(dir_name, file_root)
count = itertools.count(1)
while True:
# file_ext includes the dot.
name = "%s_%s%s" % (file_root, count.next(), file_ext)
if name not in dir_contents:
return os.path.join(dir_name, name)
else:
return name
@prepend_path_with_attr("_location")
def get_valid_name(self, name):
return name
def delete_file_dropbox(self, user_profile):
api_client = DropboxClient(user_profile.dropbox_profile.access_token["key"])
result = api_client.file_delete(self.path)
return True
def historicalCloud(self):
user = self.getData()
while len(self.getAllBackupsByDate()) >= user['FileHistoricalNumberCloud']:
cliente = DropboxClient(self.TOKEN)
respuesta = cliente.file_delete(self.getAllBackupsByDate()[0]['path'])
class DropBox(clouddrive.CloudDrive):
name = "DropBox"
def __init__(self, access_token):
self.client = DropboxClient(access_token)
self.access_token = access_token
clouddrive.CloudDrive.__init__(self, access_token)
@staticmethod
def auth():
#app_key = 'knbyx2adg14kkn5'
#app_secret = 'kh3ulgqry8jffqp'
app_key = 'eif0l7bgnpb06di'
app_secret = 'qa02jhdo4jrwaid'
global Auth_DROPMytoken
global Auth_Drop_Running_true
def keep_running():
global Auth_Drop_Running_true
return Auth_Drop_Running_true
class AuthHandler(BaseHTTPServer.BaseHTTPRequestHandler):
def do_HEAD(s):
s.send_response(200)
s.send_header("Content-type", "text/html")
s.end_headers()
def do_GET(s):
s.send_response(200)
s.send_header("Content-type", "text/html")
s.end_headers()
if s.path.find("code=") != -1:
global Auth_DROPMytoken
global Auth_Drop_Running_true
Auth_DROPMytoken = s.path
Auth_Drop_Running_true = False
s.wfile.write("ok see command line")
return
class MYrequest:
def __init__(self, url):
self.url = url
def get(self, mystring):
if self.url.find(mystring) == -1:
return
item = self.url.split(mystring + "=")[1]
if item.find("&") != -1:
item = item.split("&")[0]
return urllib.unquote(item).decode()
redirect_url = "http://localhost:8787"
my_session = {}
Auth_Drop_Running_true = True
flow = DropboxOAuth2Flow(app_key, app_secret, redirect_url, my_session,
"dropbox-auth-csrf-token")
authorize_url = flow.start()
webbrowser.open(authorize_url)
try:
httpd = BaseHTTPServer.HTTPServer(("", 8787), AuthHandler)
while keep_running():
httpd.handle_request()
except KeyboardInterrupt:
pass
httpd.server_close()
token, user_id, url_state = flow.finish(MYrequest(Auth_DROPMytoken))
clouddrive.CloudDrive.access_token = token
return token
def read(self, filename):
try:
data = []
with self.client.get_file(filename) as f:
data += f.read()
except:
return -1
return ''.join(data)
def write(self, filename, data):
try:
response = self.client.put_file(filename, data, True)
except:
return -1
return 1
def mkdir(self, dirname):
try:
self.client.file_create_folder(dirname)
except:
return -1
return 1
def delete(self, filename):
try:
self.client.file_delete(filename)
except:
return -1
return 1
def capacity(self):
try:
a = self.client.account_info()["quota_info"]
except:
return -1
return a["quota"] - a["shared"] - a["normal"]
def listing(self, path="/"):
lists = self.client.metadata(path)
filelist = []
for x in lists["contents"]:
filelist.append((x['path'], x['is_dir']))
return filelist
class DropboxStorage(Storage):
"""
A storage class providing access to resources in a Dropbox Public folder.
"""
def __init__(self, location='/Public'):
session = DropboxSession(CONSUMER_KEY, CONSUMER_SECRET, ACCESS_TYPE, locale=None)
session.set_token(ACCESS_TOKEN, ACCESS_TOKEN_SECRET)
self.client = DropboxClient(session)
self.account_info = self.client.account_info()
self.location = location
self.base_url = 'http://dl.dropbox.com/u/{uid}/'.format(**self.account_info)
def _get_abs_path(self, name):
return os.path.realpath(os.path.join(self.location, name))
def _open(self, name, mode='rb'):
name = self._get_abs_path(name)
remote_file = DropboxFile(name, self, mode=mode)
return remote_file
def _save(self, name, content):
name = self._get_abs_path(name)
directory = os.path.dirname(name)
if not self.exists(directory) and directory:
self.client.file_create_folder(directory)
response = self.client.metadata(directory)
if not response['is_dir']:
raise IOError("%s exists and is not a directory." % directory)
abs_name = os.path.realpath(os.path.join(self.location, name))
self.client.put_file(abs_name, content)
return name
def delete(self, name):
name = self._get_abs_path(name)
self.client.file_delete(name)
def exists(self, name):
name = self._get_abs_path(name)
try:
metadata = self.client.metadata(name)
if metadata.get('is_deleted'):
return False
except ErrorResponse as e:
if e.status == 404: # not found
return False
raise e
return True
def listdir(self, path):
path = self._get_abs_path(path)
response = self.client.metadata(path)
directories = []
files = []
for entry in response.get('contents', []):
if entry['is_dir']:
directories.append(os.path.basename(entry['path']))
else:
files.append(os.path.basename(entry['path']))
return directories, files
def size(self, name):
cache_key = 'django-dropbox-size:%s' % filepath_to_uri(name)
size = cache.get(cache_key)
if not size:
size = self.client.metadata(filepath_to_uri(name))['bytes']
cache.set(cache_key, size, CACHE_TIMEOUT)
return size
def url(self, name):
cache_key = 'django-dropbox-url:%s' % filepath_to_uri(name)
url = cache.get(cache_key)
if not url:
url = self.client.share(filepath_to_uri(name), short_url=False)['url'] + '?dl=1'
cache.set(cache_key, url, CACHE_TIMEOUT)
return url
def get_available_name(self, name):
"""
Returns a filename that's free on the target storage system, and
available for new content to be written to.
"""
name = self._get_abs_path(name)
dir_name, file_name = os.path.split(name)
file_root, file_ext = os.path.splitext(file_name)
# If the filename already exists, add an underscore and a number (before
# the file extension, if one exists) to the filename until the generated
# filename doesn't exist.
count = itertools.count(1)
while self.exists(name):
# file_ext includes the dot.
name = os.path.join(dir_name, "%s_%s%s" % (file_root, count.next(), file_ext))
return name
class DropBoxStorage(Storage):
"""DropBox Storage class for Django pluggable storage system."""
def __init__(self, oauth2_access_token=None, root_path=None):
oauth2_access_token = oauth2_access_token or setting('DROPBOX_OAUTH2_TOKEN')
self.root_path = root_path or setting('DROPBOX_ROOT_PATH', '/')
if oauth2_access_token is None:
raise ImproperlyConfigured("You must configure a token auth at"
"'settings.DROPBOX_OAUTH2_TOKEN'.")
self.client = DropboxClient(oauth2_access_token)
def _full_path(self, name):
if name == '/':
name = ''
return safe_join(self.root_path, name).replace('\\', '/')
def delete(self, name):
self.client.file_delete(self._full_path(name))
def exists(self, name):
try:
return bool(self.client.metadata(self._full_path(name)))
except ErrorResponse:
return False
def listdir(self, path):
directories, files = [], []
full_path = self._full_path(path)
metadata = self.client.metadata(full_path)
for entry in metadata['contents']:
entry['path'] = entry['path'].replace(full_path, '', 1)
entry['path'] = entry['path'].replace('/', '', 1)
if entry['is_dir']:
directories.append(entry['path'])
else:
files.append(entry['path'])
return directories, files
def size(self, name):
metadata = self.client.metadata(self._full_path(name))
return metadata['bytes']
def modified_time(self, name):
metadata = self.client.metadata(self._full_path(name))
mod_time = datetime.strptime(metadata['modified'], DATE_FORMAT)
return mod_time
def accessed_time(self, name):
metadata = self.client.metadata(self._full_path(name))
acc_time = datetime.strptime(metadata['client_mtime'], DATE_FORMAT)
return acc_time
def url(self, name):
media = self.client.media(self._full_path(name))
return media['url']
def _open(self, name, mode='rb'):
remote_file = DropBoxFile(self._full_path(name), self)
return remote_file
def _save(self, name, content):
self.client.put_file(self._full_path(name), content)
return name
f = open(backup_file, 'rb')
response = dbx.put_file('/your_dropbox_app_folder/' + destination, f)
print "Response: ", response
# Retention
head = ''
total_backups = get_line_count('/root/backup_script/backup_history')
print "Checking retention"
print "There are %s backups | retention is %s" %(total_backups, retention)
diff = int(total_backups) - int(retention)
if diff > 0 :
# Delete diff number of folders from the top of the file backup_history
print "There are files to be deleted in the destination"
with open("/root/backup_script/backup_history") as f:
head = [next(f) for x in xrange(diff)]
# delete everything in head
if head:
for folder in head:
os.system("sed -i '1d' /root/backup_script/backup_history")
print "Deleting ", folder
folder = folder.rstrip('\n')
dbx.file_delete('/your_dropbox_app_folder' + folder + '.tar.gz')
print "Deleted successfully"
#cleaning up
print "Cleaning up.."
os.system('rm -rf /tmp/databases/*')
os.system("rm -f %s" %(backup_file))
print "All done"
