def commit(self, resource, object, method):
uuid_str = str(uuid.uuid4())
time = datetime.now()
user_id = self.user.user_id
if self.model == None:
self.model = BaseModel()
row = TaskModel(uuid=uuid_str,
post_time=time,
run_time=0,
user_id=user_id,
status="init",
resource=resource,
object=object,
method=method,
request=self.model.json(),
message="queing task")
res = TaskModel(uuid=uuid_str,
post_time=time,
run_time=0,
user_id=user_id,
status="init",
resource=resource,
object=object,
method=method,
request=self.model,
message="queing task")
self.db.add(row)
self.db.commit()
return res
def create_task(request):
task = TaskModel(status=Status.IN_QUEUE)
task.save()
if NEW_TASK_EVENT.is_set():
NEW_TASK_EVENT.clear()
NEW_TASK_EVENT.set()
return JsonResponse({"task_id": task.pk})
def dev_patch_node_role():
db = SessionLocal()
model = TaskModel(request={
"node_name": "shiori",
"role_name": "libvirt"
})
patch_node_role(db=db, model=model)
def change_domain_base(db: Session, model: TaskModel):
request: DomainPatch = DomainPatch(**model.request)
try:
domain: DomainModel = db.query(DomainModel).filter(DomainModel.uuid == request.uuid).one()
except:
raise Exception("domain not found")
try:
node: NodeModel = db.query(NodeModel).filter(NodeModel.name == domain.node_name).one()
except:
raise Exception("node not found")
manager = virtlib.VirtManager(node_model=node)
# 電源
if request.status == "on":
manager.domain_poweron(uuid=request.uuid)
elif request.status == "off":
manager.domain_destroy(uuid=request.uuid)
# CDROM
if request.status == "mount":
manager.domain_cdrom(request.uuid, request.target, request.path)
elif request.status == "unmount":
manager.domain_cdrom(request.uuid, request.target)
update_domain_list(db=db, model=TaskModel())
return model
def exec_task(db, task):
logger.info(
f'start tasks: {task.resource}.{task.object}.{task.method} {task.uuid}'
)
task.status = "start"
db.merge(task)
db.commit()
# Model to Schemas
task: TaskSelect = TaskSelect().from_orm(task)
start_time = time()
try:
res = task_swicher(model=task, db=db)
msg = str(res.message)
end_time = time()
task.run_time = end_time - start_time
except Exception as e:
db.rollback()
logger.error(e, exc_info=True)
task.status = "error"
task.message = str(e)
else:
logger.info(
f'task finished: {task.resource}.{task.object}.{task.method} {task.uuid} {task.run_time}s'
)
task.status = "finish"
task.message = msg
logger.debug(task)
# Schemas to Model
db.merge(TaskModel(**task.dict()))
db.commit()
class PostTask():
db = None
user = None
model = None
task_model = TaskModel()
def __init__(self, db: Session, user: CurrentUser, model: BaseModel):
self.db = db
self.user = user
self.model = model
def commit(self, resource, object, method):
uuid_str = str(uuid.uuid4())
time = datetime.now()
user_id = self.user.user_id
if self.model == None:
self.model = BaseModel()
row = TaskModel(uuid=uuid_str,
post_time=time,
run_time=0,
user_id=user_id,
status="init",
resource=resource,
object=object,
method=method,
request=self.model.json(),
message="queing task")
res = TaskModel(uuid=uuid_str,
post_time=time,
run_time=0,
user_id=user_id,
status="init",
resource=resource,
object=object,
method=method,
request=self.model,
message="queing task")
self.db.add(row)
self.db.commit()
return res
def endless_eight():
logger.info("Worker起動")
db = SessionLocal()
while True:
query = db.query(TaskModel)
query = query.filter(TaskModel.status == "init")
query = query.order_by(desc(TaskModel.post_time))
tasks = query.all()
if tasks == []:
sleep(3)
continue
# 開始処理
task: TaskModel = tasks[0]
logger.info(
f'タスク開始: {task.resource}.{task.object}.{task.method} {task.uuid}')
task.status = "start"
db.merge(task)
db.commit()
# Model to Schemas
task: TaskSelect = TaskSelect().from_orm(task)
start_time = time()
try:
task_swicher(model=task, db=db)
except Exception as e:
logger.error(e, exc_info=True)
task.status = "error"
task.message = str(e)
else:
task.status = "finish"
task.message = "finish"
end_time = time()
task.run_time = end_time - start_time
logger.info(
f'タスク終了: {task.resource}.{task.object}.{task.method} {task.uuid} {task.run_time}s'
)
# Schemas to Model
db.merge(TaskModel(**task.dict()))
db.commit()
def delete_domain_base(db: Session, model: TaskModel):
request: DomainInsert = DomainDelete(**model.request)
try:
domain: DomainModel = db.query(DomainModel).filter(DomainModel.uuid == request.uuid).one()
except:
raise Exception("domain not found")
try:
node: NodeModel = db.query(NodeModel).filter(NodeModel.name == domain.node_name).one()
except:
raise Exception("node not found")
manager = virtlib.VirtManager(node_model=node)
manager.domain_undefine(request.uuid)
update_domain_list(db=db, model=TaskModel())
return model
def change_domain_network(db: Session, model: TaskModel):
request: DomainNetworkChange = DomainNetworkChange(**model.request)
try:
domain: DomainModel = db.query(DomainModel).filter(DomainModel.uuid == request.uuid).one()
except:
raise Exception("domain not found")
try:
node: NodeModel = db.query(NodeModel).filter(NodeModel.name == domain.node_name).one()
except:
raise Exception("node not found")
manager = virtlib.VirtManager(node_model=node)
manager.domain_network(uuid=request.uuid, network=request.network_name, port=request.port, mac=request.mac)
update_domain_list(db=db, model=TaskModel())
return model
def add_storage_base(db: Session, model: TaskModel):
request: StorageInsert = StorageInsert(**model.request)
try:
node: NodeModel = db.query(NodeModel).filter(
NodeModel.name == request.node_name).one()
except:
raise Exception("node not found")
# XMLを定義、設定
editor = xmllib.XmlEditor("static", "storage_dir")
editor.storage_base_edit(name=request.name, path=request.path)
# ソイや！
manager = virtlib.VirtManager(node_model=node)
manager.storage_define(xml_str=editor.dump_str())
update_storage_list(db=db, model=TaskModel())
return model
def delete_network_base(db: Session, model: TaskModel):
request: NetworkDelete = NetworkDelete(**model.request)
try:
network: NetworkModel = db.query(NetworkModel).filter(
NetworkModel.uuid == request.uuid).one()
except:
raise Exception("network not found")
try:
node: NodeModel = db.query(NodeModel).filter(
NodeModel.name == network.node_name).one()
except:
raise Exception("node not found")
manager = virtlib.VirtManager(node_model=node)
manager.network_undefine(request.uuid)
update_network_list(db=db, model=TaskModel())
return model
def add_network_base(db: Session, model: TaskModel):
request: NetworkInsert = NetworkInsert(**model.request)
try:
node: NodeModel = db.query(NodeModel).filter(
NodeModel.name == request.node_name).one()
except:
raise Exception("node not found")
if request.type == "bridge":
# XMLを定義、設定
editor = xmllib.XmlEditor("static", "net_bridge")
editor.network_bridge_edit(name=request.name,
bridge=request.bridge_device)
xml = editor.dump_str()
elif request.type == "ovs":
xml = f'''
<network>
<name>{request.name}</name>
<forward mode="bridge" />
<bridge name="{request.bridge_device}" />
<virtualport type="openvswitch" />
<portgroup name="untag" default="yes">
</portgroup>
</network>
'''
else:
raise Exception("Type is incorrect")
# ソイや！
manager = virtlib.VirtManager(node_model=node)
manager.network_define(xml_str=xml)
update_network_list(db=db, model=TaskModel())
return model
def dev_domain_define():
db = SessionLocal()
update_network_list(db=db, model=TaskModel())
def dev_update_network_list():
db = SessionLocal()
update_network_list(db=db, model=TaskModel())
def dev_update_storage_list():
db = SessionLocal()
update_storage_list(db=db, model=TaskModel())
def add_domain_base(db: Session, model: TaskModel):
# 受け取ったデータをモデルに型付け
task_model:TaskModel = model
model: DomainInsert = DomainInsert(**task_model.request)
# データベースから情報とってきて確認も行う
domains: DomainModel = db.query(DomainModel).filter(DomainModel.name==model.name).all()
try:
node: NodeModel = db.query(NodeModel).filter(NodeModel.name==model.node_name).one()
except:
raise Exception("node not found")
if domains != []:
raise Exception("domain name is duplicated")
# XMLのベース読み込んで編集開始
editor = xmllib.XmlEditor("static","domain_base")
editor.domain_emulator_edit(node.os_like)
editor.domain_base_edit(
domain_name=model.name,
memory_mega_byte=model.memory_mega_byte,
core=model.cpu,
vnc_port=0,
vnc_passwd=None
)
domain_uuid = editor.domain_uuid_generate()
# ネットワークインターフェイス
for interface in model.interface:
interface: DomainInsertInterface
editor.domain_interface_add(
network_name=interface.network_name,
mac_address=None,
port=interface.port
)
img_device_names = ["vda","vdb","vdc"]
# ブロックデバイス
for device, device_name in zip(model.disks, img_device_names):
# 型定義
device: DomainInsertDisk
# 作成先のプールを参照
try:
new_pool: StorageModel = db.query(StorageModel).filter(StorageModel.uuid==device.save_pool_uuid).one()
except:
raise Exception("request storage pool uuid not found")
# ファイル名決めてる
create_image_path = new_pool.path +"/"+ model.name + "_" + device_name + '.img'
# XMLに追加
editor.domain_device_image_add(image_path=create_image_path, target_device=device_name)
# 新規ディスクの場合
if device.type == "empty":
# 空のディスク作成
ssh_manager = sshlib.SSHManager(user=node.user_name, domain=node.domain, port=node.port)
ssh_manager.qemu_create(
size_giga_byte=device.size_giga_byte,
path=create_image_path
)
# 既存ディスクのコピー
elif device.type == "copy":
# コピー元のプール情報参照
try:
pool_model:StorageModel = db.query(StorageModel).filter(StorageModel.uuid==device.original_pool_uuid).one()
except:
raise Exception("request src pool uuid not found")
pool_path = pool_model.path
file_name = device.original_name
from_image_path = pool_path + '/' + file_name
logger.info(f'{from_image_path}を{create_image_path}へコピーします')
ssh_manager = sshlib.SSHManager(user=node.user_name, domain=node.domain, port=node.port)
ssh_manager.file_copy(
from_path=from_image_path,
to_path=create_image_path
)
# Cloud-init
if model.cloud_init != None:
# iso作成
cloudinit_manager = cloudinitlib.CloudInitManager(domain_uuid,model.cloud_init.hostname)
cloudinit_manager.custom_user_data(model.cloud_init.userData)
iso_path = cloudinit_manager.make_iso()
# cloud-initのisoを保存するpoolを探す
try:
query = db.query(StorageModel).join(NodeModel).outerjoin(StorageMetadataModel)
query = query.filter(NodeModel.name==node.name).filter(StorageMetadataModel.rool=="init-iso")
init_pool_model:StorageModel = query.one()
except:
raise Exception("cloud-init pool not found")
# 生成したisoをノードに転送
send_path = f"{init_pool_model.path}/{domain_uuid}.iso"
ansible_manager = ansiblelib.AnsibleManager(user=node.user_name, domain=node.domain)
ansible_manager.file_copy_to_node(src=iso_path,dest=send_path)
editor.domain_cdrom(target=None,path=send_path)
# ノードに接続してlibvirtでXMLを登録
node = virtlib.VirtManager(node_model=node)
node.domain_define(xml_str=editor.dump_str())
# 情報の更新
update_domain_list(db=db, model=TaskModel())
domain = db.query(DomainModel).filter(DomainModel.uuid==domain_uuid).one()
domain.owner_user_id = task_model.user_id
db.commit()
return task_model
