def r_resume(uuids):
args_rules = [Rules.UUIDS.value]
try:
ji.Check.previewing(args_rules, {'uuids': uuids})
guest = Guest()
for uuid in uuids.split(','):
guest.uuid = uuid
guest.get_by('uuid')
for uuid in uuids.split(','):
guest.uuid = uuid
guest.get_by('uuid')
message = {
'_object': 'guest',
'action': 'resume',
'uuid': uuid,
'hostname': guest.on_host
}
Guest.emit_instruction(message=json.dumps(message))
ret = dict()
ret['state'] = ji.Common.exchange_state(20000)
return ret
except ji.PreviewingError, e:
return json.loads(e.message)
def r_update(uuid):
args_rules = [Rules.UUID.value]
if 'remark' in request.json:
args_rules.append(Rules.REMARK.value, )
if args_rules.__len__() < 2:
ret = dict()
ret['state'] = ji.Common.exchange_state(20000)
return ret
request.json['uuid'] = uuid
try:
ji.Check.previewing(args_rules, request.json)
guest = Guest()
guest.uuid = uuid
guest.get_by('uuid')
guest.remark = request.json.get('remark', guest.label)
guest.update()
guest.get()
ret = dict()
ret['state'] = ji.Common.exchange_state(20000)
ret['data'] = guest.__dict__
return ret
except ji.PreviewingError, e:
return json.loads(e.message)
def add():
name = request.form.get('name')
domain = request.form.get('domain')
guest = Guest(name, domain, request.remote_addr)
guest.commit()
return redirect('/manage/')
def add():
name = request.form.get('name')
domain = request.form.get('domain')
guest = Guest(name, domain, request.remote_addr)
guest.commit()
return redirect('/manage/')
def post(self):
name = self.request.get('name')
veg = (self.request.get("veg", default_value="false") == "true")
new_guest = Guest(name=name, vegetarian=veg)
new_guest.put()
self.redirect_to("signup")
def r_get_uuids_of_all_had_boot_job():
guest = Guest()
try:
ret = dict()
ret['state'] = ji.Common.exchange_state(20000)
ret['data'] = guest.get_uuids_of_all_had_boot_job()
return ret
except ji.PreviewingError, e:
return json.loads(e.message)
def r_detach_disk(disk_uuid):
args_rules = [Rules.DISK_UUID.value]
try:
ji.Check.previewing(args_rules, {'disk_uuid': disk_uuid})
disk = Disk()
disk.uuid = disk_uuid
disk.get_by('uuid')
ret = dict()
ret['state'] = ji.Common.exchange_state(20000)
if disk.state != DiskState.mounted.value or disk.sequence == 0:
# 表示未被任何实例使用，已被分离
# 序列为 0 的表示实例系统盘，系统盘不可以被分离
# TODO: 系统盘单独范围其它状态
return ret
guest = Guest()
guest.uuid = disk.guest_uuid
guest.get_by('uuid')
# 判断 Guest 是否处于可用状态
if guest.status in (status.GuestState.no_state.value,
status.GuestState.dirty.value):
ret['state'] = ji.Common.exchange_state(41259)
return ret
config = Config()
config.id = 1
config.get()
guest_xml = GuestXML(guest=guest, disk=disk, config=config)
message = {
'_object': 'guest',
'action': 'detach_disk',
'uuid': disk.guest_uuid,
'node_id': guest.node_id,
'xml': guest_xml.get_disk(),
'passback_parameters': {
'disk_uuid': disk.uuid
}
}
Utils.emit_instruction(message=json.dumps(message))
disk.state = DiskState.unloading.value
disk.update()
return ret
except ji.PreviewingError, e:
return json.loads(e.message)
def update_ssh_key(uuid):
guest = Guest()
guest.uuid = uuid
guest.get_by('uuid')
# 不支持更新离线虚拟机的 SSH-KEY
if guest.status != GuestState.running.value:
return
os_template_image = OSTemplateImage()
os_template_profile = OSTemplateProfile()
os_template_image.id = guest.os_template_image_id
os_template_image.get()
os_template_profile.id = os_template_image.os_template_profile_id
os_template_profile.get()
# 不支持更新 Windows 虚拟机的 SSH-KEY
if os_template_profile.os_type == 'windows':
return
rows, _ = SSHKeyGuestMapping.get_by_filter(
filter_str=':'.join(['guest_uuid', 'eq', uuid]))
ssh_keys_id = list()
for row in rows:
ssh_keys_id.append(row['ssh_key_id'].__str__())
ssh_keys = list()
if ssh_keys_id.__len__() > 0:
rows, _ = SSHKey.get_by_filter(
filter_str=':'.join(['id', 'in', ','.join(ssh_keys_id)]))
for row in rows:
ssh_keys.append(row['public_key'])
else:
ssh_keys.append('')
message = {
'_object': 'guest',
'uuid': uuid,
'node_id': guest.node_id,
'action': 'update_ssh_key',
'ssh_keys': ssh_keys,
'os_type': os_template_profile.os_type,
'passback_parameters': {
'uuid': uuid,
'ssh_keys': ssh_keys,
'os_type': os_template_profile.os_type
}
}
Utils.emit_instruction(message=json.dumps(message, ensure_ascii=False))
def r_adjust_ability(uuids, cpu, memory):
args_rules = [
Rules.UUIDS.value,
Rules.CPU.value,
Rules.MEMORY.value,
]
try:
ret = dict()
ret['state'] = ji.Common.exchange_state(20000)
cpu = int(cpu)
memory = int(memory)
ji.Check.previewing(args_rules, {'uuids': uuids, 'cpu': cpu, 'memory': memory})
not_ready_yet_of_guests = list()
guest = Guest()
# 检测所指定的 UUDIs 实例都存在。且状态都为可以操作状态（即关闭状态）。
for uuid in uuids.split(','):
guest.uuid = uuid
guest.get_by('uuid')
if guest.status != status.GuestState.shutoff.value:
not_ready_yet_of_guests.append(guest.__dict__)
if not_ready_yet_of_guests.__len__() > 0:
ret['state'] = ji.Common.exchange_state(41261)
ret['data'] = not_ready_yet_of_guests
return ret
for uuid in uuids.split(','):
guest.uuid = uuid
guest.get_by('uuid')
guest.cpu = cpu
guest.memory = memory
message = {
'_object': 'guest',
'action': 'adjust_ability',
'uuid': guest.uuid,
'node_id': guest.node_id,
'cpu': guest.cpu,
'memory': guest.memory,
'passback_parameters': {'cpu': guest.cpu, 'memory': guest.memory}
}
Utils.emit_instruction(message=json.dumps(message, ensure_ascii=False))
return ret
except ji.PreviewingError, e:
return json.loads(e.message)
def r_get_boot_jobs(uuids):
args_rules = [Rules.UUIDS.value]
try:
ji.Check.previewing(args_rules, {'uuids': uuids})
guest = Guest()
for uuid in uuids.split(','):
guest.uuid = uuid
guest.get_by('uuid')
ret = dict()
ret['state'] = ji.Common.exchange_state(20000)
if uuids.split(',').__len__() > 1:
ret['data'] = dict()
for uuid in uuids.split(','):
guest.uuid = uuid
boot_jobs = dict()
boot_jobs['ttl'], boot_jobs['boot_jobs'] = guest.get_boot_jobs(
)
ret['data'][uuid] = boot_jobs
else:
guest.uuid = uuids
ret['data'] = dict()
ret['data']['ttl'], ret['data']['boot_jobs'] = guest.get_boot_jobs(
)
return ret
except ji.PreviewingError, e:
return json.loads(e.message)
def post(self):
ime_priimek = self.request.get("ImePriimek")
if ime_priimek == "":
ime_priimek = "neznanec"
e_posta = self.request.get("E_mail")
message_ = self.request.get("Message")
guest = Guest(ImePriimek = ime_priimek, E_mail = e_posta, Message = message_)
guest.put()
self.write("Hvala za sporocilo. Vas kontaktiramo v kratkem!")
self.redirect_to("seznam-gostov")
def r_delete(uuids):
args_rules = [
Rules.UUIDS.value
]
# TODO: 加入是否删除使用的数据磁盘开关，如果为True，则顺便删除使用的磁盘。否则解除该磁盘被使用的状态。
try:
ji.Check.previewing(args_rules, {'uuids': uuids})
guest = Guest()
# 检测所指定的 UUDIs 实例都存在
for uuid in uuids.split(','):
guest.uuid = uuid
guest.get_by('uuid')
config = Config()
config.id = 1
config.get()
# 执行删除操作
for uuid in uuids.split(','):
guest.uuid = uuid
guest.get_by('uuid')
message = {
'_object': 'guest',
'action': 'delete',
'uuid': uuid,
'storage_mode': config.storage_mode,
'dfs_volume': config.dfs_volume,
'node_id': guest.node_id
}
Utils.emit_instruction(message=json.dumps(message))
# 删除创建失败的 Guest
if guest.status == status.GuestState.dirty.value:
disk = Disk()
disk.uuid = guest.uuid
disk.get_by('uuid')
if disk.state == status.DiskState.pending.value:
disk.delete()
guest.delete()
SSHKeyGuestMapping.delete_by_filter(filter_str=':'.join(['guest_uuid', 'eq', guest.uuid]))
ret = dict()
ret['state'] = ji.Common.exchange_state(20000)
return ret
except ji.PreviewingError, e:
return json.loads(e.message)
def r_migrate(uuids, destination_host):
args_rules = [
Rules.UUIDS.value,
Rules.DESTINATION_HOST.value
]
try:
ji.Check.previewing(args_rules, {'uuids': uuids, 'destination_host': destination_host})
ret = dict()
ret['state'] = ji.Common.exchange_state(20000)
# 取全部活着的 hosts
available_hosts = Host.get_available_hosts(nonrandom=None)
if available_hosts.__len__() == 0:
ret['state'] = ji.Common.exchange_state(50351)
return ret
available_hosts_mapping_by_node_id = dict()
for host in available_hosts:
if host['node_id'] not in available_hosts_mapping_by_node_id:
available_hosts_mapping_by_node_id[host['node_id']] = host
guest = Guest()
for uuid in uuids.split(','):
guest.uuid = uuid
guest.get_by('uuid')
config = Config()
config.id = 1
config.get()
for uuid in uuids.split(','):
guest.uuid = uuid
guest.get_by('uuid')
# 忽略宕机计算节点 上面的 虚拟机 迁移请求
# 忽略目标计算节点 等于 当前所在 计算节点 的虚拟机 迁移请求
if guest.node_id not in available_hosts_mapping_by_node_id or \
available_hosts_mapping_by_node_id[guest.node_id]['hostname'] == destination_host:
continue
message = {
'_object': 'guest',
'action': 'migrate',
'uuid': uuid,
'node_id': guest.node_id,
'storage_mode': config.storage_mode,
'duri': 'qemu+ssh://' + destination_host + '/system'
}
Utils.emit_instruction(message=json.dumps(message))
return ret
except ji.PreviewingError, e:
return json.loads(e.message)
def r_force_reboot(uuids):
args_rules = [Rules.UUIDS.value]
try:
ji.Check.previewing(args_rules, {'uuids': uuids})
guest = Guest()
for uuid in uuids.split(','):
guest.uuid = uuid
guest.get_by('uuid')
for uuid in uuids.split(','):
guest.uuid = uuid
guest.get_by('uuid')
disks, _ = Disk.get_by_filter(
filter_str=':'.join(['guest_uuid', 'eq', guest.uuid]))
message = {
'_object': 'guest',
'action': 'force_reboot',
'uuid': uuid,
'node_id': guest.node_id,
'disks': disks
}
Utils.emit_instruction(message=json.dumps(message))
ret = dict()
ret['state'] = ji.Common.exchange_state(20000)
return ret
except ji.PreviewingError, e:
return json.loads(e.message)
def r_delete(uuids):
args_rules = [Rules.UUIDS.value]
try:
ji.Check.previewing(args_rules, {'uuids': uuids})
ret = dict()
ret['state'] = ji.Common.exchange_state(20000)
disk = Disk()
# 检测所指定的 UUDIs 磁盘都存在
for uuid in uuids.split(','):
disk.uuid = uuid
disk.get_by('uuid')
if disk.state != DiskState.idle.value:
ret['state'] = ji.Common.exchange_state(41256)
return ret
config = Config()
config.id = 1
config.get()
# 执行删除操作
for uuid in uuids.split(','):
disk.uuid = uuid
disk.get_by('uuid')
message = {
'_object': 'disk',
'action': 'delete',
'uuid': disk.uuid,
'storage_mode': config.storage_mode,
'dfs_volume': config.dfs_volume,
'hostname': disk.on_host,
'image_path': disk.path
}
if disk.on_host == 'shared_storage':
message['hostname'] = Guest.get_lightest_host()['hostname']
Guest.emit_instruction(
message=json.dumps(message, ensure_ascii=False))
return ret
except ji.PreviewingError, e:
return json.loads(e.message)
def r_delete_boot_jobs(uuids, boot_jobs_id):
args_rules = [Rules.UUIDS.value, Rules.BOOT_JOBS_ID.value]
try:
ji.Check.previewing(args_rules, {
'uuids': uuids,
'boot_jobs_id': boot_jobs_id
})
guest = Guest()
# 检测所指定的 UUDIs 实例都存在
for uuid in uuids.split(','):
guest.uuid = uuid
guest.get_by('uuid')
for uuid in uuids.split(','):
guest.uuid = uuid
guest.delete_boot_jobs(boot_jobs_id=boot_jobs_id.split(','))
ret = dict()
ret['state'] = ji.Common.exchange_state(20000)
return ret
except ji.PreviewingError, e:
return json.loads(e.message)
def r_resize(uuid, size):
args_rules = [Rules.UUID.value, Rules.DISK_SIZE_STR.value]
try:
ji.Check.previewing(args_rules, {'uuid': uuid, 'size': size})
disk = Disk()
disk.uuid = uuid
disk.get_by('uuid')
ret = dict()
ret['state'] = ji.Common.exchange_state(20000)
if disk.size >= size:
ret['state'] = ji.Common.exchange_state(41257)
return ret
config = Config()
config.id = 1
config.get()
message = {
'_object': 'disk',
'action': 'resize',
'uuid': disk.uuid,
'guest_uuid': disk.guest_uuid,
'storage_mode': config.storage_mode,
'size': int(size),
'dfs_volume': config.dfs_volume,
'hostname': disk.on_host,
'image_path': disk.path,
'passback_parameters': {
'size': size
}
}
if disk.on_host == 'shared_storage':
message['hostname'] = Guest.get_lightest_host()['hostname']
if disk.guest_uuid.__len__() == 36:
message['device_node'] = dev_table[disk.sequence]
Guest.emit_instruction(message=json.dumps(message, ensure_ascii=False))
return ret
except ji.PreviewingError, e:
return json.loads(e.message)
def guest_new():
guest = Guest()
if request.method == 'POST':
form = GuestForm(request.form, obj=guest)
if form.validate():
try:
form.populate_obj(guest)
validate_guest(guest)
guest.save()
flash('Yes, hóspede cadastrado com sucesso.', 'success')
return redirect(url_for('guests.guest_index'))
except AttributeError as e:
flash(str(e), 'warning')
else:
form = GuestForm(obj=guest)
return render_template('guests/new.html', form=form)
def rsvp():
error = None
formfilled = request.cookies.get('rsvpstat')
if formfilled == '1':
return redirect(url_for('thankyou'))
if request.method == 'POST':
if 'inputName' in request.form:
if request.form['inputName'] == '':
error = "Name field cannot be blank."
return render_template('rsvp.html', error=error)
else:
inputName = request.form['inputName']
if 'inputGuest' in request.form:
inputGuest = request.form['inputGuest']
if 'inputEmail' in request.form:
inputEmail = request.form['inputEmail']
if 'decision' in request.form:
if request.form['decision'] == 'attending':
inputDecision = "Yes"
else:
inputDecision = "No"
if 'inputComment' in request.form:
inputComment = request.form['inputComment']
guest = Guest(name=inputName,
email=inputEmail,
invitename=inputGuest,
comments=inputComment,
decision=inputDecision)
db_session.add(guest)
db_session.commit()
#flash(message)
resp = make_response(redirect(url_for('thankyou')))
resp.set_cookie('rsvpstat', '1')
return resp
return render_template('rsvp.html', error=error)
def get(self):
guests = Guest.query()
message = "\r\n".join([guest.email for guest in guests])
name = "emails.txt"
self.response.headers['Content-Type'] = "text/plain"
self.response.headers['Content-Disposition'] = 'attachment; filename=' + name
self.response.out.write(message)
def get(self):
domains_dict = get_domain_dict(Guest.query())
template_values = {
'domains_dict': domains_dict,
}
template = JINJA_ENVIRONMENT.get_template('emails.html')
self.response.write(template.render(template_values))
def r_create():
args_rules = [
Rules.GUEST_UUID.value
]
if 'label' in request.json:
args_rules.append(
Rules.LABEL.value,
)
try:
ret = dict()
ret['state'] = ji.Common.exchange_state(20000)
ji.Check.previewing(args_rules, request.json)
snapshot = Snapshot()
guest = Guest()
guest.uuid = request.json.get('guest_uuid')
guest.get_by('uuid')
snapshot.label = request.json.get('label', '')
snapshot.status = guest.status
snapshot.guest_uuid = guest.uuid
snapshot.snapshot_id = '_'.join(['tmp', ji.Common.generate_random_code(length=8)])
snapshot.parent_id = '-'
snapshot.progress = 0
snapshot.create()
snapshot.get_by('snapshot_id')
message = {
'_object': 'snapshot',
'action': 'create',
'uuid': guest.uuid,
'node_id': guest.node_id,
'passback_parameters': {'id': snapshot.id}
}
Utils.emit_instruction(message=json.dumps(message, ensure_ascii=False))
ret['data'] = snapshot.__dict__
return ret
except ji.PreviewingError, e:
return json.loads(e.message)
def r_reset_password(uuids, password):
args_rules = [
Rules.UUIDS.value,
Rules.PASSWORD.value
]
try:
ji.Check.previewing(args_rules, {'uuids': uuids, 'password': password})
guest = Guest()
os_template_image = OSTemplateImage()
os_template_profile = OSTemplateProfile()
# 检测所指定的 UUDIs 实例都存在
for uuid in uuids.split(','):
guest.uuid = uuid
guest.get_by('uuid')
for uuid in uuids.split(','):
guest.uuid = uuid
guest.get_by('uuid')
os_template_image.id = guest.os_template_image_id
os_template_image.get()
os_template_profile.id = os_template_image.os_template_profile_id
os_template_profile.get()
user = '******'
if os_template_profile.os_type == 'windows':
user = '******'
# guest.password 由 guest 事件处理机更新。参见 @models/event_processory.py:189 附近。
message = {
'_object': 'guest',
'action': 'reset_password',
'uuid': guest.uuid,
'node_id': guest.node_id,
'os_type': os_template_profile.os_type,
'user': user,
'password': password,
'passback_parameters': {'password': password}
}
Utils.emit_instruction(message=json.dumps(message, ensure_ascii=False))
ret = dict()
ret['state'] = ji.Common.exchange_state(20000)
return ret
except ji.PreviewingError, e:
return json.loads(e.message)
def guests_add(request, event_id):
event = get_object_or_404(Event, id=event_id)
guest = Guest(event=event)
form = GuestAddForm(instance=guest, data=(request.POST or None))
if form.is_valid():
form.save()
return redirect(event)
template = "events/_guests_add.html" if request.is_ajax() else "events/guests_add.html"
return render_to_response(template, locals(), context_instance=RequestContext(request))
def r_delete(snapshots_id):
args_rules = [
Rules.SNAPSHOTS_ID.value
]
try:
ji.Check.previewing(args_rules, {'snapshots_id': snapshots_id})
snapshot = Snapshot()
guest = Guest()
# 检测所指定的 快照 都存在
for snapshot_id in snapshots_id.split(','):
snapshot.snapshot_id = snapshot_id
snapshot.get_by('snapshot_id')
guest.uuid = snapshot.guest_uuid
guest.get_by('uuid')
# 执行删除操作
for snapshot_id in snapshots_id.split(','):
snapshot.snapshot_id = snapshot_id
snapshot.get_by('snapshot_id')
guest.uuid = snapshot.guest_uuid
guest.get_by('uuid')
message = {
'_object': 'snapshot',
'action': 'delete',
'uuid': snapshot.guest_uuid,
'snapshot_id': snapshot.snapshot_id,
'node_id': guest.node_id,
'passback_parameters': {'id': snapshot.id}
}
Utils.emit_instruction(message=json.dumps(message))
# 删除创建失败的 快照
if snapshot.progress == 255:
SnapshotDiskMapping.delete_by_filter(filter_str=':'.join(['snapshot_id', 'eq', snapshot.snapshot_id]))
snapshot.delete()
else:
snapshot.progress = 254
snapshot.update()
ret = dict()
ret['state'] = ji.Common.exchange_state(20000)
return ret
except ji.PreviewingError, e:
return json.loads(e.message)
def register_guest():
from models import Guest
name = request.form.get('name')
email = request.form.get('email')
guest = Guest(name, email)
db.session.add(guest)
db.session.commit()
return render_template('guest_confirmation.html', name=name, email=email)
def get_next_spell_entry(guest_name):
guest = Guest.objects(login=guest_name).first()
spell_answers = guest.spell_answers
for spell_entry in SpellEntry.objects():
try:
key_image = get_img_key(spell_entry.image_name)
spell_answers[key_image]
except KeyError:
return spell_entry
return None
def r_migrate(uuids, destination_host):
args_rules = [Rules.UUIDS.value, Rules.DESTINATION_HOST.value]
try:
ji.Check.previewing(args_rules, {
'uuids': uuids,
'destination_host': destination_host
})
guest = Guest()
for uuid in uuids.split(','):
guest.uuid = uuid
guest.get_by('uuid')
config = Config()
config.id = 1
config.get()
for uuid in uuids.split(','):
guest.uuid = uuid
guest.get_by('uuid')
message = {
'_object': 'guest',
'action': 'migrate',
'uuid': uuid,
'hostname': guest.on_host,
'storage_mode': config.storage_mode,
'duri': 'qemu+ssh://' + destination_host + '/system'
}
Guest.emit_instruction(message=json.dumps(message))
ret = dict()
ret['state'] = ji.Common.exchange_state(20000)
return ret
except ji.PreviewingError, e:
return json.loads(e.message)
def r_revert(snapshot_id):
args_rules = [
Rules.SNAPSHOT_ID.value
]
try:
ret = dict()
ret['state'] = ji.Common.exchange_state(20000)
ji.Check.previewing(args_rules, {'snapshot_id': snapshot_id})
snapshot = Snapshot()
guest = Guest()
snapshot.snapshot_id = snapshot_id
snapshot.get_by('snapshot_id')
snapshot.progress = 253
snapshot.update()
snapshot.get()
guest.uuid = snapshot.guest_uuid
guest.get_by('uuid')
message = {
'_object': 'snapshot',
'action': 'revert',
'uuid': guest.uuid,
'snapshot_id': snapshot.snapshot_id,
'node_id': guest.node_id,
'passback_parameters': {'id': snapshot.id}
}
Utils.emit_instruction(message=json.dumps(message, ensure_ascii=False))
ret['data'] = snapshot.__dict__
return ret
except ji.PreviewingError, e:
return json.loads(e.message)
def new_guest():
form = GuestForm(request.form)
form.city.choices = [(city.id, city.desc)
for city in db.session.query(City).all()]
if request.method == 'POST' and form.validate():
guest = form.getObj(Guest())
guest.user_id = current_user.id
guest.picture = 'picna.jpg'
db.session.add(guest)
db.session.commit()
flash('Anúncio adicionado'.decode('utf-8'), 'success')
return redirect(url_for('dashboard'))
return render_template('guest/edit_guest.html',
form=form,
action='Adicionar')
def r_boot(uuids):
# TODO: 做好关系依赖判断，比如boot不可以对suspend的实例操作。
args_rules = [
Rules.UUIDS.value
]
try:
ji.Check.previewing(args_rules, {'uuids': uuids})
guest = Guest()
for uuid in uuids.split(','):
guest.uuid = uuid
guest.get_by('uuid')
config = Config()
config.id = 1
config.get()
for uuid in uuids.split(','):
guest.uuid = uuid
guest.get_by('uuid')
disks, _ = Disk.get_by_filter(filter_str=':'.join(['guest_uuid', 'eq', guest.uuid]))
message = {
'_object': 'guest',
'action': 'boot',
'uuid': uuid,
'node_id': guest.node_id,
'passback_parameters': {},
'disks': disks
}
Utils.emit_instruction(message=json.dumps(message))
ret = dict()
ret['state'] = ji.Common.exchange_state(20000)
return ret
except ji.PreviewingError, e:
return json.loads(e.message)
def create():
from models import Guest
from forms import PostForm
if request.method == 'POST':
print(request.form)
form = PostForm(request.form)
if form.validate():
post = Guest(**form.data)
db.session.add(post)
db.session.commit()
flash('Post created!')
else:
flash('Form is not valid! Post was not created.')
flash(str(form.errors))
return index()
def r_distribute_count():
from models import Guest
rows, count = Guest.get_all()
ret = dict()
ret['state'] = ji.Common.exchange_state(20000)
ret['data'] = {
'os_template_id': dict(),
'status': dict(),
'node_id': dict(),
'cpu_memory': dict(),
'cpu': 0,
'memory': 0,
'guests': rows.__len__()
}
for guest in rows:
if guest['os_template_id'] not in ret['data']['os_template_id']:
ret['data']['os_template_id'][guest['os_template_id']] = 0
if guest['status'] not in ret['data']['status']:
ret['data']['status'][guest['status']] = 0
if guest['node_id'] not in ret['data']['node_id']:
ret['data']['node_id'][guest['node_id']] = 0
cpu_memory = '_'.join([str(guest['cpu']), str(guest['memory'])])
if cpu_memory not in ret['data']['cpu_memory']:
ret['data']['cpu_memory'][cpu_memory] = 0
ret['data']['os_template_id'][guest['os_template_id']] += 1
ret['data']['status'][guest['status']] += 1
ret['data']['node_id'][guest['node_id']] += 1
ret['data']['cpu_memory'][cpu_memory] += 1
ret['data']['cpu'] += guest['cpu']
ret['data']['memory'] += guest['memory']
return ret
def r_content_search():
ret = os_template_image_base.content_search()
if '200' != ret['state']['code']:
return ret
os_template_images_id = list()
for os_template_image in ret['data']:
os_template_image_id = os_template_image['id']
if os_template_image_id not in os_template_images_id:
os_template_images_id.append(os_template_image_id)
rows, _ = Guest.get_by_filter(filter_str=':'.join([
'os_template_image_id', 'in', ','.join(
_id.__str__() for _id in os_template_images_id)
]))
os_template_image_guest_mapping = dict()
for guest in rows:
os_template_image_id = guest['os_template_image_id']
if os_template_image_id not in os_template_image_guest_mapping:
os_template_image_guest_mapping[os_template_image_id] = list()
os_template_image_guest_mapping[os_template_image_id].append(guest)
for i, os_template_image in enumerate(ret['data']):
if os_template_image['id'] in os_template_image_guest_mapping:
ret['data'][i]['guests'] = os_template_image_guest_mapping[
os_template_image['id']]
return ret
def get(self):
template_values = {
'guests': Guest.query().order(-Guest.date),
}
template = JINJA_ENVIRONMENT.get_template('guests_list.html')
self.response.write(template.render(template_values))
def get_guest(login_name):
"""
:param login_name: string
:return: Document
"""
return Guest.objects(login=login_name).first()
def get(self):
guests = Guest.all().order('-date').fetch(limit=100)
context = {"post_action": webapp2.uri_for("signup"),
"guests": guests}
self.render_response('signup.html', **context)
def post(self, guest_ID):
guest = Guest.get_by_id(int(guest_ID))
guest.izbrisan = True
guest.put()
self.redirect_to("seznam-gostov")
def guests(id=None):
if request.method == 'GET':
if id is not None:
guest = Guest.query.get(id)
if guest:
return jsonify(guest.serialize()), 200
else:
return jsonify({"msg": "guest not found"}), 404
else:
guests = Guest.query.all()
guests = list(map(lambda guest: guest.serialize(), guests))
return jsonify(guests), 200
if request.method == 'POST':
fullname = request.json.get('fullname', None)
email = request.json.get('email', None)
rol = request.json.get('rol', None)
meeting_id = request.json.get('meeting_id', None)
if not fullname:
return jsonify({"msg": "fullname is required"}), 422
guest = Guest()
guest.fullname = fullname
guest.email = email
guest.rol = rol
guest.meeting_id = meeting_id
db.session.add(guest)
db.session.commit()
return jsonify(guest.serialize()), 201
if request.method == 'PUT':
fullname = request.json.get('fullname', None)
email = request.json.get('email', None)
rol = request.json.get('rol', None)
meeting_id = request.json.get('meeting_id', None)
if not fullname:
return jsonify({"msg": "fullname is required"}), 422
guest = Guest.query.get(id)
if not guest:
return jsonify({"msg": "guest not found"}), 404
guest.fullname = fullname
guest.email = email
guest.rol = rol
guest.meeting_id = meeting_id
db.session.commit()
return jsonify(guest.serialize()), 200
if request.method == 'DELETE':
guest = Guest.query.get(id)
if not guest:
return jsonify({"msg": "guest not found"}), 404
db.session.delete(guest)
db.session.commit()
return jsonify({"msg": "guest deleted"}), 200
def post(self, guest_ID):
Message = self.request.get("Message")
guest = Guest.get_by_id(int(guest_ID))
guest.Message = Message
guest.put()
self.redirect_to("seznam-gostov")
def get(self, guest_ID):
guest = Guest.get_by_id(int(guest_ID))
params = {"guest": guest}
self.render_template("izbrisi_message.html", params=params)
def get(self, guest_ID):
guest = Guest.get_by_id(int(guest_ID))
params = {"guest": guest}
self.render_template("posamezni_gost.html", params=params)
def get(self):
seznam = Guest.query(Guest.izbrisan == False).fetch()
params = {"seznam": seznam}
self.render_template("seznam_gostov.html", params=params)
class EventProcessor(object):
message = None
log = Log()
guest = Guest()
guest_migrate_info = GuestMigrateInfo()
disk = Disk()
config = Config()
cpu_memory = CPUMemory()
traffic = Traffic()
disk_io = DiskIO()
host_cpu_memory = HostCPUMemory()
host_traffic = HostTraffic()
host_disk_usage_io = HostDiskUsageIO()
@classmethod
def log_processor(cls):
cls.log.set(type=cls.message['type'],
timestamp=cls.message['timestamp'],
host=cls.message['host'],
message=cls.message['message'],
full_message='' if cls.message['message'].__len__() < 255
else cls.message['message'])
cls.log.create()
@classmethod
def guest_event_processor(cls):
cls.guest.uuid = cls.message['message']['uuid']
cls.guest.get_by('uuid')
cls.guest.on_host = cls.message['host']
last_status = cls.guest.status
cls.guest.status = cls.message['type']
if cls.message['type'] == GuestState.update.value:
# 更新事件不改变 Guest 的状态
cls.guest.status = last_status
cls.guest.xml = cls.message['message']['xml']
elif cls.guest.status == GuestState.migrating.value:
try:
cls.guest_migrate_info.uuid = cls.guest.uuid
cls.guest_migrate_info.get_by('uuid')
cls.guest_migrate_info.type = cls.message['message'][
'migrating_info']['type']
cls.guest_migrate_info.time_elapsed = cls.message['message'][
'migrating_info']['time_elapsed']
cls.guest_migrate_info.time_remaining = cls.message['message'][
'migrating_info']['time_remaining']
cls.guest_migrate_info.data_total = cls.message['message'][
'migrating_info']['data_total']
cls.guest_migrate_info.data_processed = cls.message['message'][
'migrating_info']['data_processed']
cls.guest_migrate_info.data_remaining = cls.message['message'][
'migrating_info']['data_remaining']
cls.guest_migrate_info.mem_total = cls.message['message'][
'migrating_info']['mem_total']
cls.guest_migrate_info.mem_processed = cls.message['message'][
'migrating_info']['mem_processed']
cls.guest_migrate_info.mem_remaining = cls.message['message'][
'migrating_info']['mem_remaining']
cls.guest_migrate_info.file_total = cls.message['message'][
'migrating_info']['file_total']
cls.guest_migrate_info.file_processed = cls.message['message'][
'migrating_info']['file_processed']
cls.guest_migrate_info.file_remaining = cls.message['message'][
'migrating_info']['file_remaining']
cls.guest_migrate_info.update()
except ji.PreviewingError as e:
ret = json.loads(e.message)
if ret['state']['code'] == '404':
cls.guest_migrate_info.type = cls.message['message'][
'migrating_info']['type']
cls.guest_migrate_info.time_elapsed = cls.message[
'message']['migrating_info']['time_elapsed']
cls.guest_migrate_info.time_remaining = cls.message[
'message']['migrating_info']['time_remaining']
cls.guest_migrate_info.data_total = cls.message['message'][
'migrating_info']['data_total']
cls.guest_migrate_info.data_processed = cls.message[
'message']['migrating_info']['data_processed']
cls.guest_migrate_info.data_remaining = cls.message[
'message']['migrating_info']['data_remaining']
cls.guest_migrate_info.mem_total = cls.message['message'][
'migrating_info']['mem_total']
cls.guest_migrate_info.mem_processed = cls.message[
'message']['migrating_info']['mem_processed']
cls.guest_migrate_info.mem_remaining = cls.message[
'message']['migrating_info']['mem_remaining']
cls.guest_migrate_info.file_total = cls.message['message'][
'migrating_info']['file_total']
cls.guest_migrate_info.file_processed = cls.message[
'message']['migrating_info']['file_processed']
cls.guest_migrate_info.file_remaining = cls.message[
'message']['migrating_info']['file_remaining']
cls.guest_migrate_info.create()
elif cls.guest.status == GuestState.creating.value:
cls.guest.progress = cls.message['message']['progress']
cls.guest.update()
# 限定特殊情况下更新磁盘所属 Guest，避免迁移、创建时频繁被无意义的更新
if cls.guest.status in [
GuestState.running.value, GuestState.shutoff.value
]:
cls.disk.update_by_filter({'on_host': cls.guest.on_host},
filter_str='guest_uuid:eq:' +
cls.guest.uuid)
@classmethod
def host_event_processor(cls):
key = cls.message['message']['node_id']
value = {
'hostname': cls.message['host'],
'cpu': cls.message['message']['cpu'],
'system_load': cls.message['message']['system_load'],
'memory': cls.message['message']['memory'],
'memory_available': cls.message['message']['memory_available'],
'interfaces': cls.message['message']['interfaces'],
'disks': cls.message['message']['disks'],
'boot_time': cls.message['message']['boot_time'],
'timestamp': ji.Common.ts()
}
db.r.hset(app.config['hosts_info'],
key=key,
value=json.dumps(value, ensure_ascii=False))
@classmethod
def response_processor(cls):
_object = cls.message['message']['_object']
action = cls.message['message']['action']
uuid = cls.message['message']['uuid']
state = cls.message['type']
data = cls.message['message']['data']
hostname = cls.message['host']
if _object == 'guest':
if action == 'create':
if state == ResponseState.success.value:
# 系统盘的 UUID 与其 Guest 的 UUID 相同
cls.disk.uuid = uuid
cls.disk.get_by('uuid')
cls.disk.guest_uuid = uuid
cls.disk.state = DiskState.mounted.value
# disk_info['virtual-size'] 的单位为Byte，需要除以 1024 的 3 次方，换算成单位为 GB 的值
cls.disk.size = data['disk_info']['virtual-size'] / (1024**
3)
cls.disk.update()
else:
cls.guest.uuid = uuid
cls.guest.get_by('uuid')
cls.guest.status = GuestState.dirty.value
cls.guest.update()
elif action == 'migrate':
pass
elif action == 'delete':
if state == ResponseState.success.value:
cls.config.id = 1
cls.config.get()
cls.guest.uuid = uuid
cls.guest.get_by('uuid')
if IP(cls.config.start_ip).int() <= IP(
cls.guest.ip).int() <= IP(cls.config.end_ip).int():
if db.r.srem(app.config['ip_used_set'], cls.guest.ip):
db.r.sadd(app.config['ip_available_set'],
cls.guest.ip)
if (cls.guest.vnc_port - cls.config.start_vnc_port) <= \
(IP(cls.config.end_ip).int() - IP(cls.config.start_ip).int()):
if db.r.srem(app.config['vnc_port_used_set'],
cls.guest.vnc_port):
db.r.sadd(app.config['vnc_port_available_set'],
cls.guest.vnc_port)
cls.guest.delete()
# TODO: 加入是否删除使用的数据磁盘开关，如果为True，则顺便删除使用的磁盘。否则解除该磁盘被使用的状态。
cls.disk.uuid = uuid
cls.disk.get_by('uuid')
cls.disk.delete()
cls.disk.update_by_filter(
{
'guest_uuid': '',
'sequence': -1,
'state': DiskState.idle.value
},
filter_str='guest_uuid:eq:' + cls.guest.uuid)
elif action == 'attach_disk':
cls.disk.uuid = cls.message['message']['passback_parameters'][
'disk_uuid']
cls.disk.get_by('uuid')
if state == ResponseState.success.value:
cls.disk.guest_uuid = uuid
cls.disk.sequence = cls.message['message'][
'passback_parameters']['sequence']
cls.disk.state = DiskState.mounted.value
cls.disk.update()
elif action == 'detach_disk':
cls.disk.uuid = cls.message['message']['passback_parameters'][
'disk_uuid']
cls.disk.get_by('uuid')
if state == ResponseState.success.value:
cls.disk.guest_uuid = ''
cls.disk.sequence = -1
cls.disk.state = DiskState.idle.value
cls.disk.update()
elif action == 'boot':
boot_jobs_id = cls.message['message']['passback_parameters'][
'boot_jobs_id']
if state == ResponseState.success.value:
cls.guest.uuid = uuid
cls.guest.delete_boot_jobs(boot_jobs_id=boot_jobs_id)
elif _object == 'disk':
if action == 'create':
cls.disk.uuid = uuid
cls.disk.get_by('uuid')
cls.disk.on_host = hostname
if state == ResponseState.success.value:
cls.disk.state = DiskState.idle.value
else:
cls.disk.state = DiskState.dirty.value
cls.disk.update()
elif action == 'resize':
if state == ResponseState.success.value:
cls.disk.uuid = uuid
cls.disk.get_by('uuid')
cls.disk.size = cls.message['message'][
'passback_parameters']['size']
cls.disk.update()
elif action == 'delete':
cls.disk.uuid = uuid
cls.disk.get_by('uuid')
cls.disk.delete()
else:
pass
@classmethod
def collection_performance_processor(cls):
data_kind = cls.message['type']
timestamp = ji.Common.ts()
timestamp -= (timestamp % 60)
data = cls.message['message']['data']
if data_kind == CollectionPerformanceDataKind.cpu_memory.value:
for item in data:
cls.cpu_memory.guest_uuid = item['guest_uuid']
cls.cpu_memory.cpu_load = item['cpu_load']
cls.cpu_memory.memory_available = item['memory_available']
cls.cpu_memory.memory_unused = item['memory_unused']
cls.cpu_memory.timestamp = timestamp
cls.cpu_memory.create()
if data_kind == CollectionPerformanceDataKind.traffic.value:
for item in data:
cls.traffic.guest_uuid = item['guest_uuid']
cls.traffic.name = item['name']
cls.traffic.rx_bytes = item['rx_bytes']
cls.traffic.rx_packets = item['rx_packets']
cls.traffic.rx_errs = item['rx_errs']
cls.traffic.rx_drop = item['rx_drop']
cls.traffic.tx_bytes = item['tx_bytes']
cls.traffic.tx_packets = item['tx_packets']
cls.traffic.tx_errs = item['tx_errs']
cls.traffic.tx_drop = item['tx_drop']
cls.traffic.timestamp = timestamp
cls.traffic.create()
if data_kind == CollectionPerformanceDataKind.disk_io.value:
for item in data:
cls.disk_io.disk_uuid = item['disk_uuid']
cls.disk_io.rd_req = item['rd_req']
cls.disk_io.rd_bytes = item['rd_bytes']
cls.disk_io.wr_req = item['wr_req']
cls.disk_io.wr_bytes = item['wr_bytes']
cls.disk_io.timestamp = timestamp
cls.disk_io.create()
else:
pass
@classmethod
def host_collection_performance_processor(cls):
data_kind = cls.message['type']
timestamp = ji.Common.ts()
timestamp -= (timestamp % 60)
data = cls.message['message']['data']
if data_kind == HostCollectionPerformanceDataKind.cpu_memory.value:
cls.host_cpu_memory.node_id = data['node_id']
cls.host_cpu_memory.cpu_load = data['cpu_load']
cls.host_cpu_memory.memory_available = data['memory_available']
cls.host_cpu_memory.timestamp = timestamp
cls.host_cpu_memory.create()
if data_kind == HostCollectionPerformanceDataKind.traffic.value:
for item in data:
cls.host_traffic.node_id = item['node_id']
cls.host_traffic.name = item['name']
cls.host_traffic.rx_bytes = item['rx_bytes']
cls.host_traffic.rx_packets = item['rx_packets']
cls.host_traffic.rx_errs = item['rx_errs']
cls.host_traffic.rx_drop = item['rx_drop']
cls.host_traffic.tx_bytes = item['tx_bytes']
cls.host_traffic.tx_packets = item['tx_packets']
cls.host_traffic.tx_errs = item['tx_errs']
cls.host_traffic.tx_drop = item['tx_drop']
cls.host_traffic.timestamp = timestamp
cls.host_traffic.create()
if data_kind == HostCollectionPerformanceDataKind.disk_usage_io.value:
for item in data:
cls.host_disk_usage_io.node_id = item['node_id']
cls.host_disk_usage_io.mountpoint = item['mountpoint']
cls.host_disk_usage_io.used = item['used']
cls.host_disk_usage_io.rd_req = item['rd_req']
cls.host_disk_usage_io.rd_bytes = item['rd_bytes']
cls.host_disk_usage_io.wr_req = item['wr_req']
cls.host_disk_usage_io.wr_bytes = item['wr_bytes']
cls.host_disk_usage_io.timestamp = timestamp
cls.host_disk_usage_io.create()
else:
pass
@classmethod
def launch(cls):
logger.info(msg='Thread EventProcessor is launched.')
while True:
if Utils.exit_flag:
msg = 'Thread EventProcessor say bye-bye'
print msg
logger.info(msg=msg)
return
try:
report = db.r.lpop(app.config['upstream_queue'])
if report is None:
time.sleep(1)
continue
cls.message = json.loads(report)
if cls.message['kind'] == EmitKind.log.value:
cls.log_processor()
elif cls.message['kind'] == EmitKind.guest_event.value:
cls.guest_event_processor()
elif cls.message['kind'] == EmitKind.host_event.value:
cls.host_event_processor()
elif cls.message['kind'] == EmitKind.response.value:
cls.response_processor()
elif cls.message[
'kind'] == EmitKind.collection_performance.value:
cls.collection_performance_processor()
elif cls.message[
'kind'] == EmitKind.host_collection_performance.value:
cls.host_collection_performance_processor()
else:
pass
except Exception as e:
logger.error(traceback.format_exc())
def post(self, guest_ID): #se ne izbrise zares
guest = Guest.get_by_id(int(guest_ID))
guest.key.delete()
self.redirect_to("izbrisani")
def get(self):
seznam = Guest.query(Guest.izbrisan == True).fetch()
params = {"seznam": seznam}
self.render_template("izbrisani.html", params=params)
