def adminpj():
cliente = session.query(tbl_cliente, tbl_pessoa_juridica, tbl_cidade,
tbl_estado,
tbl_telefone).join(tbl_pessoa_juridica, tbl_cidade,
tbl_estado, tbl_telefone).all()
session.close()
return render_template("admin_pessoajuridica.html", cliente=cliente)
def adicionar_pedido_pj():
cliente_pj = session.query(tbl_pessoa_juridica).order_by(
tbl_pessoa_juridica.razao_social).all()
status_list = session.query(tbl_status_pedido).order_by(
tbl_status_pedido.id_status).all()
if request.method == 'POST':
# tbl_pedido
cod_cliente = request.form['cod_cliente']
mod_pgto = request.form['mod_pgto']
cod_status = request.form['cod_status']
desconto = 0
pedido = tbl_pedido(data_pedido=datetime.now(),
cod_cliente=cod_cliente,
desconto=desconto,
cod_status=cod_status,
mod_pgto=mod_pgto)
session.add(pedido)
session.commit()
session.close()
return redirect(url_for('admin_pedido'))
session.close()
return render_template('adicionar_pedido_pj.html',
cliente_pj=cliente_pj,
status_list=status_list)
def test_code_create_service_setup():
with open('static/role_service.json') as role_data_file:
role_data = json.load(role_data_file)
nodes = session.query(models.Node).all()
for node in nodes:
deployment = node.deployment
if deployment is not None:
roles = [role.role_name for role in node.node_roles]
for role in roles:
list_services = role_data[role]['list_service']
for service in list_services:
service_setup = models.Service_setup(
service_type=role,
service_name=service['service_name'],
enable="ENABLE",
service_lib=None,
service_config_folder=None,
setup_index=service['index'],
is_validated_success=None,
validated_status=None)
deployment.service_setups.append(service_setup)
session.add(node)
session.commit()
session.close()
return {"respone": "Done Add Service Setup to Database"}, 202
def get_role_info(role_id):
with open('static/role_service.json') as role_data_file:
role_data = json.load(role_data_file)
print(role_data.keys())
role_info = [{
"role_name": role_name,
"role_inf": role_data[role_name]
} for role_name in role_data.keys()
if role_data[role_name]['id'] == role_id]
if len(role_info) == 0:
return {"status: ": "Role id not found"}
role_node = []
list_node_role = session.query(
models.Node_role).filter_by(role_name=role_info[0]["role_name"]).all()
for node_role in list_node_role:
node = session.query(
models.Node).filter_by(node_id=node_role.node_id).first()
role_node.append(models.to_json(node, 'Node', False))
session.close()
return {"status": "OK", "role_info": role_info[0], "role_node": role_node}
def get_current_installation_status():
current_task = session.query(
models.Task).filter_by(status='INPROCESSING').first()
if current_task is None:
current_task = session.query(
models.Task).filter_by(status='FAILED').first()
if current_task is None:
current_task = session.query(models.Task).filter_by(
status='DONE').order_by(models.Task.finished_at.desc()).all()
if current_task is not None:
current_task = current_task[0] if len(current_task) > 0 else None
if current_task is None:
return abort(404, "No Task was Run")
current_service = current_task.service_setup
current_node = current_service.deployment.node
res = {
" current_task": models.to_json(current_task, 'Task', False),
"current_service": models.to_json(current_service, 'Service_setup',
False),
"current_node": models.to_json(current_node, 'Node', False),
}
session.commit()
session.close()
return res, 200
def adicionar_item_pedido():
produto_list = session.query(tbl_produto).order_by(
tbl_produto.nome_produto).all()
tb_ped = session.query(tbl_pedido).order_by(tbl_pedido.id_pedido).all()
id = request.form.get('cod_produto')
tb_prod = session.get(tbl_produto, id)
print(id)
if request.method == 'POST':
# tbl_item
quantidade_venda = request.form['quantidade_venda']
quantidade_venda = int(quantidade_venda)
valor_unitario = request.form['id_valor_unitario']
valor_unitario = float(valor_unitario)
cod_produto = request.form['id_cod_produto']
cod_pedido = request.form['id_pedido']
itens = tbl_item(quantidade_venda=quantidade_venda,
valor_unitario=valor_unitario,
cod_produto=cod_produto,
cod_pedido=cod_pedido)
session.add(itens)
session.commit()
session.close()
return redirect(url_for('admin_pedido'))
session.close()
return render_template('adicionar_item_pedido.html',
tb_ped=tb_ped,
tb_prod=tb_prod,
produto_list=produto_list)
def create():
if current_user.get_id() == None:
return redirect('/login')
forme = Home()
if forme.validate_on_submit():
try:
maps = googlemaps.Client(
key='AIzaSyC5t7IJz1xp-3huks0QEOVv5eFOv6Lal4Y')
h = maps.geocode("Rua " + forme.street.data + " " +
forme.neighborhood.data + " " +
str(forme.number.data) + " " + forme.zipCode.data)
lat = str(h[0]['geometry']['location']['lat'])
lng = str(h[0]['geometry']['location']['lng'])
i = ControlHomes()
i.addHome(int(current_user.get_id()), forme.title.data,
forme.value.data,
forme.description.data, forme.telephone.data,
datetime.now(), forme.zipCode.data, forme.street.data,
forme.neighborhood.data, forme.number.data,
forme.complement.data, lat, lng)
flash("Anúncio cadastrado!")
return redirect('/republica/meusanuncios')
except:
return render_template('create.html', forme=forme)
finally:
session.close()
else:
return render_template('create.html', forme=forme)
return render_template('create.html', forme=forme)
def adicionar():
cidades = session.query(tbl_cidade).order_by(tbl_cidade.cidade).all()
if request.method == 'POST':
# tbl_cliente
usuario = request.form['usuario']
senha = request.form['senha']
senha = generate_password_hash(senha, method='sha256', salt_length=2)
endereco = request.form['endereco']
num_endereco = request.form['num_endereco']
complemento = request.form['complemento']
bairro = request.form['bairro']
cep = request.form['cep']
cod_cidade = request.form['cod_cidade']
contato = request.form['contato']
email = request.form['email']
observacao = request.form['observacao']
cliente = tbl_cliente(usuario=usuario,
senha=senha,
endereco=endereco,
num_endereco=num_endereco,
complemento=complemento,
bairro=bairro,
cep=cep,
cod_cidade=cod_cidade,
contato=contato,
email=email,
observacao=observacao)
session.add(cliente)
session.commit()
# tbl_pessoa_fisica
nome = request.form['nome']
cpf = request.form['cpf']
rg = request.form['rg']
data_nascimento = request.form['data_nascimento']
pessoa_fisica = tbl_pessoa_fisica(id_pessoa_fisica=cliente.id_cliente,
nome=nome,
cpf=cpf,
rg=rg,
data_nascimento=data_nascimento)
session.add(pessoa_fisica)
session.commit()
# tbl_telefone
ddd = request.form['ddd']
telefone = request.form['telefone']
tb_telefone = tbl_telefone(ddd=ddd,
telefone=telefone,
cod_cliente=cliente.id_cliente)
session.add(tb_telefone)
session.commit()
session.close()
return redirect(url_for('adminpf'))
return render_template('adicionar_pessoafisica.html', cidades=cidades)
def deletar_item_pedido(id, id_cod_pt, id_cod_pd, id_pp):
# del_pedido = session.get(tbl_pedido, id_pp)
# session.delete(del_pedido)
del_item = session.query(tbl_item).get((id, id_cod_pt, id_cod_pd))
session.delete(del_item)
session.commit()
session.close()
return redirect(url_for('admin_pedido'))
def parse_response(res):
for item in res:
updated_at = datetime.strptime(item.get('updated_at'),
'%Y-%m-%dT%H:%M:%SZ')
repo = Repo(item.get('name'), item.get('html_url'),
item.get('description'), updated_at,
item.get('stargazers_count'), item.get('watchers_count'))
session.add(repo)
session.commit()
session.close()
def add_all_deployment():
nodes = session.query(models.Node).all()
for node in nodes:
if node.deployment is None and node.node_roles > 0:
deployment = models.Deployment(created_at=datetime.now(),
updated_at=datetime.now(),
finished_at=None,
status="IN QUEUE",
name="deployement " +
str(node.management_ip))
node.deployment = deployment
session.add(node)
session.commit()
session.close()
return {"respone": "Done Add Deployment to Database"}, 202
def dbsession(app):
"""Creates a new database session for a test."""
# Connect to the database and create the schema within a transaction
app.transaction = app.connection.begin()
ctx = app.app_context()
ctx.push()
_session = session()
yield _session
# clean up test database
app.transaction.close()
session.close()
ctx.pop()
def test_code_create_task_for_service():
list_nodes = session.query(models.Node).all()
for node in list_nodes:
print(node.node_display_name)
service_setups = get_service_setups_from_deployment(node.deployment)
#service = service_setups[0]
for service in service_setups:
list_tasks = load_yml_file(CONST.role_dir + '/' +
service.service_name +
'/tasks/main.yml')
list_task_info = []
for index, task in enumerate(list_tasks, start=0):
task_info = {}
for command in task.get('block'):
if command.get('name') is not None:
task_info['name'] = command.get('name')
elif command.get('include') is None:
setup_data = str(json.dumps(command))
task_info['setup_data'] = setup_data[:250] + (
setup_data[250:] and '..')
task_info['task_type'] = command.keys()
if 'register' in task_info['task_type']:
task_info['task_type'].remove('register')
list_task_info.append(task_info)
for index, task in enumerate(list_task_info, start=1):
task_data = models.Task(created_at=datetime.now(),
task_display_name=task.get('name'),
setup_data=task.get('setup_data'),
task_type=str(task.get('task_type')),
task_index=index)
service.tasks.append(task_data)
session.add(node)
session.commit()
session.close()
return {
"respone": "Done Create Tasks in Database. Check in /api/v1/tasks"
}, 202
def editar_pessoajuridica(id):
tb_cliente = session.get(tbl_cliente, id)
tb_pessoa_juridica = session.get(tbl_pessoa_juridica, id)
tb_telefone = session.get(tbl_telefone, id)
query_cidade = session.query(tbl_cidade).order_by(tbl_cidade.cidade).all()
if request.method == 'POST':
# tbl_cliente
tb_cliente.usuario = request.form['usuario']
senha = request.form['senha']
tb_cliente.senha = generate_password_hash(senha,
method='sha256',
salt_length=2)
tb_cliente.endereco = request.form['endereco']
tb_cliente.num_endereco = request.form['num_endereco']
tb_cliente.complemento = request.form['complemento']
tb_cliente.bairro = request.form['bairro']
tb_cliente.cep = request.form['cep']
tb_cliente.cod_cidade = request.form['cod_cidade']
tb_cliente.contato = request.form['contato']
tb_cliente.email = request.form['email']
tb_cliente.observacao = request.form['observacao']
# tbl_pessoa_juridica
tb_pessoa_juridica.nome_fantasia = request.form['nome_fantasia']
tb_pessoa_juridica.razao_social = request.form['razao_social']
tb_pessoa_juridica.cnpj = request.form['cnpj']
tb_pessoa_juridica.inscricao_estadual = request.form[
'inscricao_estadual']
tb_pessoa_juridica.data_fundacao = request.form['data_fundacao']
session.commit()
# tbl_telefone
tb_telefone.ddd = request.form['ddd']
tb_telefone.telefone = request.form['telefone']
session.commit()
session.close()
return redirect(url_for('adminpj'))
session.close()
return render_template('editar_pessoajuridica.html',
tb_cliente=tb_cliente,
tb_pessoa_juridica=tb_pessoa_juridica,
tb_telefone=tb_telefone,
query_cidade=query_cidade)
def run_specific_task():
if not request.json:
abort(400)
else:
task_id = request.json.get('task_id')
method = request.json.get('method')
task = session.query(models.Task).filter_by(task_id=task_id).first()
if task is None:
return abort(400)
service = task.service_setup
node = service.deployment.node
service_name = service.service_name
node_display_name = node.node_display_name
task_index = task.task_index
session.commit()
session.close()
if method == "Install":
runner = Runner(playbook='playbook_setup_' + service_name + '_for_' +
node_display_name + '.yml',
inventory='new_node',
run_data={
'extra_vars': {
'target': 'No'
},
'tags': [str(task_index)]
},
start_at_task=None,
step=False,
private_key_file=None,
become_pass=None,
verbosity=None)
# ansible-playbook ansible_compute.yml --extra-vars "target=target other_variable=foo" --tags "install, uninstall" --start-at-task=task.task_display_name --step
print(runner.variable_manager)
stats_run = runner.run()
print(stats_run)
return {"stats": str(stats_run), "logs": runner.log}
else:
return {"res": "INCOMMING"}
def admin_pedido():
tb_ped = session.query(tbl_pedido).all()
# orcamento = session.query(tbl_pedido, tbl_pessoa_fisica, tbl_item, tbl_produto, tbl_ligacao_codigo, tbl_status_pedido).join(tbl_pessoa_fisica, tbl_pedido.cod_cliente == tbl_pessoa_fisica.id_pessoa_fisica).join(tbl_item, tbl_produto, tbl_ligacao_codigo, tbl_status_pedido).all()
# orcamento_opt = session.query(tbl_pedido, tbl_pessoa_fisica, tbl_item, tbl_produto, tbl_ligacao_codigo, tbl_status_pedido).join(tbl_pessoa_fisica, tbl_pedido.cod_cliente == tbl_pessoa_fisica.id_pessoa_fisica).join(tbl_item, tbl_produto, tbl_ligacao_codigo, tbl_status_pedido).all()
# # items = session.query(tbl_item)
# # orcamento2 = session.query(tbl_item).join(tbl_pedido, tbl_item.cod_pedido == tbl_pedido.id_pedido).join(tbl_cliente).join(tbl_produto).all()
# # totais = {}
# # for item, pedido, cliente, produto in orcamento2:
# # if pedido.id_pedido not in totais:
# # totais [pedido.id_pedido] = 0
# # totais [pedido.id_pedido] += item.quantidade_venda * item.valor_unitario
# # for k in totais:
# # totais[k] = round(totais[k], 2)
# session.close()
session.close()
return render_template("admin_pedido.html", tb_ped=tb_ped)
def editar_produto(id):
tb_produto = session.get(tbl_produto, id)
if request.method == 'POST':
tb_produto.nome_produto = request.form['nome_produto']
tb_produto.descricao = request.form['descricao']
tb_produto.qtd_produto = 0
valor_unitario = request.form['valor_unitario']
print(valor_unitario)
valor_unitario = valor_unitario.replace(",", ".")
print(valor_unitario)
tb_produto.valor_unitario = float(valor_unitario)
session.commit()
session.close()
return redirect(url_for('admin_produto'))
session.close()
return render_template('editar_produto.html', tb_produto=tb_produto)
def admin_pedido_get():
tb_ped = session.query(tbl_pedido).order_by(tbl_pedido.id_pedido).all()
id = request.form['id_pedido']
if request.method == 'POST':
pedido = db_consultar_itens(id)
total = 0
for valor in pedido:
total += valor['valor_total']
# print(valor)
session.close()
return render_template("admin_pedido.html",
pedido=pedido,
tb_ped=tb_ped,
id=id,
total=total)
# elif request.method == 'POST' and request.method == None:
# return render_template("admin_pedido.html")
session.close()
return render_template("admin_pedido.html")
def add_host_to_role():
if not request.json:
abort(400)
else:
node_id = request.json.get('node_id')
roles = request.json.get('roles')
node = session.query(models.Node).filter_by(node_id=node_id).first()
if node is None:
return {"response": "Node is not exist"}, 226
if node.node_info is None:
return {"response": "Node is not discover yet! "}, 404
if roles is None:
return {"response": "Require Role"}, 226
with open('static/role_service.json') as role_data_file:
role_data = json.load(role_data_file)
list_roles = role_data.keys()
for role in roles:
if role not in list_roles:
return {
"response":
"Error Information Role with name" + role +
" is not invalid"
}, 226
for role in roles:
node_role = models.Node_role(role_name=role)
node.node_roles.append(node_role)
session.add(node)
session.commit()
res = {
"respone": "Done Add Node to Role",
"node_info": models.to_json(node, 'Node', False)
}
session.close()
return res, 202
def form():
usuarios = session.query(tbl_cliente).all()
print(usuarios)
login = request.form['usuarioform']
secret = request.form['senhaform']
secret = str(secret)
logins = {}
for user in usuarios:
senha = str(user.senha)
check = check_password_hash(senha, secret)
print(check)
logins[user.usuario] = check
print(logins)
for chave in logins:
if logins[chave] == True and chave == login:
session.close()
return render_template("menu.html", mensagem="Login Realizado.")
session.close()
return render_template("login.html", mensagem="Login inválido.")
def skip_current_installation():
current_task = session.query(
models.Task).filter_by(status='INPROCESSING').first()
if current_task is None:
current_task = session.query(
models.Task).filter_by(status='FAILED').first()
if current_task is None:
current_task = session.query(models.Task).filter_by(
status='DONE').order_by(models.Task.finished_at.desc())
current_task = current_task[0] if current_task is not None else None
### MAYBE ERROR IF NO TASK IS DONE
current_task.status = current_task.status + "_" + "SKIPPED"
next_task = session.query(models.Task).filter_by(
service_setup_id=current_task.service_setup_id,
task_index=current_task.task_index + 1).first()
if next_task is None:
current_service_setup = current_task.service_setup
current_service_setup.status = current_service_setup.status + "_" + "SKIPPED"
next_service_setup = session.query(models.Service_setup).filter_by(
deployment_id=current_service_setup.deployment_id,
setup_index=current_service_setup.setup_index + 1).first()
if next_service_setup is None:
current_service_setup.deployment.status = current_service_setup.deployment.status + "_" + "SKIPPED"
else:
###ERROR
next_task = [
t for t in next_service_setup.tasks if t.task_index == 1
][0]
session.add(current_task)
session.commit()
res = {
" current_task": models.to_json(current_task, 'Task', False),
" next_task": models.to_json(next_task, 'Task', False)
}
session.close()
return res
def gerar_pedido(id):
if request.method == 'POST':
tb_ped = session.query(tbl_pedido).order_by(tbl_pedido.id_pedido).all()
query_pd = session.get(tbl_pedido, id)
query_cl = session.get(tbl_cliente, query_pd.cod_cliente)
query_tl = session.get(tbl_telefone, query_cl.id_cliente)
query_cd = session.get(tbl_cidade, query_cl.cod_cidade)
query_uf = session.get(tbl_estado, query_cd.cod_estado)
query_st = session.get(tbl_status_pedido, query_pd.cod_status)
query_pj = session.get(tbl_pessoa_juridica, query_pd.cod_cliente)
query_pf = session.get(tbl_pessoa_fisica, query_pd.cod_cliente)
# id = request.form['id_pedido']
if request.method == 'POST':
pedido = db_consultar_itens(id)
total = 0
for valor in pedido:
total += valor['valor_total']
# print(valor)
session.close()
# Criando pdf render_template
return render_template("report_pedido.html",
pedido=pedido,
tb_ped=tb_ped,
id=id,
query_cl=query_cl,
query_cd=query_cd,
query_uf=query_uf,
query_tl=query_tl,
query_pf=query_pf,
query_pj=query_pj,
query_st=query_st,
query_pd=query_pd,
total=total)
session.close()
return render_template("admin_pedido.html")
def editar_pedido(id_item, id_cod_pdt, id_cod_ped):
tb_pp = session.get(tbl_pedido, id_cod_ped)
tb_it = session.query(tbl_item).get((id_item, id_cod_pdt, id_cod_ped))
tb_pto = session.get(tbl_produto, id_cod_pdt)
status_list = session.query(tbl_status_pedido).order_by(
tbl_status_pedido.id_status).all()
produto_list = session.query(tbl_produto).order_by(
tbl_produto.nome_produto).all()
if request.method == 'POST':
# tbl_pedido
tb_pp.mod_pgto = request.form['mod_pgto']
tb_pp.cod_status = request.form['cod_status']
session.commit()
# tbl_item
# tb_pessoa_juridica.nome_fantasia = request.form['nome_fantasia']
quantidade_venda = request.form['quantidade_venda']
valor_unitario = request.form['id_valor_unitario']
tb_it.quantidade_venda = int(quantidade_venda)
tb_it.valor_unitario = float(valor_unitario)
tb_it.cod_produto = request.form['id_cod_produto']
session.commit()
session.close()
return redirect(url_for('admin_pedido'))
session.close()
return render_template('editar_pedido.html',
produto_list=produto_list,
status_list=status_list,
tb_pp=tb_pp,
tb_it=tb_it,
tb_pto=tb_pto)
def adicionar_produto():
if request.method == 'POST':
nome_produto = request.form['nome_produto']
descricao = request.form['descricao']
qtd_produto = 0
valor_unitario = request.form['valor_unitario']
print(valor_unitario)
valor_unitario = valor_unitario.replace(",", ".")
print(valor_unitario)
valor_unitario = float(valor_unitario)
add_produto = tbl_produto(nome_produto=nome_produto,
descricao=descricao,
qtd_produto=qtd_produto,
valor_unitario=valor_unitario)
session.add(add_produto)
session.commit()
session.close()
return redirect(url_for('admin_produto'))
session.close()
return render_template('adicionar_produto.html')
def load_node_info_to_database(ansible_facts_dir):
nodes=session.query(models.Node).all()
res={"succeed" : 0, "error":0}
for node in nodes:
node.updated_at=datetime.now()
node.node_type="oenstack"
with open(ansible_facts_dir+ '/'+str(node.management_ip)) as data_node:
node_data = json.load(data_node)
ansible_facts=node_data.get('ansible_facts')
if ansible_facts is not None:
#print(node_data)
node_name = ansible_facts.get('ansible_hostname')
memory_mb = ansible_facts.get('ansible_memtotal_mb')
memory_mb_free=ansible_facts.get('ansible_memfree_mb')
numa_topology=None
metrics= None
processor_core=ansible_facts.get('ansible_processor_cores')
processor_count=ansible_facts.get('ansible_processor_count')
processor_threads_per_core=ansible_facts.get('ansible_processor_threads_per_core')
processor_vcpu=ansible_facts.get('ansible_processor_vcpus')
os_family=ansible_facts.get('ansible_os_family')
pkg_mgr=ansible_facts.get('ansible_pkg_mgr')
os_version=ansible_facts.get('ansible_distribution_version')
default_ipv4=ansible_facts.get('ansible_default_ipv4').get('address')
default_broadcast=ansible_facts.get('ansible_default_ipv4').get('broadcast')
default_gateway=ansible_facts.get('ansible_default_ipv4').get('gateway')
default_interface_id=ansible_facts.get('ansible_default_ipv4').get('interface')
node_info=models.Node_info(node_name=node_name,memory_mb=memory_mb,memory_mb_free=memory_mb_free,numa_topology=numa_topology,metrics=metrics,processor_core=processor_core,processor_count=processor_count,processor_threads_per_core=processor_threads_per_core, processor_vcpu=processor_vcpu,os_family=os_family, pkg_mgr=pkg_mgr,os_version=os_version,default_ipv4=default_ipv4,default_broadcast=default_broadcast,default_gateway=default_gateway,default_interface_id=default_interface_id)
interface_resources=[]
for interface in ansible_facts['ansible_interfaces']:
if "docker" not in interface and "veth" not in interface and "virb" not in interface :
interface_info=ansible_facts.get('ansible_'+interface)
if interface_info is not None:
device_name=interface_info.get('device')
speed=interface_info.get('speed')
port_info=None
active=str(interface_info.get('active'))
features=str(interface_info.get('features'))
macaddress=interface_info.get('macaddress')
module=interface_info.get('module')
mtu=interface_info.get('mtu')
pciid=interface_info.get('pciid')
phc_index=interface_info.get('phc_index')
type_interface=interface_info.get('type_interface')
if device_name==ansible_facts.get('ansible_default_ipv4').get('interface'):
is_default_ip='True'
else:
is_default_ip='False'
interface_resource=models.Interface_resource(device_name=device_name,speed=speed,port_info=port_info,active=active,features=features,macaddress=macaddress,module=module,mtu=mtu,pciid=pciid,phc_index=phc_index,type_interface=type_interface,is_default_ip=is_default_ip)
interface_resources.append(interface_resource)
node_info.interface_resources=interface_resources
#node_info.update(interface_resources=interface_resources)
disk_resources=[]
for device in ansible_facts['ansible_devices']:
if "sd" in device:
device_data=ansible_facts.get('ansible_devices').get(str(device))
device_name=device
size = int(float(device_data.get('size')[0:-2].replace(" ", "")))
model = device_data.get('model')
removable= device_data.get('removable')
sectors = device_data.get('sectors')
sectorsize=device_data.get('sectorsize')
serial = device_data.get('serial')
vendor = device_data.get('vendor')
support_discard=device_data.get('support_discard')
virtual=device_data.get('virtual')
disk_resource= models.Disk_resource(device_name=device_name, size=size, model=model, removable=removable,sectors=sectors,sectorsize=sectorsize,serial=serial, vendor=vendor,support_discard=support_discard,virtual=virtual)
disk_resources.append(disk_resource)
node_info.disk_resources=disk_resources
node.node_info=node_info
node.status = "success access node info"
res['succeed']+=1
else :
node.status = json.dumps(node_data)
res['error']+=1
session.add(node)
session.commit()
session.close()
return res
def remHome(self, Homes):
session.delete(Homes)
session.commit()
session.close()
def update_task_info():
if not request.json:
abort(400)
state = request.json.get('state')
node_ip = request.json.get('node_ip')
task_index = int(request.json.get('task_index').encode('utf-8'))
service_name = request.json.get('service_name').encode('utf-8')
# logging.debug("TYPE INDEX: " + str(type(task_index)))
task = session.query(models.Task).filter(
and_(
models.Task.task_index == task_index,
models.Task.service_setup.has(
models.Service_setup.service_name == str(service_name)),
models.Task.service_setup.has(
models.Service_setup.deployment.has(
models.Deployment.node.has(
models.Node.management_ip == str(node_ip)))))).first()
if task is None:
session.commit()
session.close()
return {
"res":
"Error Task Not Found" + 'node_ip: ' + str(node_ip) +
' service_name: ' + str(service_name) + ' task_index: ' +
str(task_index)
}, 200
info = request.json.get('info')
if state == "before_task":
task.status = 'INPROCESSING'
task.result = 'UNDONE'
task.service_setup.status = "INPROCESSING"
task.service_setup.deployment.status = "INPROCESSING"
session.add(task)
res = jsonify(models.to_json(task, 'Task', False))
session.commit()
session.close()
return res, 200
# logging.debug("TYPE INFO: " + str(type(info)))
if type(info) is unicode:
info = info.encode('utf-8')
if type(info) is not dict:
info = ast.literal_eval(info)
logging.debug("INFO: " + json.dumps(info))
logging.debug("INFO.failed: " + str(info.get('failed')))
logging.debug("INFO.results: " + str(info.get('results')))
logging.debug("INFO.stderr: " + str(info.get('stderr')))
logging.debug("INFO.stdout: " + str(info.get('stdout')))
if state == "after_task_failse":
task.status = "FAILED"
task.service_setup.status = "FAILED"
task.service_setup.deployment.status = "FAILED"
if state == "after_task_ok":
if info.get('failed') is True:
task.status = "FAILED_IGNORE"
else:
task.status = "DONE"
task.service_setup.status = "DONE" if task.task_index == len(
task.service_setup.tasks) else "INPROCESSING"
task.service_setup.deployment.status = "INPROCESSING"
task.finished_at = datetime.now()
info_result = info.get('results') if info.get('results') else []
info_dest = info.get('dest') if info.get('dest') else ""
info_backup_file = info.get('backup_file') if info.get(
'backup_file') else ""
info_changed = info.get('changed') if info.get('changed') else False
info_failed = info.get('failed') if info.get('failed') else False
info_name = info.get('name') if info.get('name') else ""
info_msg = info.get('msg') if info.get('msg') else ""
info_state = info.get('state') if info.get('state') else ""
info_enable = info.get('enable') if info.get('enable') else ""
if 'command' in task.task_type:
task.log = json.dumps(info.get('results'))
if info.get('results') is not None:
task_result = "SUCCEED "
task.changes[:] = []
for index, change_info in enumerate(info_result, start=1):
change_status = "OK" if change_info.get(
'failed') is False else "FAILED"
change_log = " stdout = " + change_info.get(
"stdout") + "|| stderr = " + change_info.get("stderr")
task_result = "ERROR " + change_info.get(
"stderr") if change_info.get(
"stderr"
) != "" else task_result + change_info.get("stdout")
finished_at = datetime.now(
) if change_info.get('failed') is False else None
change_type = json.dumps(change_info)
change_type = change_type[:250] + (change_type[250:] and '..')
file_config_id = -1
change = models.Change(created_at=datetime.now(),
change_type=change_type,
status=change_status,
change_log=change_log,
finished_at=finished_at,
file_config_id=file_config_id)
task.changes.append(change)
task.result = task_result
if 'template' in task.task_type:
if info_changed:
task.result = "SUCCEED CHANGE FILE: " + info_dest
task.log = "dest: " + info_dest + '|| backup: ' + info_backup_file
task.changes[:] = []
file_config_id = -1
change = models.Change(created_at=datetime.now(),
change_type='template',
status='OK',
change_log=task.log,
finished_at=datetime.now(),
file_config_id=file_config_id)
task.changes.append(change)
else:
if info_failed == False:
task.result = "DONE NOTHING CHANGED: " + info_dest
else:
task.result = "FAILED TO CHANGE FILE " + info_msg
task.log = json.dumps(info)
if 'systemd' in task.task_type:
if info_changed:
task.result = "SUCCEED SYSTEMD SERVICE: " + info_name
task.log = "service: " + info_name + ' || state: ' + info_state + ' || enable: ' + info_enable
task.changes[:] = []
file_config_id = -1
change = models.Change(created_at=datetime.now(),
change_type='service',
status='OK',
change_log=task.log,
finished_at=datetime.now(),
file_config_id=file_config_id)
task.changes.append(change)
else:
if info_failed == False:
task.result = "DONE NOTHING CHANGED: " + info_name
else:
task.result = "FAILED TO CHANGE SERVICE " + info_msg
task.log = json.dumps(info)
if 'uri' in task.task_type:
if info_failed == True:
info_status = info.get('status') if info.get('status') else ""
task.result = "FAILED Status = " + str(
info_status) + " Message: " + str(info_msg)
task.log = json.dumps(info)
else:
info_status = info.get('status') if info.get('status') else ""
task.result = "OK Status = " + str(
info_status) + " Message: " + str(info_msg)
task.log = json.dumps(info)
session.add(task)
session.commit()
#res = jsonify(models.to_json(task, 'Task', False))
session.close()
return {"ok": "ok"}, 200
session.add(task)
session.commit()
res = jsonify(models.to_json(task, 'Task', False))
session.close()
return res, 200
def deletar_pedido(id):
del_pedido = session.get(tbl_pedido, id)
session.delete(del_pedido)
session.commit()
session.close()
return redirect(url_for('admin_pedido'))
def run_specific_deployment():
if not request.json:
abort(400)
else:
service_setup_id = request.json.get('service_setup_id')
deployment_id = request.json.get('deployment_id')
method = request.json.get('method')
service_setup_start = None
if service_setup_id is not None:
service_setup_start = session.query(models.Service_setup).filter_by(
service_setup_id=service_setup_id).first()
if service_setup_start is None:
return abort(400, "Cannot Find Service_setup with id: ",
service_setup_id)
if deployment_id is not None:
deployment = session.query(
models.Deployment).filter_by(deployment_id=deployment_id).first()
if deployment is None:
return abort(400, "Cannot Find deployment with id: ",
deployment_id)
if service_setup_start.deployment.deployment_id != deployment.deployment_id:
return abort(400, "Service Setup Khong thuoc Deployment")
list_service_setups = get_service_setups_from_deployment(deployment)
if method == "Install":
list_logs = []
for service_setup in list_service_setups:
if service_setup.setup_index >= service_setup_start.setup_index:
node = deployment.node
service_name = service_setup.service_name
node_display_name = node.node_display_name
runner = Runner(playbook='playbook_setup_' + service_name +
'_for_' + node_display_name + '.yml',
inventory='new_node',
run_data={
'extra_vars': {
'target': 'No'
},
'tags': ['install']
},
start_at_task=None,
step=False,
private_key_file=None,
become_pass=None,
verbosity=None)
runner.run()
list_logs.append(runner.log)
status = session.query(models.Service_setup).filter_by(
service_setup_id=service_setup.service_setup_id).first(
).status
session.commit()
if status != 'DONE':
break
session.close()
return {"logs": list_logs}
# ansible-playbook ansible_compute.yml --extra-vars "target=target other_variable=foo" --tags "install, uninstall" --start-at-task=task.task_display_name --step
else:
return {"res": "INCOMMING"}
def run_specific_service_setup():
if not request.json:
abort(400)
else:
service_setup_id = request.json.get('service_setup_id')
deployment_id = request.json.get('deployment_id')
setup_index = request.json.get('setup_index')
method = request.json.get('method')
start_at_task_id = request.json.get('start_at_task_id')
service_setup = None
if service_setup_id is not None:
service_setup = session.query(models.Service_setup).filter_by(
service_setup_id=service_setup_id).first()
if service_setup is None:
return abort(400, "Cannot Find Service_setup with id: ",
service_setup_id)
else:
if deployment_id is not None and setup_index is not None:
service_setup = session.query(models.Service_setup).filter_by(
setup_index=setup_index, deployment_id=deployment_id).first()
if service_setup is None:
return abort(400,
"Cannot Find Service_setup with setup_index: ",
setup_index, "deployment_id: ", deployment_id)
if start_at_task_id is not None:
start_task = session.query(
models.Task).filter_by(task_id=start_at_task_id).first()
if start_task is not None:
start_task_name = start_task.task_display_name
else:
start_task_name = None
deployment = service_setup.deployment
node = deployment.node
service_name = service_setup.service_name
node_display_name = node.node_display_name
session.close()
if method == "Install":
runner = Runner(playbook='playbook_setup_' + service_name + '_for_' +
node_display_name + '.yml',
inventory='new_node',
run_data={
'extra_vars': {
'target': 'No'
},
'tags': ['install']
},
start_at_task=start_task_name,
step=False,
private_key_file=None,
become_pass=None,
verbosity=None)
# ansible-playbook ansible_compute.yml --extra-vars "target=target other_variable=foo" --tags "install, uninstall" --start-at-task=task.task_display_name --step
print(runner.variable_manager)
stats_run = runner.run()
print(stats_run)
return {"stats": str(stats_run), "logs": runner.log}
else:
return {"res": "INCOMMING"}
