def __init__(self, name, formation_type):
self.name = name
self.common_image_dir = constant.BATTLE_COMMON_IMAGE_DIR
self.war_dir = os.path.join(constant.WARS_DIR, self.name)
self.war_image_dir = os.path.join(self.war_dir, 'image')
self.inventory = Inventory()
self.restore = Restore()
self.formation = Formation(formation_type)
def map(rbd, snap):
restore = Restore(rbd, snap)
status = restore.mount()
if status is None:
return send_json({'success': False, 'path': None}, code=500)
else:
status = status.replace('/tmp/', '')
return send_json({'success': True, 'path': status})
def ls_snaps(rbd):
restore = Restore(rbd)
data = restore.ls()
result = list()
for i in data:
result.append({
'creation_date': str(i['creation']),
'uuid': i['uuid'],
})
return send_json(result)
class Battle:
""" handle how to execute battle flow"""
def __init__(self, name, formation_type):
self.name = name
self.common_image_dir = constant.BATTLE_COMMON_IMAGE_DIR
self.war_dir = os.path.join(constant.WARS_DIR, self.name)
self.war_image_dir = os.path.join(self.war_dir, 'image')
self.inventory = Inventory()
self.restore = Restore()
self.formation = Formation(formation_type)
def run(self, device):
rounds = 0
presetting = ImageForPresetting(
os.path.join(constant.BATTLE_COMMON_IMAGE_DIR, 'combat'))
while True:
presetting.click_somewhere_to_wait(device)
try:
self.restore.check(device)
if self.formation.formation_type:
self.run_formation(device)
self.enter_combat(device)
while self.inventory.hit_limit(device):
self.enter_combat(device)
self.apply_flow(device)
self.battle_flow(device)
if self.formation.formation_type:
self.formation.already_change = False
except Exception as error:
print(error)
continue
rounds += 1
print("The round :" + str(rounds))
def run_formation(self, device):
if self.formation and not self.formation.already_change:
self.formation.run(device)
self.formation.already_change = True
def enter_combat(self, device):
enter_combat = CommonFlow(self.war_dir, self.war_image_dir,
'enter.xlsx')
enter_combat.run(device)
def apply_flow(self, device):
apply_team = CommonFlow(self.war_dir, self.war_image_dir, 'apply.xlsx')
apply_team.run(device)
def battle_flow(self, device):
battle = CommonFlow(self.war_dir, self.common_image_dir,
self.name + '.xlsx')
battle.run(device)
def ls():
restore = Restore()
data = restore.ls()
result = list()
for i in data:
result.append({
'ident': i['ident'],
'disk': i['disk'],
'uuid': i['uuid'],
})
return send_json(result)
def schedule_backup_restore(self, backup_id, destination_uri,tags=None,
no_index_restore=None, no_users_restore=None, no_roles_restore=None,
source_database_name=None):
backup = get_mbs().backup_collection.get_by_id(backup_id)
destination = build_backup_source(destination_uri)
logger.info("Scheduling a restore for backup '%s'" % backup.id)
restore = Restore()
restore.state = State.SCHEDULED
restore.source_backup = backup
restore.source_database_name = source_database_name
restore.strategy = backup.strategy
restore.strategy.no_index_restore = no_index_restore
restore.strategy.no_users_restore = no_users_restore
restore.strategy.no_roles_restore = no_roles_restore
restore.destination = destination
# resolve tags
tags = tags or restore.source_backup.tags
restore.tags = tags
rc = get_mbs().restore_collection
try:
self._resolve_task_tags(restore)
except Exception, ex:
self._task_failed_to_schedule(restore, rc, ex)
def post(self):
self.response.headers['Content-Type'] = 'text/html'
if self.request.get('button') == 'Bin':
email_id = self.request.get('email_id')
all_files = Restore.query(Restore.user == email_id).fetch()
user = users.get_current_user()
logout = users.create_logout_url('/')
template_values = {
'all_files': all_files,
'email_id': email_id,
'user': user,
'logout': logout
}
template = JINJA_ENVIRONMENT.get_template('restorefile.html')
self.response.write(template.render(template_values))
if self.request.get('button') == 'Restore':
email_id = self.request.get('email_id')
file_id = self.request.get('file_id')
file_key = ndb.Key(Restore, file_id)
file = file_key.get()
directory_id = email_id + '/'
directory_key = ndb.Key(Directory, directory_id)
directory = directory_key.get()
directory.list_of_files.append(file.file_name)
directory.blobs.append(file.blob_key)
directory.put()
file_key.delete()
self.redirect('/main')
def restore_processor(self):
if not self._restore_processor:
self._restore_processor = TaskQueueProcessor(
"Restores",
Restore().type_name,
"restores",
self,
self._max_workers,
sleep_time=self.sleep_time)
return self._restore_processor
hooks.restore.pre()
if not backup_extract_path:
backup_extract_path = get_backup_extract()
extras_paths = backup.ExtrasPaths(backup_extract_path)
if not isdir(extras_paths.path):
fatal("missing %s directory - this doesn't look like a system backup" % extras_paths.path)
os.environ['TKLBAM_BACKUP_EXTRACT_PATH'] = backup_extract_path
if not silent:
print fmt_title("Restoring system from backup extract at " + backup_extract_path)
restore = Restore(backup_extract_path, limits=opt_limits, rollback=not no_rollback, simulate=opt_simulate)
if restore.conf:
os.environ['TKLBAM_RESTORE_PROFILE_ID'] = restore.conf.profile_id
hooks.restore.inspect(restore.extras.path)
if opt_debug:
print """\
The --debug option has (again) dropped you into an interactive shell so that
you can explore the state of the system just before restore. The current
working directory contains the backup extract.
To exit from the shell and continue the restore run "exit 0".
To exit from the shell and abort the restore run "exit 1".
"""
os.chdir(backup_extract_path)
def mapped():
restore = Restore()
data = restore.list_mapped()
return send_json(data)
def unmap(rbd, snap):
restore = Restore(rbd, snap)
restore.umount()
return send_json({'success': True})
def schedule_backup_restore(self,
backup_id,
destination_uri,
tags=None,
source_database_name=None):
backup = get_mbs().backup_collection.get_by_id(backup_id)
destination = build_backup_source(destination_uri)
logger.info("Scheduling a restore for backup '%s'" % backup.id)
restore = Restore()
restore.source_backup = backup
restore.source_database_name = source_database_name
restore.strategy = backup.strategy
restore.destination = destination
restore.tags = tags or restore.source_backup.tags
restore.state = STATE_SCHEDULED
restore.created_date = date_now()
logger.info("Saving restore task: %s" % restore)
restore_doc = restore.to_document()
get_mbs().restore_collection.save_document(restore_doc)
restore.id = restore_doc["_id"]
return restore
def post(self):
self.response.headers['Content-Type'] = 'text/html'
if self.request.get('button') == 'Delete' :
delete_file_name = self.request.get('delete_file_name')
directory_id = self.request.get('directory_id')
directory_key = ndb.Key(Directory,directory_id)
directory = directory_key.get()
index = int(self.request.get('index'))
blob_key = directory.blobs[index]
del directory.list_of_files[index]
del directory.blobs[index]
directory.put()
random_id = str(random.randint(000000,999999))
random_key = ndb.Key(Directory, random_id)
random_value = random_key.get()
if random_value != None:
while (random_value != None):
random_id = str(random.randint(000000, 999999))
random_key = ndb.Key(Directory, random_id)
random_value = random_key.get()
if random_value == None:
new_file = Restore(id=random_id)
new_file.put()
new_file_key = ndb.Key(Restore,random_id)
file = new_file_key.get()
file.file_name = delete_file_name
file.blob_key = blob_key
user = users.get_current_user()
email = user.email()
file.user = email
file.put()
self.redirect('/main')
if self.request.get('button') == 'Delete Permanently':
file_id = self.request.get('file_id')
file_key = ndb.Key(Restore,file_id)
file = file_key.get()
print(file)
blob_key = file.blob_key
file_key.delete()
blobstore.delete(blob_key)
self.redirect('/main')
if self.request.get('button') == 'Delete Shared File' :
directory_id = self.request.get('directory_id')
directory_key = ndb.Key(Directory,directory_id)
directory = directory_key.get()
delete_file_name = self.request.get('delete_file_name')
index = int(self.request.get('index'))
del directory.shared_files[index]
del directory.shared_files_blobs[index]
del directory.shared_file_owner[index]
directory.put()
self.redirect('/main')
extras_paths = backup.ExtrasPaths(backup_extract_path)
if not isdir(extras_paths.path):
fatal(
"missing %s directory - this doesn't look like a system backup"
% extras_paths.path)
os.environ['TKLBAM_BACKUP_EXTRACT_PATH'] = backup_extract_path
if not silent:
print fmt_title("Restoring system from backup extract at " +
backup_extract_path)
restore = Restore(backup_extract_path,
limits=opt_limits,
rollback=not no_rollback,
simulate=opt_simulate)
if restore.conf:
os.environ['TKLBAM_RESTORE_PROFILE_ID'] = restore.conf.profile_id
hooks.restore.inspect(restore.extras.path)
if opt_debug:
print """\
The --debug option has (again) dropped you into an interactive shell so that
you can explore the state of the system just before restore. The current
working directory contains the backup extract.
To exit from the shell and continue the restore run "exit 0".
To exit from the shell and abort the restore run "exit 1".
"""
def restore_images(trained_model, corrupter, net_name):
paths = read_paths.list_paths(TEST_PATH.replace(TO_REPLACE, net_name))
restore = Restore()
for i, path in enumerate(paths):
restore_image(trained_model, restore, corrupter, read_image(path), i, net_name)
# testdataAll = np.loadtxt("E:/WiFi/实验室6楼/wifiData/实验/1.2m_human.csv", dtype=float, delimiter=',')[:,3:]
font1 = {'family' : 'Times New Roman',
'weight' : 'normal',
'size' : 20,}
modelPath = 'model/GP/'
inputNum = 2
interval = 19
scaler = StandardScaler().fit(dataAll[:,:inputNum])
ax = []
err = np.zeros([len(testdataAll),len(testdataAll[0])-2])
for Ap in range(0,interval):
testAP = inputNum + Ap
testAPBand = testAP + interval
testdata = testdataAll[testdataAll[:,testAP]!=-100,:]
dataRaw = dataAll[dataAll[:, testAP] != -100]
y,dy,reData = Restore(dataAll=dataAll,gap=interval,inputN=inputNum,num=Ap)
y[y[:]==-100]=default
X = dataAll[:,:inputNum]
kernel = 1.0* RBF(length_scale=1.0, length_scale_bounds=(1e-2, 1e3)) \
+WhiteKernel(noise_level=1)
gpr = GaussianProcessRegressor(kernel=kernel, normalize_y=True)
stime = time.time()
gpr.fit(scaler.transform(X), y)
print("Time for GPR fitting: %.3f" % (time.time() - stime))
X_predict =grid[:,:2]
# Predict using gaussian process regressor
stime = time.time()
class Ui_RestoreFilesDialog(object):
def __init__(self):
self.restore_obj = Restore()
self.files_to_restore = self.restore_obj.getFiles()
def setupUi(self, Dialog):
Dialog.setObjectName("Dialog")
Dialog.resize(400, 200)
self.verticalLayout = QtWidgets.QVBoxLayout(Dialog)
self.verticalLayout.setObjectName("verticalLayout")
self.tableWidget = QtWidgets.QTableWidget(Dialog)
self.tableWidget.setObjectName("tableWidget")
self.tableWidget.setColumnCount(4)
self.tableWidget.setRowCount(len(self.files_to_restore))
self.tableWidget.setSelectionBehavior(QtWidgets.QTableView.SelectRows)
item = QtWidgets.QTableWidgetItem()
self.tableWidget.setHorizontalHeaderItem(0, item)
item = QtWidgets.QTableWidgetItem()
self.tableWidget.setHorizontalHeaderItem(1, item)
item = QtWidgets.QTableWidgetItem()
self.tableWidget.setHorizontalHeaderItem(2, item)
item = QtWidgets.QTableWidgetItem()
self.tableWidget.setHorizontalHeaderItem(3, item)
self.verticalLayout.addWidget(self.tableWidget)
self.horizontalLayout = QtWidgets.QHBoxLayout()
self.horizontalLayout.setObjectName("horizontalLayout")
self.pushButton_2 = QtWidgets.QPushButton(Dialog)
self.pushButton_2.setObjectName("pushButton_2")
self.horizontalLayout.addWidget(self.pushButton_2)
self.pushButton = QtWidgets.QPushButton(Dialog)
self.pushButton.setObjectName("pushButton")
self.horizontalLayout.addWidget(self.pushButton)
self.verticalLayout.addLayout(self.horizontalLayout)
self.retranslateUi(Dialog)
QtCore.QMetaObject.connectSlotsByName(Dialog)
row_count = 0
for file_to_restore in self.files_to_restore :
self.tableWidget.setItem(row_count,0, QtWidgets.QTableWidgetItem(file_to_restore[0]))
self.tableWidget.setItem(row_count,1, QtWidgets.QTableWidgetItem(file_to_restore[1]))
self.tableWidget.setItem(row_count,2, QtWidgets.QTableWidgetItem(file_to_restore[2]))
self.tableWidget.setItem(row_count,3, QtWidgets.QTableWidgetItem("NO"))
row_count += 1
self.tableWidget.move(0, 0)
self.pushButton_2.clicked.connect(Dialog.reject)
self.pushButton.clicked.connect(self.restoreClick)
def restoreClick(self):
index = self.tableWidget.selectedIndexes()[1]
selected_backup_file = self.tableWidget.model().data(index).rstrip()
self.restore_obj.restoreFiles(selected_backup_file)
def retranslateUi(self, Dialog):
_translate = QtCore.QCoreApplication.translate
Dialog.setWindowTitle(_translate("Dialog", "Restoration files"))
item = self.tableWidget.horizontalHeaderItem(0)
item.setText(_translate("Dialog", "Date"))
item = self.tableWidget.horizontalHeaderItem(1)
item.setText(_translate("Dialog", "File"))
item = self.tableWidget.horizontalHeaderItem(2)
item.setText(_translate("Dialog", "Size"))
item = self.tableWidget.horizontalHeaderItem(3)
item.setText(_translate("Dialog", "Infected"))
self.pushButton_2.setText(_translate("Dialog", "Cancel"))
self.pushButton.setText(_translate("Dialog", "Restore"))
def __init__(self):
self.restore_obj = Restore()
self.files_to_restore = self.restore_obj.getFiles()
