def get_session():
SWIFT_USER = get_reg_value('HKLM', APP_STORAGE_REG_KEY, 'account')
SWIFT_PASS = get_reg_value('HKLM', APP_STORAGE_REG_KEY, 'password')
SWIFT_KEY = get_reg_value('HKLM', APP_STORAGE_REG_KEY, 'key')
SWIFT_AUTH_URL = get_reg_value('HKLM', APP_STORAGE_REG_KEY, 'auth_url')
cnx = Connection(SWIFT_AUTH_URL, '%s:%s' % (SWIFT_USER,SWIFT_PASS), SWIFT_KEY)
cnx.get_auth()
return cnx
def run ( self ):
try:
port = get_reg_value(key=APP_REG_KEY, name='port')
host = get_reg_value(key=APP_REG_KEY, name='host')
bottle_run(__bottle_app__, host=host, port=port,
server=WSGIRefHandleOneServer, reloader=False,
quiet=True, notifyEvent=self.notifyEvent)
except:
log.error('Error in WebServerThread', exc_info=True)
def __init__(self):
import servicemanager
dsn = get_reg_value('HKLM', APP_REG_KEY, 'sentry_dsn')
# Need to do some error catching so that SentryLogging is disabled if,
# for some reason the dsn is invalid.
if not dsn:
servicemanager.LogErrorMsg('Sentry DSN was not specified. Logging'
' to sentry will be disabled')
self.error = self.warning = self.info = self.critical = \
self.debug = self.nulloutput
else:
sitename = get_reg_value('HKLM', APP_REG_KEY, 'sentry_site')
self.raven = Client(dsn, site=sitename)
def clear_upload_in_progress(dir):
""" Clear the upload in progress flag for the given directory
"""
data = get_reg_value('HKLM', APP_DIR_REG_KEY, dir)
data[DIR_UPLOAD_IN_PROGRESS] = 'false'
set_reg_value('HKLM', APP_DIR_REG_KEY, dir, data)
def get_container():
""" Return the path of the "App folder".
By default the "App folder" is "Anaogic Backup"
"""
return get_reg_value('HKLM', APP_STORAGE_REG_KEY, 'container',
default=APP_CONTAINER)
def save_settings():
port = get_reg_value('HKLM', APP_REG_KEY, 'port', default=4242)
hostname = get_reg_value('HKLM', APP_REG_KEY, 'hostname', default='127.0.0.1')
sentrydsn = get_reg_value('HKLM', APP_REG_KEY, 'sentry_dsn')
sentrysite = get_reg_value('HKLM', APP_REG_KEY, 'sentry_site')
restartneeded = 0
data = request.forms.settings_hostname
if data:
parts = data.split(':')
if hostname <> parts[0].strip():
log.info("--%s-- | --%s--" % (hostname, parts[0].strip()))
hostname = parts[0].strip()
restartneeded = 1
if len(parts) > 1:
try:
if port <> int(parts[1].strip()):
port = int(parts[1].strip())
log.info("--%d-- | --%d--" % (port, int(parts[1].strip())))
restartneeded = 1
except ValueError:
log.error('Unable to set port to: %s' % parts[1].strip())
data = request.forms.sentry_dsn if request.forms.sentry_dsn.lower() <> 'none' else None
if data and (data <> sentrydsn):
sentrydsn = data
restartneeded = 1
data = request.forms.sentry_site if request.forms.sentry_site.lower() <> 'none' else None
if data and (data <> sentrysite):
sentrysite = data
restartneeded = 1
swift_key = get_reg_value('HKLM', APP_STORAGE_REG_KEY, 'key')
if not swift_key:
swift_key = request.forms.settings_swift_key
swift_password = get_reg_value('HKLM', APP_STORAGE_REG_KEY, 'password')
if not swift_password:
swift_password = request.forms.settings_swift_password
swift_account = get_reg_value('HKLM', APP_STORAGE_REG_KEY, 'account')
if not swift_account:
swift_account = request.forms.settings_swift_account
swift_auth_url = get_reg_value('HKLM', APP_STORAGE_REG_KEY, 'auth_url')
if not swift_auth_url:
swift_auth_url = request.forms.settings_swift_auth_url
container = request.forms.settings_container
set_reg_value('HKLM', APP_REG_KEY, 'hostname', hostname)
set_reg_value('HKLM', APP_REG_KEY, 'port', port)
set_reg_value('HKLM', APP_REG_KEY, 'restartneeded', restartneeded)
set_reg_value('HKLM', APP_STORAGE_REG_KEY, 'container', container)
set_reg_value('HKLM', APP_STORAGE_REG_KEY, 'key', swift_key)
set_reg_value('HKLM', APP_STORAGE_REG_KEY, 'password', swift_password)
set_reg_value('HKLM', APP_STORAGE_REG_KEY, 'account', swift_account)
set_reg_value('HKLM', APP_STORAGE_REG_KEY, 'auth_url', swift_auth_url)
set_reg_value('HKLM', APP_REG_KEY, 'sentry_dsn', sentrydsn)
set_reg_value('HKLM', APP_REG_KEY, 'sentry_site', sentrysite)
redirect('/index.html')
def pending_changes(dir):
""" Return whether there are pending changes to be synced for the given dir
"""
pending = get_reg_value('HKLM', APP_DIR_REG_KEY, dir)
if len(pending) > DIR_PENDING_CHANGES:
return pending[DIR_PENDING_CHANGES] == 'true'
else:
return False
def browse():
global htdocs, templates
cnx = get_session()
container_info = cnx.get_container(get_container())
restartneeded = get_reg_value('HKLM', APP_REG_KEY, 'restartneeded')
internal_error = get_reg_value('HKLM', APP_REG_KEY, 'internal_error', False)
file_data = {
'template_lookup': [templates,],
'restartneeded': restartneeded,
'internalerror': internal_error,
'dirs': []
}
for files in container_info[1]:
file_data['dirs'].append(
{
'path': files['name'],
'path_encoded': quote(files['name'], safe='').lstrip('/'),
'changed': files['last_modified'],
'size': files['bytes']
}
)
continue
return file_data
def unwatch_directory(directory):
""" Remove the given directory from those being monitored for changes.
"""
del_reg_value('HKLM', APP_DIR_REG_KEY, directory)
log.debug('unwatch_directory(%s)' % directory)
try:
pipe = get_reg_value('HKLM', APP_REG_KEY, 'namedpipe')
handle = CreateFile(pipe, GENERIC_WRITE, FILE_SHARE_READ, None,
OPEN_EXISTING, 0, None)
WriteFile(handle, 'refreshdirectories')
CloseHandle(handle)
except pywintypes.error:
log.error('Error when calling the namedpipe with the refreshdirectories '
'command', culprit=__culprit__)
pass
def get_watched_directory_info(dir):
""" Return the added and last change times for the directory
"""
added = changed = ''
pending = inprogress = False
tstamps = get_reg_value('HKLM', APP_DIR_REG_KEY, dir)
num_entries = len(tstamps)
if num_entries > DIR_ADDED_TIMESTAMP:
added = tstamps[DIR_ADDED_TIMESTAMP]
if num_entries > DIR_LAST_SYNC_TIMESTAMP:
changed = tstamps[DIR_LAST_SYNC_TIMESTAMP]
if changed == 'None':
changed = ''
if num_entries > DIR_PENDING_CHANGES:
pending = tstamps[DIR_PENDING_CHANGES].lower() == 'true'
if num_entries > DIR_UPLOAD_IN_PROGRESS:
inprogress = tstamps[DIR_UPLOAD_IN_PROGRESS].lower() == 'true'
return (added.strip(), changed.strip(), pending, inprogress)
def __init__(self, args):
win32serviceutil.ServiceFramework.__init__(self, args)
# Looks like py2exe handles redirecting stdout and stderror for us
#sys.stdout.close()
#sys.stderr.close()
#sys.stdout = NullOutput()
#sys.stderr = NullOutput()
# Create an event which we will use to wait on.
# The "service stop" request will set this event.
self.hWaitStop = win32event.CreateEvent(None, 0, 0, None)
# Event for named pipe operation
self.overlapped = pywintypes.OVERLAPPED()
self.overlapped.hEvent = win32event.CreateEvent(None, 0, 0, None)
# Internal timer
self.timer = win32event.CreateWaitableTimer(None, 0, None)
set_reg_value('HKLM', APP_REG_KEY, 'restartneeded', 0)
# Setup Named pip for IPC
pipename = get_reg_value('HKLM', APP_REG_KEY, 'namedpipe')
self.pipe_handle = None
if not pipename:
log.error('No named pipe was specified in the registry',
culprit=__culprit__)
self.SvcStop()
else:
openmode = PIPE_ACCESS_INBOUND | FILE_FLAG_OVERLAPPED
pipmode = PIPE_TYPE_MESSAGE
sa = pywintypes.SECURITY_ATTRIBUTES()
sa.SetSecurityDescriptorDacl(1, None, 0)
self.pipe_handle = CreateNamedPipe(pipename, openmode, pipmode,
PIPE_UNLIMITED_INSTANCES, 0, 0,
0, sa)
# Initialize a list of watched handles
self.handles = list()
self.mgmt_handles = list()
self.mgmt_callbacks = list()
def upload_in_progress(dir):
""" Returns whether an upload is in progress
"""
data = get_reg_value('HKLM', APP_DIR_REG_KEY, dir)
return data[DIR_UPLOAD_IN_PROGRESS].lower() == 'true'
from swiftclient import ClientException, quote
# Local imports
from anagogic.backup.util import get_reg_value, APP_REG_KEY, set_reg_value
from anagogic.backup.storage import get_session
from anagogic.backup.storage import create_container, get_container
from anagogic.backup.storage import app_container_exists, APP_STORAGE_REG_KEY
from anagogic.backup.watch import get_watched_directories, get_watched_directory_info
from anagogic.backup.watch import unwatch_directory
__all__ = [
'app',
]
__culprit__ = 'anagogic.backup.web.admin'
htdocs = get_reg_value('HKLM', APP_REG_KEY, 'htdocs')
templates = get_reg_value('HKLM', APP_REG_KEY, 'templates')
TEMPLATE_PATH = [templates]
debug(True)
app = Bottle()
def check_internal_error(fn):
def wrap_error(*args, **kwargs):
try:
set_reg_value('HKLM', APP_REG_KEY, 'internal_error', False)
fn(*args, **kwargs)
except rest.ErrorResponse, e:
log.error('Application auth callback failure', exc_info=True,
culprit=__culprit__)
set_reg_value('HKLM', APP_REG_KEY, 'internal_error', True)
# Stdlib imports
import sys
# 3rd party imports
import pywintypes
from win32file import CreateFile, GENERIC_WRITE, FILE_SHARE_READ, OPEN_EXISTING
from win32file import WriteFile, CloseHandle
# Local imports
from anagogic.backup.util import get_reg_value, APP_REG_KEY
from anagogic.backup.watch import get_watched_directories, add_watch_directory
if __name__ == '__main__':
dir_to_watch = sys.argv[1]
pipe = get_reg_value('HKLM', APP_REG_KEY, 'namedpipe')
watched_dirs = get_watched_directories()
if dir_to_watch not in watched_dirs:
add_watch_directory(dir_to_watch)
try:
handle = CreateFile(pipe, GENERIC_WRITE, FILE_SHARE_READ, None,
OPEN_EXISTING, 0, None)
WriteFile(handle, 'refreshdirectories')
CloseHandle(handle)
except pywintypes.error:
# The named pipe wasn't ready which should indicate that the service
# isn't started. We can ignore this since the watch list will be
# loaded when the service starts
pass
def SvcDoRun(self):
import servicemanager
# log a service started message
servicemanager.LogMsg(
servicemanager.EVENTLOG_INFORMATION_TYPE,
servicemanager.PYS_SERVICE_STARTED,
(self._svc_name_, ' (%s)' % self._svc_display_name_))
try:
# Spawn off web server
self.thread_event = Event()
self.thread_event.set()
log.info('Before try block to spawn thread')
try:
if self._svc_thread_class:
log.info('Thread class specified, instantiating now')
self.service_thread = self._svc_thread_class(self.thread_event)
log.info('Thread instantiated, starting thread')
self.service_thread.start()
log.info('Thread started')
else:
log.error("No Service thread was provided", culprit=__culprit__)
self.SvcStop()
except Exception, info:
log.error('Uncaught error in thread', exc_info=True, culprit=__culprit__)
errmsg = getTrace()
servicemanager.LogErrorMsg(errmsg)
self.SvcStop()
# Start watching directories
self.mgmt_handles = []
self.handles = watch_directories()
self.add_mgmt_event_handler(self.timer, self.process_timer)
self.add_mgmt_event_handler(self.overlapped.hEvent,
self.process_named_pipe)
self.add_mgmt_event_handler(self.hWaitStop,
lambda a, b, c: True)
self.handles.extend(self.mgmt_handles)
# Set internal timer
# default to 2 minute period
timer_period = get_reg_value('HKLM', APP_REG_KEY, 'timer',
default=120000)
win32event.SetWaitableTimer(self.timer, 0, timer_period, None, None,
False)
while 1:
hr = ConnectNamedPipe(self.pipe_handle, self.overlapped)
rc = win32event.WaitForMultipleObjects(self.handles, 0,
win32event.INFINITE)
if rc == win32event.WAIT_FAILED:
log.error('WAIT_FAILED for unknown reason')
self.SvcStop()
break
elif rc == win32event.WAIT_TIMEOUT:
log.error('WAIT_TIMEOUT: This should NEVER happen')
pass
elif (rc >= win32event.WAIT_OBJECT_0) and \
(rc < (len(self.handles) - len(self.mgmt_handles))):
process_directory_changes(self.handles[rc], rc)
else:
offset = rc - len(self.handles) + len(self.mgmt_handles)
dobreak = self.mgmt_callbacks[offset](rc, self.handles,
self.mgmt_handles)
if dobreak:
break
continue
