class Tester():
def __init__(self, test_folder, options):
self.test_folder = os.path.join(test_folder, "tester")
self.options = options
self.config = Config.get_config()
self.store_folder = os.path.join(self.test_folder, "stores")
self.files_folder = os.path.join(self.test_folder, "files")
self.restore_folder = os.path.join(self.test_folder, "restore")
self.db = DB()
self.max_fs_id = self.db.query("select max(fs_id) from fs", ())[0][0]
if self.max_fs_id is None:
self.max_fs_id = 0
self.max_version_id = self.db.query("select max(version_id) from versions", ())[0][0]
if self.max_version_id is None:
self.max_version_id = 0
self.max_run_id = self.db.query("select max(run_id) from runs", ())[0][0]
if self.max_run_id is None:
self.max_run_id = 0
self.max_message_id = self.db.query("select max(message_id) from messages", ())[0][0]
if self.max_message_id is None:
self.max_message_id = 0
log.debug("MAX IDs", self.max_fs_id, self.max_version_id, self.max_run_id, self.max_message_id)
self.teststring1 = os.urandom(204800)
self.teststring2 = os.urandom(204800)
def run(self):
try:
self.simpleCycleTest()
self.restoreTest()
except:
pass
if self.options.message:
try:
from lib.dlg import Notify
Notify(const.AppTitle, "Test run is complete")
except:
log.debug("Unable to notify. No-one logged in?")
if self.options.email:
self.send_email(True)
if self.options.shutdown:
os.system("shutdown -P +2")
def simpleCycleTest(self):
try:
# build the test files/folders
self.make_folders()
# fill the files folder with the initial set of files
self.fill_files()
# Build a backup and store
self.build_config()
# self.run_test()
for i in xrange(int(self.options.cycles)):
log.info("Cycle", i)
# Run a full and one incremental
self.run_cycle_test()
except Exception as e:
log.error("Test run failed: %s" % str(e))
finally:
self.cleanup()
log.info("********Success")
def restoreTest(self):
try:
# build the test files/folders
self.make_folders()
# fill the files folder with the initial set of files
self.fill_files()
except:
pass
# def build_config(self):
# log.trace("build_config")
# try:
# if self.options.store:
# store = self.config.storage[self.options.store]
# else:
# # Make the store about 3x the options size
# s, dummy, dummy = utils.from_readable_form(self.options.size)
# store_size = utils.readable_form(s * 3)
# store = FolderStore("teststore1", store_size, True, os.path.join(self.store_folder, "teststore1"))
# self.config.storage[store.name] = store
#
# backup = Backup("testbackup1")
# backup.include_folders = [self.files_folder]
# backup.store = store.name
# backup.notify_msg = False
# self.config.backups[backup.name] = backup
#
#
# # Run full backup
# # change some files
# # Run incremental backup
# # restore as at full date
# # restore as at incr date
#
#
# except Exception as e:
# log.error("Test run failed: %s" % str(e))
# finally:
# self.cleanup()
log.info("********Success")
def send_email(self, result, error_message=None):
'''
Send a message to the appropriate users.
If result is False (failure) then error message will contain the reason.
@param result:
@param error_message:
'''
log.debug("send_email: ", result, error_message)
if result:
message_text = "Test to folder %s completed." % (self.test_folder)
subject = "Test Completed"
else:
message_text = "Test FAILED\n\nERROR: %s" % (error_message)
subject = "Test FAILED"
log.debug("Starting mail send")
try:
sendemail.sendemail(subject, message_text)
except Exception as e:
self.db.save_message("Unable to email results: %s" % str(e))
log.trace("send_email completed")
def run_cycle_test(self):
options = BlankClass()
options.dry_run = False
options.message = False
options.email = False
options.shutdown = False
options.norecurse = False
# Run a full backup
b = Run("testbackup1", const.FullBackup, options)
b.run()
# Run a full backup
b = Run("testbackup2", const.FullBackup, options)
b.run()
# Now restore two files, one that will be on each store.
restore_file1 = os.path.join(self.files_folder, "dir1", "f2.mp3")
dest_file1 = os.path.join(self.restore_folder, restore_file1[1:])
restore_file2 = os.path.join(self.files_folder, "dir2", "f3.exe")
dest_file2 = os.path.join(self.restore_folder, restore_file2[1:])
restore_file3 = os.path.join(self.files_folder, "dir3", "f4.txt")
dest_file3 = os.path.join(self.restore_folder, restore_file3[1:])
r = Restore(self.restore_folder, [restore_file1, restore_file2, restore_file3],
datetime.now(), options)
r.run()
for path in [dest_file1, dest_file2, dest_file3]:
if not os.path.exists(path):
raise Exception("File %s was not restored" % path)
if open(path).read() != self.teststring1:
raise Exception("Restored file contents incorrect %s" % path)
os.remove(path)
# Make sure the store is the right size
for name in self.config.storage:
store = self.config.storage[name].copy()
size, used, avail = store.current_usage()
log.debug("Store", store.name, "size", size, "used", used, "avail", avail)
if store.auto_manage and used > size:
raise Exception("Store %s has grown too large" % store.name)
######################PART 2
#wait a little
time.sleep(1.1)
for path in [restore_file1, restore_file2, restore_file3]:
# Make a change
with open(path, "w") as f:
f.write(self.teststring2)
#wait a little
time.sleep(1.1)
# Run an incremental backup
b = Run("testbackup1", const.IncrBackup, options)
b.run()
# Run an incremental backup
b = Run("testbackup2", const.IncrBackup, options)
b.run()
time.sleep(1.1)
r = Restore(self.restore_folder, [restore_file1, restore_file2, restore_file3],
datetime.now(), options)
r.run()
for path in [dest_file1, dest_file2, dest_file3]:
if not os.path.exists(path):
raise Exception("File %s was not restored after INCR %s" % path)
if open(path).read() != self.teststring2:
raise Exception("Restored file contents incorrect after INCR %s" % path)
# raise Exception("Test Failure")
# Make sure the store is the right size
for name in self.config.storage:
store = self.config.storage[name].copy()
size, used, avail = store.current_usage()
log.debug("Store", store.name, "size", size, "used", used)
if store.auto_manage and used > size:
raise Exception("Store %s has grown too large" % store.name)
time.sleep(1.1)
# change it back
for path in [restore_file1, restore_file2, restore_file3]:
with open(path, "w") as f:
f.write(self.teststring1)
def build_config(self):
log.trace("build_config")
#store1 = FTPStore("teststore1", "4MB", True, "localhost", "store1", "ftpuser", "ftpuserX9", False)
#store2 = FTPStore("teststore2", "4MB", True, "localhost", "store2", "ftpuser", "ftpuserX9", False)
if self.options.store:
store1 = self.config.storage[self.options.store].copy()
store2 = store1
else:
# Make the store about 3x the options size
s, dummy, dummy = utils.from_readable_form(self.options.size)
store_size = utils.readable_form(s * 3)
store1 = FolderStore("teststore1", store_size, True, os.path.join(self.store_folder, "teststore1"))
store2 = FolderStore("teststore2", store_size, True, os.path.join(self.store_folder, "teststore2"))
self.config.storage[store1.name] = store1
self.config.storage[store2.name] = store2
backup1 = Backup("testbackup1")
backup1.include_folders = [self.files_folder]
backup1.include_packages = True
backup1.exclude_types = ["Music"]
backup1.exclude_patterns = []
backup1.store = store1.name
backup1.notify_msg = False
self.config.backups[backup1.name] = backup1
backup2 = Backup("testbackup2")
backup2.include_folders = [self.files_folder]
backup2.include_packages = True
backup2.exclude_patterns = []
backup1.exclude_types = ["Videos", "Programs"]
backup2.store = store2.name
backup2.notify_msg = False
self.config.backups[backup2.name] = backup2
def fill_files(self, remaining=None, root=None):
log.trace("fill_files")
if not remaining:
# First time in...
remaining, dummy, dummy = utils.from_readable_form(self.options.size)
root = self.files_folder
list = [root]
done = False
while not done:
newlist = []
for folder in list:
for dname in ["dir1", "dir2", "dir3"]:
path = os.path.join(folder, dname)
utils.makedirs(path)
newlist.append(path)
for fname in ["f1.avi", "f2.mp3", "f3.exe", "f4.txt"]:
path = os.path.join(folder, fname)
with open(path, "w") as f:
f.write(self.teststring1)
remaining -= len(self.teststring1)
if remaining < 0:
done = True
break
list = newlist
return
def make_folders(self):
log.trace("make_folders")
if not os.path.isdir(self.test_folder):
os.makedirs(self.test_folder)
# if not os.path.isdir(self.store_folder):
# os.makedirs(self.store_folder)
if not os.path.isdir(self.files_folder):
os.makedirs(self.files_folder)
if not os.path.isdir(self.restore_folder):
os.makedirs(self.restore_folder)
def cleanup(self):
log.trace("Cleanup")
self.db.execute("delete from messages where message_id > ?", (self.max_message_id,))
self.db.execute("delete from versions where version_id > ?", (self.max_version_id,))
self.db.execute("delete from fs where fs_id > ?", (self.max_fs_id,))
self.db.execute("delete from runs where run_id > ?", (self.max_run_id,))
if self.options.store:
stores = self.options.store
else:
stores = ["teststore1", "teststore2"]
for name in stores:
log.info("Cleaning up", name)
store = self.config.storage[name].copy()
store.connect()
store.delete_store_data()
store.disconnect()
if not self.options.store:
del self.config.storage["teststore1"]
del self.config.storage["teststore2"]
del self.config.backups["testbackup1"]
del self.config.backups["testbackup2"]
shutil.rmtree(self.test_folder)
pass
else:
print line + "\n"
if select.select([
sys.stdin,
], [], [], 0.5)[0]:
foo = sys.stdin().readline().strip()
if foo == "exit":
break
elif comm.lower == "sms":
command = agentkey + " " + "PORT" + " " + port1 + " " + foo
db = DB(config=config)
db.query("SELECT path from modems where id=" + modem)
path2 = db.fetchone()[0]
db.query("SELECT controlkey from modems where id=" + modem)
key2 = db.fetchone()[0]
number2 = agentnumber
db.query("SELECT type from modems where id=" + modem)
modemtype2 = db.fetchone()[0]
if modemtype2 == "usb":
usb = serial.serialposix(port='/dev/ttyUSB2',
baudrate=115200,
bytesize=8,
parity='N',
stopbits=1)
usb.write("ATZ\r\n")
sleep(1)
class LongRunTestCase(unittest.TestCase):
def setUp(self):
self.config = Config.get_config()
self.db = DB()
self.db.check_upgrade()
self.mark_db_ids()
self.test_folder = tempfile.mkdtemp()
self.files_folder = os.path.join(self.test_folder, "files")
self.store_folder = os.path.join(self.test_folder, "store")
self.restore_folder = os.path.join(self.test_folder, "restore")
utils.makedirs(self.files_folder)
utils.makedirs(self.store_folder)
utils.makedirs(self.restore_folder)
# Build the base set of files
with open(os.path.join(self.files_folder, "base"), "w") as f:
f.write("base")
with open(os.path.join(self.files_folder, "incr"), "w") as f:
f.write("0")
config_file = os.path.expanduser("~/.vault")
if not os.path.exists(config_file):
raise Exception("Vault test configuration file (~/.vault) does not exist")
self.store_config = ConfigParser.RawConfigParser()
self.store_config.read(config_file)
# FOLDER STORE
self.store = FolderStore("teststore", "50MB", True, self.store_folder)
# DROPBOX STORE
# self.login = self.store_config.get("DropBox", "login")
# self.password = self.store_config.get("DropBox", "password")
# self.folder = self.store_config.get("DropBox", "folder")
# self.app_key = self.store_config.get("DropBox", "app_key")
# self.app_secret_key = self.store_config.get("DropBox", "app_secret_key")
# self.store = DropBoxStore("teststore", 0, False, self.folder, self.login, self.password,
# self.app_key, self.app_secret_key)
# S3 STORE
# self.key = self.store_config.get("Amazon", "aws_access_key_id")
# self.secret_key = self.store_config.get("Amazon", "aws_secret_access_key")
# self.bucket = self.store_config.get("Amazon", "bucket")
# self.store = S3Store("teststore", 0, False, bucket=self.bucket, key=self.key, secret_key=self.secret_key)
# Now record the existance of this store
self.config.storage[self.store.name] = self.store
# Build the backup object (dont save config)
self.backup = Backup("testbackup")
self.backup.include_folders = [self.files_folder]
self.backup.store = self.store.name
self.backup.notify_msg = False
self.old_pass = self.config.data_passphrase
self.config.data_passphrase = "goofy"
self.backup.encrypt = True
self.config.backups[self.backup.name] = self.backup
# build an options object for use with the backup
self.options = BlankClass()
self.options.dry_run = False
self.options.message = False
self.options.email = False
self.options.shutdown = False
self.options.norecurse = False
# How many cycles?
self.cycles = 20
def tearDown(self):
self.config.data_passphrase = self.old_pass
# Remove all DB records created during this test
self.clean_db()
shutil.rmtree(self.test_folder)
self.assertFalse(os.path.isdir(self.test_folder))
def testLongRun(self):
# Run a full backup
b = Run(self.backup.name, const.FullBackup, self.options)
b.run()
for cycle in xrange(self.cycles):
print(str(cycle)+"\r")
time.sleep(1)
# Change some files
with open(os.path.join(self.files_folder, "incr"), "w") as f:
f.write(os.urandom(100))
with open(os.path.join(self.files_folder, str(cycle)), "w") as f:
f.write(os.urandom(100))
# Run an incr backup
b = Run(self.backup.name, const.IncrBackup, self.options)
b.run()
# Attempt to restore every file
r = Restore(self.restore_folder, [self.files_folder],
datetime.now(), self.options)
r.run()
# Lets break it
# os.remove(os.path.join(self.restore_folder, self.files_folder[1:], "1"))
# with open(os.path.join(self.files_folder, "incr"), "w") as f:
# f.write("-1")
# with open(os.path.join(self.restore_folder, self.files_folder[1:], "8"), "w") as f:
# f.write("-1")
# Check that the restored folder and original folder are identical
left = unicode(self.files_folder)
right = unicode(os.path.join(self.restore_folder, self.files_folder[1:]))
d = utils.dircmp(left, right)
self.assertEqual(d.left_only, set())
self.assertEqual(d.right_only, set())
self.assertEqual(d.diff_files, set())
self.assertTrue(len(d.same_files) > 0)
# Check that all files are in the DB
for folder, _, local_files in os.walk(self.files_folder):
for file in local_files:
path = os.path.join(file, folder)
# This will raise an exception if it does not exist
self.db.select_path(path, build=False)
############################################################################
#
# Utility Routines
#
############################################################################
def mark_db_ids(self):
self.max_fs_id = self.db.query("select max(fs_id) from fs", ())[0][0]
if self.max_fs_id is None:
self.max_fs_id = 0
self.max_version_id = self.db.query("select max(version_id) from versions", ())[0][0]
if self.max_version_id is None:
self.max_version_id = 0
self.max_run_id = self.db.query("select max(run_id) from runs", ())[0][0]
if self.max_run_id is None:
self.max_run_id = 0
self.max_message_id = self.db.query("select max(message_id) from messages", ())[0][0]
if self.max_message_id is None:
self.max_message_id = 0
def clean_db(self):
self.db.execute("delete from messages where message_id > ?", (self.max_message_id,))
self.db.execute("delete from versions where version_id > ?", (self.max_version_id,))
self.db.execute("delete from fs where fs_id > ?", (self.max_fs_id,))
self.db.execute("delete from runs where run_id > ?", (self.max_run_id,))
if line == "":
pass
else:
print line + "\n"
if select.select([sys.stdin, ], [], [], 0.5)[0]:
foo = sys.stdin().readline().strip()
if foo == "exit":
break
elif comm.lower == "sms":
command = agentkey + " " + "PORT" + " " + port1 + " " + foo
db = DB(config=config)
db.query("SELECT path from modems where id=" + modem)
path2 = db.fetchone()[0]
db.query("SELECT controlkey from modems where id=" + modem)
key2 = db.fetchone()[0]
number2 = agentnumber
db.query("SELECT type from modems where id=" + modem)
modemtype2 = db.fetchone()[0]
if modemtype2 == "usb":
usb = serial.serialposix(port='/dev/ttyUSB2', baudrate=115200,
bytesize=8, parity='N', stopbits=1)
usb.write("ATZ\r\n")
sleep(1)
line = read_modem(usb)
print line
sleep(1)
class VerifyTestCase(unittest.TestCase):
def setUp(self):
self.config = Config.get_config()
self.db = DB()
self.db.check_upgrade()
self.mark_db_ids()
self.test_folder = tempfile.mkdtemp()
self.files_folder = os.path.join(self.test_folder, "files")
self.store_folder = os.path.join(self.test_folder, "store")
self.restore_folder = os.path.join(self.test_folder, "restore")
utils.makedirs(self.files_folder)
utils.makedirs(self.store_folder)
utils.makedirs(self.restore_folder)
utils.build_file_structure(self.files_folder, 50 * const.Kilobyte, 500 * const.Kilobyte)
# Build a store object (dont save config)
# Note the careful size selection - we want backups to overflow the FolderStore.
self.store = FolderStore("teststore", "2MB", True, self.store_folder)
self.config.storage[self.store.name] = self.store
# Build the backup object (dont save config)
self.backup = Backup("testbackup")
self.backup.include_folders = [self.files_folder]
self.backup.store = self.store.name
self.backup.notify_msg = False
self.include_packages = True
self.config.backups[self.backup.name] = self.backup
# build an options object for use with the backup
self.options = BlankClass()
self.options.dry_run = False
self.options.message = False
self.options.email = False
self.options.shutdown = False
self.options.norecurse = False
self.old_pass = self.config.data_passphrase
self.config.data_passphrase = "banana"
def tearDown(self):
self.config.data_passphrase = self.old_pass
# Remove all DB records created during this test
self.clean_db()
shutil.rmtree(self.test_folder)
self.assertFalse(os.path.isdir(self.test_folder))
def testVerify(self):
# Run a full backup
b = Run("testbackup", const.FullBackup, self.options)
b.run()
# Get the times
runs = self.db.runs("testbackup")
run = runs[0]
v = Verify("testbackup", run.start_time)
self.assertTrue(v.run())
def testBadVerify(self):
# Run a full backup
b = Run("testbackup", const.FullBackup, self.options)
b.run()
# Get the times
runs = self.db.runs("testbackup")
run = runs[0]
# Get the location of the data file from the streamer
streamer = StreamOut(None, self.store, b.backup_folder)
datafile = os.path.join(self.store.root, streamer.get_path(0))
size = os.path.getsize(datafile)
# Now corrupt the data file a little
with open(datafile, "r+b") as f:
f.seek(size // 2, 0)
f.write("X")
v = Verify("testbackup", run.start_time)
self.assertRaises(Exception, v.run)
def testBadConfig(self):
# Run a full backup
b = Run("testbackup", const.FullBackup, self.options)
b.run()
# Get the times
runs = self.db.runs("testbackup")
run = runs[0]
# Delete The Config File
configfile = os.path.join(run.folder, const.ConfigName)
self.store.remove_file(configfile)
v = Verify("testbackup", run.start_time)
self.assertRaises(Exception, v.run)
def testBadVerifyEncrypted(self):
backup = self.config.backups[self.backup.name]
backup.encrypt = True
self.config.backups[backup.name] = backup
# Run a full backup
b = Run("testbackup", const.FullBackup, self.options)
b.run()
# Get the times
runs = self.db.runs("testbackup")
run = runs[0]
# Get the location of the data file from the streamer
streamer = StreamOut(None, self.store, b.backup_folder)
datafile = os.path.join(self.store.root, streamer.get_path(0))
# Now corrupt the data file a little
size = os.path.getsize(datafile)
with open(datafile, "r+b") as f:
f.seek(size // 2, 0)
f.write("X")
v = Verify("testbackup", run.start_time)
self.assertRaises(Exception, v.run)
############################################################################
#
# Utility Routines
#
############################################################################
def mark_db_ids(self):
self.max_fs_id = self.db.query("select max(fs_id) from fs", ())[0][0]
if self.max_fs_id is None:
self.max_fs_id = 0
self.max_version_id = self.db.query("select max(version_id) from versions", ())[0][0]
if self.max_version_id is None:
self.max_version_id = 0
self.max_run_id = self.db.query("select max(run_id) from runs", ())[0][0]
if self.max_run_id is None:
self.max_run_id = 0
self.max_message_id = self.db.query("select max(message_id) from messages", ())[0][0]
if self.max_message_id is None:
self.max_message_id = 0
def clean_db(self):
self.db.execute("delete from messages where message_id > ?", (self.max_message_id,))
self.db.execute("delete from versions where version_id > ?", (self.max_version_id,))
self.db.execute("delete from fs where fs_id > ?", (self.max_fs_id,))
self.db.execute("delete from runs where run_id > ?", (self.max_run_id,))
class ServerTestCase(unittest.TestCase):
def setUp(self):
self.config = Config.get_config()
self.db = DB()
self.db.check_upgrade()
self.mark_db_ids()
self.test_folder = tempfile.mkdtemp()
self.files_folder = os.path.join(self.test_folder, "files")
self.store_folder = os.path.join(self.test_folder, "store")
self.restore_folder = os.path.join(self.test_folder, "restore")
utils.makedirs(self.files_folder)
utils.makedirs(self.store_folder)
utils.makedirs(self.restore_folder)
utils.build_file_structure(self.files_folder, 50 * const.Kilobyte, 500 * const.Kilobyte)
# Build a store object (dont save the config)
# Note the careful size selection - we want backups to overflow the FolderStore.
self.store = FolderStore("teststore", "2MB", True, self.store_folder)
self.config.storage[self.store.name] = self.store
# Build the backup object (dont save config)
self.backup = Backup("testbackup")
self.backup.include_folders = [self.files_folder]
self.backup.store = self.store.name
self.backup.notify_msg = False
self.old_pass = self.config.data_passphrase
self.config.data_passphrase = "goofy"
self.backup.encrypt = True
self.config.backups[self.backup.name] = self.backup
# build an options object for use with the backup
self.options = BlankClass()
self.options.dry_run = False
self.options.message = False
self.options.email = False
self.options.shutdown = False
self.options.norecurse = False
def tearDown(self):
self.config.data_passphrase = self.old_pass
# Remove all DB records created during this test
self.clean_db()
shutil.rmtree(self.test_folder)
self.assertFalse(os.path.isdir(self.test_folder))
def testBackupRestore(self):
self.backup_restore_compare()
def testCheckFiles(self):
self.backup.include_packages = True
b = Run("testbackup", const.FullBackup, self.options)
b.run()
# Check that all the right files are there.
runs = self.db.runs(self.backup.name)
self.assertEqual(len(runs), 1)
run = runs[0]
folder = run.folder
self.assertTrue(self.store.exists(os.path.join(folder, const.PackageFile + const.EncryptionSuffix)))
self.assertTrue(self.store.exists(os.path.join(folder, const.LOFFile + const.EncryptionSuffix)))
self.assertTrue(self.store.exists(os.path.join(folder, const.ConfigName + const.EncryptionSuffix)))
self.assertTrue(self.store.exists)
def testAutoManagementOfStore1(self):
# Run a set of backups that will overload the store.
# The automanaged store should continue to archive old backups as required.
# Store space reclaimation happens across all backups (i.e. any run).
# We should see older runs from the first backup disappear.
max_size, dummy, dummy = self.store.limit_details()
filesize = utils.du(self.backup.include_folders[0])
# Lets make sure we are going to do enough backups that
# the older ones will be removed.
RunCount = (max_size // filesize) + 2
last_start = None
for cycle in xrange(RunCount):
if last_start:
# Make sure we have ticked to another second since the start of the last backup.
while datetime.now() - last_start < timedelta(seconds=1):
time.sleep(0.01)
backup = Backup(self.backup.name + str(cycle))
backup.include_folders = self.backup.include_folders
backup.store = self.backup.store
backup.notify_msg = False
self.config.backups[backup.name] = backup
# Run a full backup
b = Run(backup.name, const.FullBackup, self.options)
b.run()
last_start = b.start_time
# Assert that the store is still of an appropriate size
size, used, avail = self.store.current_usage()
self.assertTrue(avail >= 0)
self.assertTrue(used <= max_size)
# Confirm that's true on disk
disksize = utils.du(self.store.root)
self.assertTrue(disksize <= max_size)
# Check that some runs have actually been deleted
runs = self.db.runs(self.backup.name + "0")
self.assertTrue(len(runs) == 0)
runs = self.db.runs(self.backup.name + "1")
self.assertTrue(len(runs) == 0)
def testAutoManagementOfStore2(self):
# Run one backup multiple times to overload a store
max_size, dummy, dummy = self.store.limit_details()
filesize = utils.du(self.backup.include_folders[0])
# Lets make sure we are going to do enough backups that
# the older ones will be removed.
RunCount = (max_size // filesize) + 2
last_start = None
for cycle in xrange(RunCount):
if last_start:
# Make sure we have ticked to another second since the start of the last backup.
while datetime.now() - last_start < timedelta(seconds=1):
time.sleep(0.01)
# Run a full backup
b = Run(self.backup.name, const.FullBackup, self.options)
b.run()
last_start = b.start_time
# Assert that the store is still of an appropriate size
size, used, avail = self.store.current_usage()
self.assertTrue(avail >= 0)
self.assertTrue(used <= max_size)
# Confirm that's true on disk
disksize = utils.du(self.store.root)
self.assertTrue(disksize <= max_size)
# Check that some runs have actually been deleted
runs = self.db.runs(self.backup.name)
self.assertTrue(len(runs) < RunCount)
def testChanges(self):
pass
# Full Backup
# change a file
# Incremental backup
# Restore most recent. ensure you get latest file
# Restore to just prior to incremental, ensure you get earlier file
# Run a full backup
file = os.path.join(self.files_folder, "changer")
restore_file = os.path.join(self.restore_folder, file[1:])
# t=0 - file does not exist
b = Run("testbackup", const.FullBackup, self.options)
b.run()
# Make sure we have ticked to another second since the start of the last backup.
while datetime.now() - b.start_time < timedelta(seconds=1):
time.sleep(0.01)
# t=1 - file exists
with open(file, "w") as f:
f.write("1")
b = Run("testbackup", const.IncrBackup, self.options)
b.run()
# Make sure we have ticked to another second since the start of the last backup.
while datetime.now() - b.start_time < timedelta(seconds=1):
time.sleep(0.01)
# t=2 - file changed
with open(file, "w") as f:
f.write("2")
b = Run("testbackup", const.IncrBackup, self.options)
b.run()
# Get the times
runs = self.db.runs("testbackup")
t0 = runs[0].start_time
t1 = runs[1].start_time
t2 = runs[2].start_time
for t, exists, contents in [(t0, False, None), (t1, True, "1"), (t2, True, "2"), (None, True, "2")]:
# Attempt to restore most recent of ALL files
# This tests the default restore.
r = Restore(self.restore_folder, [self.files_folder], t, self.options)
r.run()
if exists:
with open(restore_file, "r") as f:
self.assertEqual(f.read(), contents)
else:
self.assertFalse(os.path.exists(restore_file))
# clean
shutil.rmtree(self.restore_folder)
utils.makedirs(self.restore_folder)
def test7bitFilenames(self):
# Make some 7 bit filenames
strange_folder = os.path.join(self.files_folder, "strange")
utils.makedirs(strange_folder)
for i in xrange(1, 117, 10):
name = "".join([chr(j) for j in xrange(i, i + 10) if chr(j) != "/"])
path = os.path.join(strange_folder, name)
with open(path, "w") as f:
f.write(os.urandom(100))
self.backup_restore_compare()
def testUnicodeFilenames(self):
# Make some unicode bit filenames
# Clean out the ordinary files
shutil.rmtree(self.files_folder)
utils.makedirs(self.files_folder)
unicode_folder = os.path.join(unicode(self.files_folder), u"unicode")
utils.makedirs(unicode_folder)
for i in xrange(1000, 1200, 10):
name = u"".join([unichr(j) for j in xrange(i, i + 10) if unichr(j) != u"/"])
path = os.path.join(unicode_folder, name)
with open(path, "w") as f:
f.write(os.urandom(10))
self.backup_restore_compare()
def backup_restore_compare(self):
# Run a full backup
b = Run("testbackup", const.FullBackup, self.options)
b.run()
# Make sure we have ticked to another second since the start of the last backup.
while datetime.now() - b.start_time < timedelta(seconds=1):
time.sleep(0.01)
# Attempt to restore every file
r = Restore(self.restore_folder, [self.files_folder],
datetime.now(), self.options)
r.run()
# Check that the restored folder and original folder are identical
left = unicode(self.files_folder)
right = unicode(os.path.join(self.restore_folder, self.files_folder[1:]))
d = utils.dircmp(left, right)
self.assertEqual(d.left_only, set())
self.assertEqual(d.right_only, set())
self.assertEqual(d.diff_files, set())
self.assertTrue(len(d.same_files) > 0)
# Check that all files are in the DB
for folder, _, local_files in os.walk(self.files_folder):
for file in local_files:
path = os.path.join(file, folder)
# This will raise an exception if it does not exist
self.db.select_path(path, build=False)
############################################################################
#
# Utility Routines
#
############################################################################
def mark_db_ids(self):
self.max_fs_id = self.db.query("select max(fs_id) from fs", ())[0][0]
if self.max_fs_id is None:
self.max_fs_id = 0
self.max_version_id = self.db.query("select max(version_id) from versions", ())[0][0]
if self.max_version_id is None:
self.max_version_id = 0
self.max_run_id = self.db.query("select max(run_id) from runs", ())[0][0]
if self.max_run_id is None:
self.max_run_id = 0
self.max_message_id = self.db.query("select max(message_id) from messages", ())[0][0]
if self.max_message_id is None:
self.max_message_id = 0
def clean_db(self):
self.db.execute("delete from messages where message_id > ?", (self.max_message_id,))
self.db.execute("delete from versions where version_id > ?", (self.max_version_id,))
self.db.execute("delete from fs where fs_id > ?", (self.max_fs_id,))
self.db.execute("delete from runs where run_id > ?", (self.max_run_id,))
exp.send("tooltest\n")
if (exp.expect(["Smartphone Pentest Framework Agent"], timeout)):
agent = "yes"
exp.send("exit")
exp.close()
fullpath2 = webserver + path + "/text2.txt"
GETFILE = open(fullpath2, 'w')
GETFILE.write("Apline Agent " + agent)
GETFILE.close()
table = "remote"
db = DB(config=config)
alpine = "alpine"
db.query("INSERT INTO "+table+" (id,ip,exploit,vuln,agent) VALUES (DEFAULT,%s,%s,%s,%s)", (ipaddress,alpine,vulnerable,agent))
elif arsplit[1] == "evil" :
print "Something something\n"
webserver = config.get('WEBSERVER')
sqlserver = config.get('MYSQLSERVER')
ipaddress = config.get('IPADDRESS')
localpath = arsplit[2]
filename = arsplit[3]
link = "http://" + ipaddress + localpath + filename
fullpath = webserver + localpath
command1 = "mkdir " + fullpath
system(command1)
sploitfile = webserver + localpath + filename
command8 = "touch " + sploitfile
system(command8)
system(command8)
command9 = "chmod 777 " + sploitfile
system(command9)
results = webserver + localpath + "/results"
command8 = "touch " + results
system(command8)
command9 = "chmod 777 " + results
system(command9)
sploitfiletext = "<?php\necho \"You Got Phished!\";\n$agent = $_SERVER['HTTP_USER_AGENT'];\n$page = " + x + ";\n$thing = $page . \" \" . $agent;\n$file = results;\n$current = file_get_contents($file);\n$current .= $thing . \"\\n\";\nfile_put_contents($file, $current);\n?>"
SPLOITFILE = open(sploitfile, 'w')
SPLOITFILE.write(sploitfiletext)
SPLOITFILE.close()
modem = 1
db = DB(config=config)
db.query("SELECT path from modems where id=%s", (modem,))
path2 = db.fetchone()[0].replace('"', '')
print path2
db.query("SELECT controlkey from modems where id=%s", (modem,))
key2 = db.fetchone()[0]
print key2
db.query("SELECT type from modems where id=%s", (modem,))
modemtype2 = db.fetchone()[0]
control = webserver + path2 + "/getfunc"
sleep(5)
with open(control, 'w') as f:
msg = "This is a cool page: "
command2 = key2 + " " + "SEND" + " " + x + " " + msg + link
f.write(command2)