def server_basic_info(user):
try:
response, content = callRestServer(user, None, 'nodeinfo', 'basicinfo', None, True, False)
if response.getStatus() == 200:
update_time = datetime.now()
total_servers = len(content)
i = 0
for server in content:
#verify if server exists in database
server_name = server.getSender()
#Using filter because get sometimes generates query error
#The filter result is a collection, so you need to select the first element to work
query_response = Server.objects.filter(hostname=server_name)
if query_response:
retrieved_server = query_response[0]
logger.info("Updating Server information " + server_name)
complete_server_info(retrieved_server, server, update_time)
retrieved_server.save()
else:
logger.info("Creating new server with name " + server_name)
new_server = Server.objects.create(hostname=server_name)
complete_server_info(new_server, server, update_time)
new_server.save()
i = i + 1
server_basic_info.update_state(state="PROGRESS", meta={"current": i, "total": total_servers})
except Exception, err:
logger.error('ERROR: ' + str(err))
def get_apps_list(user, filters, file_type):
logger.debug("Calling app_list with filters %s and type %s" %
(filters, str(file_type)))
try:
response, content = callRestServer(user, filters, "jboss", "applist",
"apptype=" + str(file_type))
if response.status == 200:
jsonObj = json.loads(content)
if jsonObj:
#Looking for "intersections"
app_list = None
for server_response in jsonObj:
if not app_list:
app_list = server_response['data']['applist']
else:
app_list = set(app_list).intersection(
server_response['data']['applist'])
#If I test the intersection I need to re-convert my object to list
if type(app_list) == set:
app_list = list(app_list)
return json.dumps({"errors": "", "applist": app_list})
else:
return json.dumps({"errors": "Cannot retrieve apps list"})
except Exception, err:
logger.error('ERROR: ' + str(err))
def hostCallInventory(request, hostname):
filters = "identity=%s" % hostname
response, content = callRestServer(request.user, filters, "rpcutil",
"inventory", None, True)
if response.getStatus() == 200:
jsonObj = []
for entry in content:
jsonObj.append(entry.to_dict())
return render_to_response('server/inventory.html', {
"base_url": settings.BASE_URL,
"static_url": settings.STATIC_URL,
"hostname": hostname,
'service_status_url': settings.RUBY_REST_PING_URL,
"c": jsonObj[0]
},
context_instance=RequestContext(request))
else:
return render_to_response(
'server/inventory.html', {
"base_url": settings.BASE_URL,
"static_url": settings.STATIC_URL,
"hostname": hostname,
'service_status_url': settings.RUBY_REST_PING_URL
},
context_instance=RequestContext(request))
def get_server_details(request, hostname, instance_name, resource_name):
filter = "identity_filter=%s"%hostname
server = Server.objects.get(hostname=hostname)
response, content = callRestServer(request.user, filter, "libvirt", "hvinfo", None, True)
if response.getStatus() == 200:
virtual = content[0]
domains = []
for dom in virtual.getData()['inactive_domains']:
info = {'name': dom,
'active': False,
'start_url': reverse('call_mcollective_with_arguments', kwargs={'filters':filter, 'agent':"libvirt", 'action':"start", 'args':"domain=%s"%dom, 'wait_for_response':True}),
'stop_url': reverse('call_mcollective_with_arguments', kwargs={'filters':filter, 'agent':"libvirt", 'action':"shutdown", 'args':"domain=%s"%dom, 'wait_for_response':True})
}
domains.append(info)
for dom in virtual.getData()['active_domains']:
vnc_agent = server.agents.filter(name='libvirtvnc')
novnc_url = None
if len(vnc_agent) > 0:
novnc_url = '%s/novnc/vnc_auto.html?host=%s&port=6080' % (settings.STATIC_URL, hostname)
info = {'name': dom,
'active': True,
'start_url': reverse('call_mcollective_with_arguments', kwargs={'filters':filter, 'agent':"libvirt", 'action':"start", 'args':"domain=%s"%dom, 'wait_for_response':True}),
'stop_url': reverse('call_mcollective_with_arguments', kwargs={'filters':filter, 'agent':"libvirt", 'action':"shutdown", 'args':"domain=%s"%dom, 'wait_for_response':True}),
'start_vnc_proxy_url': reverse('start_vnc_proxy', kwargs={'hostname':hostname, 'domain': dom}),
'novnc_url': novnc_url
}
domains.append(info)
return render_to_response('platforms/virtualization/server.html', {"base_url": settings.BASE_URL, "static_url":settings.STATIC_URL, "hostname": hostname, 'filter': filter ,'virtual': virtual['data'], 'domains': domains}, context_instance=RequestContext(request))
else:
return render_to_response('platforms/virtualization/server.html', {"base_url": settings.BASE_URL, "static_url":settings.STATIC_URL, "hostname": hostname}, context_instance=RequestContext(request))
def get_apps_list(user, filters, file_type):
logger.debug("Calling app_list with filters %s and type %s" %
(filters, str(file_type)))
try:
response, content = callRestServer(user, filters, "jboss", "applist",
"apptype=" + str(file_type), False,
False)
if response.status == 200:
jsonObj = json.loads(content)
if jsonObj:
#Looking for "intersections"
app_list = None
for server_response in jsonObj:
if server_response['statuscode'] == 0 and server_response[
'data']:
if not app_list:
app_list = server_response['data']['applist']
else:
app_list = list(
set(app_list).intersection(
server_response['data']['applist']))
else:
logger.warn("No app list received")
return json.dumps({"errors": "", "applist": app_list})
else:
return json.dumps({"errors": "Cannot retrieve apps list"})
except Exception, err:
logger.error('ERROR: ' + str(err))
def start_vnc_proxy(request, hostname, domain):
response, content = callRestServer(request.user, "identity_filter=%s"%hostname, "libvirtvnc", "start_proxy", "domain=%s"%domain, True)
if response.status == 200:
json_data = json.loads(content)
return HttpResponse(json_data, mimetype='application/javascript')
else:
print "ERRROR"
def inventoryUpdate(self, user):
logger.debug("Calling WebLoginc Inventory")
try:
response, content = callRestServer(user, 'no-filter', 'a7xows',
'inventory')
except Exception, err:
logger.error('ERROR: ' + str(err))
def get_apps_list(user, filters, file_type):
logger.debug("Calling app_list with filters %s and type %s" %
(filters, str(file_type)))
try:
response, content = callRestServer(user, filters, "a7xows", "applist",
"apptype=" + str(file_type), False,
False)
if response.getStatus() == 200:
if content:
#Looking for "intersections"
app_list = None
for server_response in content:
if server_response.getStatusCode(
) == 0 and server_response.getData():
if not app_list:
app_list = server_response.getData()['applist']
else:
app_list = list(
set(app_list).intersection(
server_response.getData()['applist']))
else:
logger.warn("No app list received")
return json.dumps({"errors": "", "applist": app_list})
else:
return json.dumps({"errors": "Cannot retrieve apps list"})
except Exception, err:
logger.error('ERROR: ' + str(err))
def execute_action_form(request, agent, action, filters, dialog_name, response_container, xhr=None):
if request.method == "POST":
inputs = get_action_inputs(agent, action)
logger.debug("Recreating form")
form_type = create_action_form(inputs)
form = form_type(request.POST)
#Check if the <xhr> var had something passed to it.
if xhr == "xhr":
# Yup, this is an Ajax request.
# Validate the form:
clean = form.is_valid()
# Make some dicts to get passed back to the browser
rdict = {'bad':'false', 'agent':agent, 'action':action, 'dialog_name':dialog_name, 'response_container':response_container, 'filters':filters }
if not clean:
rdict.update({'bad':'true'})
d = {}
# This was painful, but I can't find a better way to extract the error messages:
for e in form.errors.iteritems():
d.update({e[0]:unicode(e[1])}) # e[0] is the id, unicode(e[1]) is the error HTML.
# Bung all that into the dict
rdict.update({'errs': d })
# Make a json whatsit to send back.
json_data = json.dumps(rdict, ensure_ascii=False)
else:
logger.debug("Parameters check: OK.")
logger.debug("Creating args")
arguments=None
for input in inputs:
if form.cleaned_data[input['name']]:
if arguments:
arguments = arguments + ';'
else:
arguments = ''
arguments = arguments + input['name'] + '=' + form.cleaned_data[input['name']]
logger.debug("Arguments for MCollective call %s" % arguments)
wait_for_response = False
response, content = callRestServer(request.user, filters, agent, action, arguments, wait_for_response)
#Leave wait for response check it to support both two in the future (read wait_for_response from config file)
if wait_for_response:
if response.status == 200:
json_data = render_agent_template(request, rdict, content, form.cleaned_data, agent, action)
return HttpResponse(json_data, mimetype='application/javascript')
else:
rdict.update({"result": "KO", "message": "Error communicating with server. <br> %s"%content})
else:
logger.debug("Returning request UUID")
update_url = reverse('get_progress', kwargs={'taskname':content, 'taskid':response.task_id})
rdict.update({"UUID": response.task_id, "taskname": content, 'update_url': update_url})
return HttpResponse(json.dumps(rdict, ensure_ascii=False), mimetype='application/javascript')
else:
if form.is_valid():
logger.error("Trying to execute a NON Ajax call. Rejected and redirected to DashBoard.")
return HttpResponseRedirect(settings.BASE_URL)
else:
# It's not post so make a new form
logger.warn("Cannot access this page using GET")
raise Http404
def execute_action_form(request, agent, action, filters, dialog_name, response_container, xhr=None):
if request.method == "POST":
inputs = get_action_inputs(agent, action)
logger.debug("Recreating form")
form_type = create_action_form(inputs)
form = form_type(request.POST)
#Check if the <xhr> var had something passed to it.
if xhr == "xhr":
# Yup, this is an Ajax request.
# Validate the form:
clean = form.is_valid()
# Make some dicts to get passed back to the browser
rdict = {'bad':'false', 'agent':agent, 'action':action, 'dialog_name':dialog_name, 'response_container':response_container, 'filters':filters }
if not clean:
rdict.update({'bad':'true'})
d = {}
# This was painful, but I can't find a better way to extract the error messages:
for e in form.errors.iteritems():
d.update({e[0]:unicode(e[1])}) # e[0] is the id, unicode(e[1]) is the error HTML.
# Bung all that into the dict
rdict.update({'errs': d })
# Make a json whatsit to send back.
json_data = json.dumps(rdict, ensure_ascii=False)
else:
logger.debug("Parameters check: OK.")
logger.debug("Creating args")
arguments=None
for input in inputs:
if form.cleaned_data[input['name']]:
if arguments:
arguments = arguments + ';'
else:
arguments = ''
arguments = arguments + input['name'] + '=' + form.cleaned_data[input['name']]
logger.debug("Arguments for MCollective call %s" % arguments)
wait_for_response = False
response, content = callRestServer(request.user, filters, agent, action, arguments, wait_for_response)
#Leave wait for response check it to support both two in the future (read wait_for_response from config file)
if wait_for_response:
if response.getStatus() == 200:
json_data = render_agent_template(request, rdict, content, form.cleaned_data, agent, action)
return HttpResponse(json_data, mimetype='application/javascript')
else:
rdict.update({"result": "KO", "message": "Error communicating with server. <br> %s"%content})
else:
logger.debug("Returning request UUID")
update_url = reverse('get_progress', kwargs={'taskname':content, 'taskid':response.task_id})
rdict.update({"UUID": response.task_id, "taskname": content, 'update_url': update_url})
return HttpResponse(json.dumps(rdict, ensure_ascii=False), mimetype='application/javascript')
else:
if form.is_valid():
logger.error("Trying to execute a NON Ajax call. Rejected and redirected to DashBoard.")
return HttpResponseRedirect(settings.BASE_URL)
else:
# It's not post so make a new form
logger.warn("Cannot access this page using GET")
raise Http404
def sql_list(user, filters):
file_type = "sql"
logger.debug("Calling get_sql_list with filters %s and type %s" %
(filters, str(file_type)))
try:
response, content = callRestServer(user, filters, "postgresql",
"sql_list", None, False, False)
if response.status == 200:
jsonObj = json.loads(content)
if jsonObj:
#Looking for "intersections"
sql_list = None
for server_response in jsonObj:
if server_response['statuscode'] == 0 and server_response[
'data']:
if not sql_list:
sql_list = server_response['data']['sqllist']
else:
sql_list = list(
set(sql_list).intersection(
server_response['data']['sqllist']))
else:
logger.warn("No sqllist received")
return json.dumps({"errors": "", "sqllist": sql_list})
else:
return json.dumps({"errors": "Cannot retrieve sqls list"})
except Exception, err:
logger.error('ERROR: ' + str(err))
def server_basic_info(user):
try:
response, content = callRestServer(user, None, 'nodeinfo', 'basicinfo',
None, True, False)
if response.getStatus() == 200:
update_time = datetime.now()
total_servers = len(content)
i = 0
for server in content:
#verify if server exists in database
server_name = server.getSender()
#Using filter because get sometimes generates query error
#The filter result is a collection, so you need to select the first element to work
query_response = Server.objects.filter(hostname=server_name)
if query_response:
retrieved_server = query_response[0]
logger.info("Updating Server information " + server_name)
complete_server_info(retrieved_server, server, update_time)
retrieved_server.save()
else:
logger.info("Creating new server with name " + server_name)
new_server = Server.objects.create(hostname=server_name)
complete_server_info(new_server, server, update_time)
new_server.save()
i = i + 1
server_basic_info.update_state(state="PROGRESS",
meta={
"current": i,
"total": total_servers
})
except Exception, err:
logger.error('ERROR: ' + str(err))
def getWithTemplate(request, template):
if request.method != "POST":
return HttpResponseForbidden()
agent = request.POST["agent"]
action = request.POST["action"]
filters = request.POST["filters"]
if request.POST["parameters"]:
args = request.POST["parameters"]
if verify_agent_acl(request.user, agent) and verify_action_acl(
request.user, agent, action):
response, content = callRestServer(request.user, filters, agent,
action, args, True)
if response.getStatus() == 200:
jsonObj = []
for entry in content:
jsonObj.append(entry.to_dict())
templatePath = 'ajax/' + template + '.html'
data = {'content': jsonObj}
return render_to_response(templatePath,
data,
context_instance=RequestContext(request))
return response
else:
return HttpResponseForbidden()
def getWithTemplate(request, template):
if request.method != "POST":
return HttpResponseForbidden()
agent = request.POST["agent"]
action = request.POST["action"]
filters = request.POST["filters"]
if request.POST["parameters"]:
args = request.POST["parameters"]
if verify_agent_acl(request.user, agent) and verify_action_acl(request.user, agent, action):
response, content = callRestServer(request.user, filters, agent, action, args, True)
if response.getStatus() == 200:
jsonObj = []
for entry in content:
jsonObj.append(entry.to_dict())
templatePath = 'ajax/' + template + '.html'
data = {
'content': jsonObj
}
return render_to_response( templatePath, data,
context_instance = RequestContext( request ) )
return response
else:
return HttpResponseForbidden()
def get(request, wait_for_response=False):
if request.method != "POST":
return HttpResponseForbidden()
agent = request.POST["agent"]
action = request.POST["action"]
filters = request.POST["filters"]
if request.POST["parameters"]:
args = request.POST["parameters"]
#Fix for unicode wait_for_response variable (actually used in url only for Virtualization Platform)
if wait_for_response == "false" or wait_for_response == "False":
wait_for_response = False
elif wait_for_response == "true" or wait_for_response == "True":
wait_for_response = True
if verify_agent_acl(request.user, agent) and verify_action_acl(request.user, agent, action):
response, content = callRestServer(request.user, filters, agent, action, args, wait_for_response)
if wait_for_response:
if response.getStatus() == 200:
json_data = render_agent_template(request, {}, content, {}, agent, action)
return HttpResponse(json_data, mimetype="application/json")
else:
logger.debug("Returning request UUID")
update_url = reverse('get_progress', kwargs={'taskname':content, 'taskid':response.task_id})
json_data = json.dumps({"UUID": response.task_id, "taskname": content, 'update_url': update_url})
return HttpResponse(json_data, mimetype="application/json")
else:
return HttpResponseForbidden()
def inventoryUpdate(self, user):
logger.debug("Calling PostgreSQL Inventory")
try:
response, content = callRestServer(user, 'no-filter', 'postgresql',
'inventory')
except Exception, err:
logger.error('ERROR: ' + str(err))
def hostCallInventory(request, hostname):
filters = "identity_filter=%s" % hostname
response, content = callRestServer(request.user, filters, "rpcutil", "inventory")
if response.status == 200:
jsonObj = json.loads(content)
return render_to_response('server/inventory.html', {"base_url": settings.BASE_URL, "static_url":settings.STATIC_URL, "hostname": hostname, 'service_status_url':settings.RUBY_REST_PING_URL, "c": jsonObj[0]}, context_instance=RequestContext(request))
else:
return render_to_response('server/inventory.html', {"base_url": settings.BASE_URL, "static_url":settings.STATIC_URL, "hostname": hostname, 'service_status_url':settings.RUBY_REST_PING_URL}, context_instance=RequestContext(request))
def inventoryUpdate(self, user, use_another_task=True):
logger.debug("Calling JBoss Inventory")
try:
response, content = callRestServer(user, None, 'jboss',
'inventory', None, True,
use_another_task)
except Exception, err:
logger.error('ERROR: ' + str(err))
def inventoryUpdate(self, user, use_another_task=True):
logger.debug("Calling OracleDB Inventory")
try:
response, content = callRestServer(user, 'no-filter', 'oracledb',
'inventory', None, True,
use_another_task)
except Exception, err:
logger.error('ERROR: ' + str(err))
def clone_db(request, filters, dialog_name, xhr=None):
if request.method == "POST":
logger.debug("Recreating form")
form = CloneDatabaseForm(request.POST)
#Check if the <xhr> var had something passed to it.
if xhr == "xhr":
#TODO: Try to use dynamic form validation
clean = form.is_valid()
rdict = {'bad':'false', 'filters':filters }
try:
instance = request.POST['instance']
schema = request.POST['schema']
target_server = request.POST['targetserver']
target_instance = request.POST['targetinstance']
except:
instance=None
schema=None
target_server=None
target_instance=None
if instance and schema and target_server and target_instance:
logger.debug("Parameters check: OK.")
logger.debug("Calling MCollective to export %s from %s to %s" % (schema, instance, target_server))
response, content = callRestServer(request.user, filters, 'oracledb', 'export_database', 'instancename=%s;schema=%s' %(instance, schema), True)
if response.status == 200:
json_content = json.loads(content)
s_resps = []
for server_response in json_content:
if server_response['statuscode']==0:
s_resps.append({"server": server_response["sender"], "response":server_response["statusmsg"]})
else:
s_resps.append({"server": server_response["sender"], "message":server_response["statusmsg"]})
rdict.update({"result":s_resps})
else:
rdict.update({"result": "KO", "message": "Error communicating with server"})
rdict.update({'dialog_name':dialog_name})
# And send it off.
else:
rdict.update({'bad':'true'})
d = {}
# This was painful, but I can't find a better way to extract the error messages:
for e in form.errors.iteritems():
d.update({e[0]:unicode(e[1])}) # e[0] is the id, unicode(e[1]) is the error HTML.
# Bung all that into the dict
rdict.update({'errs': d })
# Make a json whatsit to send back.
return HttpResponse(json.dumps(rdict, ensure_ascii=False), mimetype='application/javascript')
# It's a normal submit - non ajax.
else:
if form.is_valid():
# We don't accept non-ajax requests for the moment
return HttpResponseRedirect("/")
else:
# It's not post so make a new form
logger.warn("Cannot access this page using GET")
raise Http404
def redeploy_app(request, filters, dialog_name, xhr=None):
if request.method == "POST":
logger.debug("Recreating form")
form = DeployForm(request.POST)
#Check if the <xhr> var had something passed to it.
if xhr == "xhr":
#TODO: Try to use dynamic form validation
clean = form.is_valid()
rdict = {'bad': 'false', 'filters': filters}
try:
appfile = request.POST['applist']
app_type = request.POST['types']
instancename = request.POST['instancename']
appname = request.POST['appname']
except:
appname = None
app_type = None
if appname and app_type:
logger.debug("Parameters check: OK.")
logger.debug(
"Calling MCollective to deploy %s application on %s filtered server"
% (appfile, filters))
response, content = callRestServer(
request.user, filters, 'a7xoas', 'redeploy',
'appname=%s;instancename=%s;appfile=%s' %
(appname, instancename, appfile))
if response.status == 200:
json_content = json.loads(content)
rdict.update({"result": json_content[0]["statusmsg"]})
else:
rdict.update({"result": "Error communicating with server"})
rdict.update({'dialog_name': dialog_name})
# And send it off.
else:
rdict.update({'bad': 'true'})
d = {}
# This was painful, but I can't find a better way to extract the error messages:
for e in form.errors.iteritems():
d.update({
e[0]: unicode(e[1])
}) # e[0] is the id, unicode(e[1]) is the error HTML.
# Bung all that into the dict
rdict.update({'errs': d})
# Make a json whatsit to send back.
return HttpResponse(json.dumps(rdict, ensure_ascii=False),
mimetype='application/javascript')
# It's a normal submit - non ajax.
else:
if form.is_valid():
# We don't accept non-ajax requests for the moment
return HttpResponseRedirect("/")
else:
# It's not post so make a new form
logger.warn("Cannot access this page using GET")
raise Http404
def execute_sql(request, filters, dialog_name, xhr=None):
if request.method == "POST":
logger.debug("Recreating form")
form = SqlExecuteForm(request.POST)
#Check if the <xhr> var had something passed to it.
if xhr == "xhr":
#TODO: Try to use dynamic form validation
clean = form.is_valid()
rdict = {'bad':'false', 'filters':filters }
try:
sql_script = request.POST['sqllist']
dbname = request.POST['dbname']
except:
sql_script=None
dbname=None
if sql_script:
logger.debug("Parameters check: OK.")
logger.debug("Calling MCollective to deploy %s sql on %s filtered server" % (sql_script, filters))
user_ip_address = request.META.get('REMOTE_ADDR')
#;user=%s;userip=%s
response, content = callRestServer(request.user, filters, 'postgresql', 'execute_sql', 'sqlfile=%s;dbname=%s' % (sql_script, dbname), True)
#TODO: Improve reading content data
if response.status == 200:
json_content = json.loads(content)
s_resps = []
for server_response in json_content:
if "data" in server_response and "logfile" in server_response["data"]:
s_resps.append({"server": server_response["sender"], "logfile":server_response["data"]["logfile"]})
else:
s_resps.append({"server": server_response["sender"], "message":server_response["statusmsg"]})
rdict.update({"result":s_resps})
else:
rdict.update({"result": "KO", "message": "Error communicating with server"})
rdict.update({'dialog_name':dialog_name})
# And send it off.
else:
rdict.update({'bad':'true'})
d = {}
# This was painful, but I can't find a better way to extract the error messages:
for e in form.errors.iteritems():
d.update({e[0]:unicode(e[1])}) # e[0] is the id, unicode(e[1]) is the error HTML.
# Bung all that into the dict
rdict.update({'errs': d })
# Make a json whatsit to send back.
return HttpResponse(json.dumps(rdict, ensure_ascii=False), mimetype='application/javascript')
# It's a normal submit - non ajax.
else:
if form.is_valid():
# We don't accept non-ajax requests for the moment
return HttpResponseRedirect("/")
else:
# It's not post so make a new form
logger.warn("Cannot access this page using GET")
raise Http404
def start_vnc_proxy(request, hostname, domain):
response, content = callRestServer(request.user, "identity=%s"%hostname, "libvirtvnc", "start_proxy", "domain=%s"%domain, True)
if response.getStatus() == 200:
json_data = []
for entry in content:
json_data.append(entry.to_dict())
return HttpResponse(json_data, mimetype='application/javascript')
else:
print "ERRROR"
def get(request, filters, agent, action, args=None):
if verify_agent_acl(request.user, agent) and verify_action_acl(request.user, agent, action):
response, content = callRestServer(request.user, filters, agent, action, args)
if response.status == 200:
json_data = render_agent_template(request, {}, content, {}, agent, action)
return HttpResponse(json_data, mimetype="application/json")
return response
else:
return HttpResponseForbidden()
def create_instance(request, filters, dialog_name, xhr=None):
if request.method == "POST":
logger.debug("Recreating form")
form = InstanceForm(request.POST)
#Check if the <xhr> var had something passed to it.
if xhr == "xhr":
#TODO: Try to use dynamic form validation
clean = form.is_valid()
rdict = {'bad':'false', 'filters':filters }
try:
instancename = request.POST['instancename']
except:
instancename=None
if instancename:
logger.debug("Parameters check: OK.")
logger.debug("Calling MCollective to create instance %s on %s filtered server" % (instancename, filters))
response, content = callRestServer(request.user, filters, 'a7xows', 'createinstace', 'instancename=%s' %(instancename), wait_response=True, use_task=True, use_backend_scheduler=True)
if response.getStatus() == 200:
s_resps = []
for server_response in content:
if server_response.getStatusCode()==0:
response_message = 'Instance Created'
if server_response.getData() and "statusmsg" in server_response.getData() and server_response.getData()["statusmsg"]!='OK':
response_message = server_response.getData()["statusmsg"]
elif server_response.getStatusMessage() and server_response.getStatusMessage()!='OK':
response_message = server_response.getStatusMessage()
s_resps.append({"server": server_response.getSender(), "response":response_message})
else:
s_resps.append({"server": server_response.getSender(), "message":server_response.getStatusMessage()})
rdict.update({"result":s_resps})
else:
rdict.update({"result": "KO", "message": "Error communicating with server"})
rdict.update({'dialog_name':dialog_name})
# And send it off.
else:
rdict.update({'bad':'true'})
d = {}
# This was painful, but I can't find a better way to extract the error messages:
for e in form.errors.iteritems():
d.update({e[0]:unicode(e[1])}) # e[0] is the id, unicode(e[1]) is the error HTML.
# Bung all that into the dict
rdict.update({'errs': d })
# Make a json whatsit to send back.
return HttpResponse(json.dumps(rdict, ensure_ascii=False), mimetype='application/javascript')
# It's a normal submit - non ajax.
else:
if form.is_valid():
# We don't accept non-ajax requests for the moment
return HttpResponseRedirect("/")
else:
# It's not post so make a new form
logger.warn("Cannot access this page using GET")
raise Http404
def create_instance(request, filters, dialog_name, xhr=None):
if request.method == "POST":
logger.debug("Recreating form")
form = InstanceForm(request.POST)
#Check if the <xhr> var had something passed to it.
if xhr == "xhr":
#TODO: Try to use dynamic form validation
clean = form.is_valid()
rdict = {'bad':'false', 'filters':filters }
try:
instancename = request.POST['instancename']
except:
instancename=None
if instancename:
logger.debug("Parameters check: OK.")
logger.debug("Calling MCollective to create instance %s on %s filtered server" % (instancename, filters))
response, content = callRestServer(request.user, filters, 'a7xows', 'createinstace', 'instancename=%s' %(instancename), True, True, True)
if response.getStatus() == 200:
s_resps = []
for server_response in content:
if server_response.getStatusCode()==0:
response_message = 'Instance Created'
if server_response.getData() and "statusmsg" in server_response.getData() and server_response.getData()["statusmsg"]!='OK':
response_message = server_response.getData()["statusmsg"]
elif server_response.getStatusMessage() and server_response.getStatusMessage()!='OK':
response_message = server_response.getStatusMessage()
s_resps.append({"server": server_response.getSender(), "response":response_message})
else:
s_resps.append({"server": server_response.getSender(), "message":server_response.getStatusMessage()})
rdict.update({"result":s_resps})
else:
rdict.update({"result": "KO", "message": "Error communicating with server"})
rdict.update({'dialog_name':dialog_name})
# And send it off.
else:
rdict.update({'bad':'true'})
d = {}
# This was painful, but I can't find a better way to extract the error messages:
for e in form.errors.iteritems():
d.update({e[0]:unicode(e[1])}) # e[0] is the id, unicode(e[1]) is the error HTML.
# Bung all that into the dict
rdict.update({'errs': d })
# Make a json whatsit to send back.
return HttpResponse(json.dumps(rdict, ensure_ascii=False), mimetype='application/javascript')
# It's a normal submit - non ajax.
else:
if form.is_valid():
# We don't accept non-ajax requests for the moment
return HttpResponseRedirect("/")
else:
# It's not post so make a new form
logger.warn("Cannot access this page using GET")
raise Http404
def hostCallInventory(request, hostname):
filters = "identity_filter=%s" % hostname
response, content = callRestServer(request.user, filters, "rpcutil", "inventory", None, True)
if response.getStatus() == 200:
jsonObj = []
for entry in content:
jsonObj.append(entry.to_dict())
return render_to_response('server/inventory.html', {"base_url": settings.BASE_URL, "static_url":settings.STATIC_URL, "hostname": hostname, 'service_status_url':settings.RUBY_REST_PING_URL, "c": jsonObj[0]}, context_instance=RequestContext(request))
else:
return render_to_response('server/inventory.html', {"base_url": settings.BASE_URL, "static_url":settings.STATIC_URL, "hostname": hostname, 'service_status_url':settings.RUBY_REST_PING_URL}, context_instance=RequestContext(request))
def start_vnc_proxy(request, hostname, domain):
response, content = callRestServer(request.user,
"identity_filter=%s" % hostname,
"libvirtvnc", "start_proxy",
"domain=%s" % domain, True)
if response.status == 200:
json_data = json.loads(content)
return HttpResponse(json_data, mimetype='application/javascript')
else:
print "ERRROR"
def start_vnc_proxy(request, hostname, domain):
response, content = callRestServer(request.user, "identity=%s" % hostname,
"libvirtvnc", "start_proxy",
"domain=%s" % domain, True)
if response.getStatus() == 200:
json_data = []
for entry in content:
json_data.append(entry.to_dict())
return HttpResponse(json_data, mimetype='application/javascript')
else:
print "ERRROR"
def get_templates(request, hostname):
logger.debug("Calling get_templates")
templates_list = []
filters = "identity=%s" % hostname
response, content = callRestServer(request.user, filters, "ovirt", "get_templates", wait_response=True, use_task=True)
if response.getStatus() == 200 and len(content)>0:
if len(content) > 1:
logger.warn("More than one server sent a response.")
if "templates" in content[0].getData():
for template in content[0].getData()["templates"]:
templates_list.append({"id": template["id"], "name": template["name"]})
return HttpResponse(json.dumps(templates_list, ensure_ascii=False), mimetype='application/javascript')
def get(request, filters, agent, action, args=None):
if verify_agent_acl(request.user, agent) and verify_action_acl(
request.user, agent, action):
response, content = callRestServer(request.user, filters, agent,
action, args)
if response.status == 200:
json_data = render_agent_template(request, {}, content, {}, agent,
action)
return HttpResponse(json_data, mimetype="application/json")
return response
else:
return HttpResponseForbidden()
def check_kermit_base_agents(user):
#Execute PING Mco Operation
check_kermit_base_agents.update_state(state="PROGRESS", meta={"current": 0, "total": 100})
response, content = callRestServer(user, None, "rpcutil", "ping", use_task=False)
if response.getStatus() == 200:
ping_list = []
for resp in content:
ping_list.append(resp.getSender())
logger.debug("Ping List: %s" % ping_list)
logger.debug("Executing PING with agent=nodeinfo filter")
check_kermit_base_agents.update_state(state="PROGRESS", meta={"current": 25, "total": 100})
response, content_nodeinfo = callRestServer(user, "agent=nodeinfo", "rpcutil", "ping", use_task=False)
nodeinfo_list = []
for resp in content_nodeinfo:
nodeinfo_list.append(resp.getSender())
logger.debug("NodeInfo List: %s" % nodeinfo_list)
logger.debug("Executing PING with agent=agentinfo filter")
check_kermit_base_agents.update_state(state="PROGRESS", meta={"current": 50, "total": 100})
response, content_agentinfo = callRestServer(user, "agent=agentinfo", "rpcutil", "ping", use_task=False)
agentinfo_list = []
for resp in content_agentinfo:
agentinfo_list.append(resp.getSender())
logger.debug("AgentInfo List: %s" % agentinfo_list)
logger.debug("Verify pings responses")
servers_without_nodeinfo = list(ping_list)
try:
[servers_without_nodeinfo.remove(x) for x in nodeinfo_list]
except Exception, e:
logger.error("Error in servers lists: %s" % str(e))
servers_without_nodeinfo = []
servers_without_agentinfo = list(ping_list)
try:
[servers_without_agentinfo.remove(x) for x in agentinfo_list]
except Exception, e:
logger.error("Error in servers lists: %s" % str(e))
servers_without_agentinfo = []
def execute_action_form(request, agent, action, filters, dialog_name, response_container, xhr=None):
if request.method == "POST":
inputs = get_action_inputs(agent, action)
logger.debug("Recreating form")
form_type = create_action_form(inputs)
form = form_type(request.POST)
#Check if the <xhr> var had something passed to it.
if xhr == "xhr":
# Yup, this is an Ajax request.
# Validate the form:
clean = form.is_valid()
# Make some dicts to get passed back to the browser
rdict = {'bad':'false', 'agent':agent, 'action':action, 'dialog_name':dialog_name, 'response_container':response_container, 'filters':filters }
if not clean:
rdict.update({'bad':'true'})
d = {}
# This was painful, but I can't find a better way to extract the error messages:
for e in form.errors.iteritems():
d.update({e[0]:unicode(e[1])}) # e[0] is the id, unicode(e[1]) is the error HTML.
# Bung all that into the dict
rdict.update({'errs': d })
# Make a json whatsit to send back.
json_data = json.dumps(rdict, ensure_ascii=False)
else:
logger.debug("Parameters check: OK.")
logger.debug("Creating args")
arguments=None
for input in inputs:
if form.cleaned_data[input['name']]:
if arguments:
arguments = arguments + ';'
else:
arguments = ''
arguments = arguments + input['name'] + '=' + form.cleaned_data[input['name']]
logger.debug("Arguments for MCollective call " + arguments)
response, content = callRestServer(request.user, filters, agent, action, arguments)
if response.status == 200:
json_data = render_agent_template(request, rdict, content, form.cleaned_data, agent, action)
# And send it off.
return HttpResponse(json_data, mimetype='application/javascript')
# It's a normal submit - non ajax.
else:
if form.is_valid():
# We don't accept non-ajax requests for the moment
return HttpResponseRedirect("/")
else:
# It's not post so make a new form
logger.warn("Cannot access this page using GET")
raise Http404
def get_log(request, filters, dialog_name, xhr=None):
if request.method == "POST":
logger.debug("Recreating form")
form = LogForm(request.POST)
#Check if the <xhr> var had something passed to it.
if xhr == "xhr":
#TODO: Try to use dynamic form validation
clean = form.is_valid()
rdict = {'bad':'false', 'filters':filters }
try:
instancename = request.POST['instancename']
appname = request.POST['appname']
except:
instancename=None
appname=None
if instancename and appname:
logger.debug("Parameters check: OK.")
logger.debug("Calling MCollective to get log on %s filtered server" % (filters))
response, content = callRestServer(request.user, filters, 'a7xoas', 'get_log', 'instancename=%s;appname=%s' % (instancename,appname))
if response.status == 200:
json_content = json.loads(content)
s_resps = []
for server_response in json_content:
s_resps.append({"server": server_response["sender"], "logfile":server_response["data"]["logfile"]})
rdict.update({"result":s_resps})
else:
rdict.update({"result": "Error communicating with server"})
rdict.update({'dialog_name':dialog_name})
# And send it off.
else:
rdict.update({'bad':'true'})
d = {}
# This was painful, but I can't find a better way to extract the error messages:
for e in form.errors.iteritems():
d.update({e[0]:unicode(e[1])}) # e[0] is the id, unicode(e[1]) is the error HTML.
# Bung all that into the dict
rdict.update({'errs': d })
# Make a json whatsit to send back.
return HttpResponse(json.dumps(rdict, ensure_ascii=False), mimetype='application/javascript')
# It's a normal submit - non ajax.
else:
if form.is_valid():
# We don't accept non-ajax requests for the moment
return HttpResponseRedirect("/")
else:
# It's not post so make a new form
logger.warn("Cannot access this page using GET")
raise Http404
def getWithTemplate(request, template, filters, agent, action, args=None):
if verify_agent_acl(request.user, agent) and verify_action_acl(request.user, agent, action):
response, content = callRestServer(request.user, filters, agent, action, args)
if response.status == 200:
jsonObj = json.loads(content)
templatePath = 'ajax/' + template + '.html'
data = {
'content': jsonObj
}
return render_to_response( templatePath, data,
context_instance = RequestContext( request ) )
return response
else:
return HttpResponseForbidden()
def get(request, filters, agent, action, args=None, wait_for_response=False):
if verify_agent_acl(request.user, agent) and verify_action_acl(request.user, agent, action):
response, content = callRestServer(request.user, filters, agent, action, args, wait_for_response)
if wait_for_response:
if response.status == 200:
json_data = render_agent_template(request, {}, content, {}, agent, action)
return HttpResponse(json_data, mimetype="application/json")
else:
logger.debug("Returning request UUID")
update_url = reverse('get_progress', kwargs={'taskname':content, 'taskid':response.task_id})
json_data = json.dumps({"UUID": response.task_id, "taskname": content, 'update_url': update_url})
return HttpResponse(json_data, mimetype="application/json")
else:
return HttpResponseForbidden()
def getWithTemplate(request, template, filters, agent, action, args=None):
if verify_agent_acl(request.user, agent) and verify_action_acl(
request.user, agent, action):
response, content = callRestServer(request.user, filters, agent,
action, args)
if response.status == 200:
jsonObj = json.loads(content)
templatePath = 'ajax/' + template + '.html'
data = {'content': jsonObj}
return render_to_response(templatePath,
data,
context_instance=RequestContext(request))
return response
else:
return HttpResponseForbidden()
def check_online(user):
response, content = callRestServer(user, None, "rpcutil", "ping", use_task=False)
if response.getStatus() == 200:
servers_list = []
for resp in content:
servers_list.append(resp.getSender())
servers = Server.objects.all()
for server in servers:
if server.hostname in servers_list or server.fqdn in servers_list:
server.online=True
else:
server.online=False
server.save()
def update_single_dyna(user, dynag):
dynag.servers.clear()
if dynag.engine == 'Facter':
response, content = callRestServer(user, "compound=%s"%dynag.obj_name, 'rpcutil', 'ping', None, True, False)
if response.getStatus() == 200:
for sresp in content:
if sresp.getStatusMessage() == 'OK':
logger.info("Rule match for %s" % sresp.getSender())
try:
server = Server.objects.get(hostname=sresp.getSender())
except:
try:
server = Server.objects.get(fqdn=sresp.getSender())
except:
logger.warn("Cannot find server %s in database" % sresp.getSender())
continue
dynag.servers.add(server)
def check_online(user):
response, content = callRestServer(user,
None,
"rpcutil",
"ping",
use_task=False)
if response.getStatus() == 200:
servers_list = []
for resp in content:
servers_list.append(resp.getSender())
servers = Server.objects.all()
for server in servers:
if server.hostname in servers_list or server.fqdn in servers_list:
server.online = True
else:
server.online = False
server.save()
def get_apps_list(user, filters, file_type):
logger.debug("Calling app_list with filters %s and type %s" % (filters, str(file_type)))
try:
response, content = callRestServer(user, filters, "a7xows", "applist", "apptype="+str(file_type))
if response.status == 200:
jsonObj = json.loads(content)
if jsonObj:
#Looking for "intersections"
app_list = None
for server_response in jsonObj:
if not app_list:
app_list = server_response['data']['applist']
else:
app_list = set(app_list).intersection(server_response['data']['applist'])
return json.dumps({"errors":"", "applist":app_list})
else:
return json.dumps({"errors":"Cannot retrieve apps list"})
except Exception, err:
logger.error('ERROR: ' + str(err))
def server_basic_info(user):
try:
response, content = callRestServer(user, 'no-filter', 'nodeinfo',
'basicinfo')
if response.status == 200:
jsonObj = json.loads(content)
update_time = datetime.now()
total_servers = len(jsonObj)
i = 0
for server in jsonObj:
#verify if server exists in database
server_name = server['sender']
#Using filter because get sometimes generates query error
#The filter result is a collection, so you need to select the first element to work
query_response = Server.objects.filter(hostname=server_name)
if query_response:
retrieved_server = query_response[0]
logger.info("Updating Server information " + server_name)
complete_server_info(retrieved_server, server, update_time)
retrieved_server.save()
else:
logger.info("Creating new server with name " + server_name)
new_server = Server.objects.create(hostname=server_name)
complete_server_info(new_server, server, update_time)
new_server.save()
#Retrieving not updated/created server and set them to OFFLINE
logger.info("Checking offline servers")
not_updated = Server.objects.filter(
updated_time__lt=update_time)
for server in not_updated:
server.online = False
server.save()
i = i + 1
server_basic_info.update_state(state="PROGRESS",
meta={
"current": i,
"total": total_servers
})
except Exception, err:
logger.error('ERROR: ' + str(err))
def get_templates(request, hostname):
logger.debug("Calling get_templates")
templates_list = []
filters = "identity=%s" % hostname
response, content = callRestServer(request.user,
filters,
"ovirt",
"get_templates",
wait_response=True,
use_task=True)
if response.getStatus() == 200 and len(content) > 0:
if len(content) > 1:
logger.warn("More than one server sent a response.")
if "templates" in content[0].getData():
for template in content[0].getData()["templates"]:
templates_list.append({
"id": template["id"],
"name": template["name"]
})
return HttpResponse(json.dumps(templates_list, ensure_ascii=False),
mimetype='application/javascript')
def get_apps_list(user, filters, file_type):
logger.debug("Calling app_list with filters %s and type %s" % (filters, str(file_type)))
try:
response, content = callRestServer(user, filters, "a7xoas", "applist", "apptype="+str(file_type), False, False)
if response.getStatus() == 200:
if content:
#Looking for "intersections"
app_list = None
for server_response in content:
if server_response.getStatusCode()==0 and server_response.getData():
if not app_list:
app_list = server_response.getData()['applist']
else:
app_list = list(set(app_list).intersection(server_response.getData()['applist']))
else:
logger.warn("No app list received")
return json.dumps({"errors":"", "applist":app_list})
else:
return json.dumps({"errors":"Cannot retrieve apps list"})
except Exception, err:
logger.error('ERROR: ' + str(err))
def get_available_bars(user, filters):
logger.debug("Calling bar_list with filters %s" % (filters))
try:
response, content = callRestServer(user, filters, "a7xbar", "applist", "apptype=%s" % "bar", False, False)
if response.getStatus() == 200:
if content:
# Looking for "intersections"
app_list = None
for server_response in content:
if server_response.getStatusCode() == 0 and server_response.getData():
if not app_list:
app_list = server_response.getData()["applist"]
else:
app_list = list(set(app_list).intersection(server_response.getData()["applist"]))
else:
logger.warn("No bar list response received")
return json.dumps({"errors": "", "applist": app_list})
else:
return json.dumps({"errors": "Cannot retrieve apps list"})
except Exception, err:
logger.error("ERROR: " + str(err))
def sql_list(user, filters):
file_type = "sql"
logger.debug("Calling get_sql_list with filters %s and type %s" % (filters, str(file_type)))
try:
response, content = callRestServer(user, filters, "postgresql", "sql_list")
if response.status == 200:
jsonObj = json.loads(content)
if jsonObj:
#Looking for "intersections"
sql_list = None
for server_response in jsonObj:
if not sql_list:
sql_list = server_response['data']['sqllist']
else:
sql_list = set(sql_list).intersection(server_response['data']['applist'])
return json.dumps({"errors":"", "sqllist":sql_list})
else:
return json.dumps({"errors":"Cannot retrieve sqls list"})
except Exception, err:
logger.error('ERROR: ' + str(err))
def submit_server_edit(request, hostname):
if (request.POST and "values" in request.POST):
server_classes = request.POST.getlist('values')
try:
server = Server.objects.get(hostname=hostname)
except:
logger.debug("Trying to get server using fqdn")
server = Server.objects.get(fqdn=hostname)
try:
redis_server = redis.Redis(host="%s"%settings.HIERA_REDIS_SERVER, password="******"%settings.HIERA_REDIS_PASSWORD, port=settings.HIERA_REDIS_PORT, db=settings.HIERA_REDIS_DB)
current_server_classes = redis_server.smembers("%s:%s" % (hostname, "classes"))
for current_class in server_classes:
retrieved = PuppetClass.objects.filter(name=current_class)
if not current_class in current_server_classes and not retrieved[0] in server.puppet_classes.all():
redis_server.sadd("%s:%s" % (hostname, "classes"), current_class)
if retrieved:
server.puppet_classes.add(retrieved[0])
for current_class in current_server_classes:
if not current_class in server_classes:
redis_server.srem("%s:%s" % (hostname, "classes"), current_class)
retrieved = PuppetClass.objects.filter(name=current_class)
if retrieved:
server.puppet_classes.remove(retrieved[0])
logger.debug("New server classes in the Hiera Redis Database: %s" % redis_server.smembers("%s:%s" % (hostname, "classes")))
if "forceUpdate" in request.POST and request.POST["forceUpdate"] == "true":
logger.info("Calling puppet force update for modified server %s" % hostname)
filters = "identity=%s" % hostname
response, content = callRestServer(request.user, filters, "puppet", "runonce", None, wait_response=True, use_task=False)
if response.getStatus() == 200:
for msg in content:
if msg.getStatusMessage() == 'OK':
logger.info("Server correctly updated");
#TODO: Send this information back to user
except:
return HttpResponse(json.dumps({"result": "KO"}, ensure_ascii=False), mimetype='application/javascript')
return HttpResponse(json.dumps({"result": "OK"}, ensure_ascii=False), mimetype='application/javascript')
def get(request, wait_for_response=False):
if request.method != "POST":
return HttpResponseForbidden()
agent = request.POST["agent"]
action = request.POST["action"]
filters = request.POST["filters"]
if request.POST["parameters"]:
args = request.POST["parameters"]
#Fix for unicode wait_for_response variable (actually used in url only for Virtualization Platform)
if wait_for_response == "false" or wait_for_response == "False":
wait_for_response = False
elif wait_for_response == "true" or wait_for_response == "True":
wait_for_response = True
if verify_agent_acl(request.user, agent) and verify_action_acl(
request.user, agent, action):
response, content = callRestServer(request.user, filters, agent,
action, args, wait_for_response)
if wait_for_response:
if response.getStatus() == 200:
json_data = render_agent_template(request, {}, content, {},
agent, action)
return HttpResponse(json_data, mimetype="application/json")
else:
logger.debug("Returning request UUID")
update_url = reverse('get_progress',
kwargs={
'taskname': content,
'taskid': response.task_id
})
json_data = json.dumps({
"UUID": response.task_id,
"taskname": content,
'update_url': update_url
})
return HttpResponse(json_data, mimetype="application/json")
else:
return HttpResponseForbidden()
def get_available_bars(user, filters):
logger.debug("Calling bar_list with filters %s" % (filters))
try:
response, content = callRestServer(user, filters, "a7xbar", "applist", "apptype=%s" % 'bar', False, False)
if response.status == 200:
jsonObj = json.loads(content)
if jsonObj:
#Looking for "intersections"
app_list = None
for server_response in jsonObj:
if server_response['statuscode']==0 and server_response['data']:
if not app_list:
app_list = server_response['data']['applist']
else:
app_list = list(set(app_list).intersection(server_response['data']['applist']))
else:
logger.warn("No bar list response received")
return json.dumps({"errors":"", "applist":app_list})
else:
return json.dumps({"errors":"Cannot retrieve apps list"})
except Exception, err:
logger.error('ERROR: ' + str(err))
def update_single_dyna(user, dynag):
dynag.servers.clear()
if dynag.engine == 'Facter':
response, content = callRestServer(user,
"compound=%s" % dynag.obj_name,
'rpcutil', 'ping', None, True,
False)
if response.getStatus() == 200:
for sresp in content:
if sresp.getStatusMessage() == 'OK':
logger.info("Rule match for %s" % sresp.getSender())
try:
server = Server.objects.get(hostname=sresp.getSender())
except:
try:
server = Server.objects.get(fqdn=sresp.getSender())
except:
logger.warn("Cannot find server %s in database" %
sresp.getSender())
continue
dynag.servers.add(server)
def sql_list(user, filters):
file_type = "sql"
logger.debug("Calling get_sql_list with filters %s and type %s" % (filters, str(file_type)))
try:
response, content = callRestServer(user, filters, "postgresql", "sql_list", None, False, False)
if response.getStatus() == 200:
if content:
#Looking for "intersections"
sql_list = None
for server_response in content:
if server_response.getStatusCode()==0 and server_response.getData():
if not sql_list:
sql_list = server_response.getData()['sqllist']
else:
sql_list = list(set(sql_list).intersection(server_response.getData()['sqllist']))
else:
logger.warn("No sqllist received")
return json.dumps({"errors":"", "sqllist":sql_list})
else:
return json.dumps({"errors":"Cannot retrieve sqls list"})
except Exception, err:
logger.error('ERROR: ' + str(err))
def sql_list(user, filters):
file_type = "sql"
logger.debug("Calling get_sql_list with filters %s and type %s" % (filters, str(file_type)))
try:
#Does not use celery for fast operations (with celery it's longer)
response, content = callRestServer(user, filters, "oracledb", "sql_list", None, False, False)
if response.getStatus() == 200:
if content:
#Looking for "intersections"
sql_list = None
for server_response in content:
if server_response.getStatusCode()==0 and server_response.getData():
if not sql_list:
sql_list = server_response.getData()['sqllist']
else:
sql_list = list(set(sql_list).intersection(server_response.getData()['sqllist']))
else:
logger.warn("No sqllist in server response")
return json.dumps({"errors":"", "sqllist":sql_list})
else:
return json.dumps({"errors":"Cannot retrieve sqls list"})
except Exception, err:
logger.error('ERROR: ' + str(err))
def get_server_details(request, hostname, instance_name, resource_name):
filter = "identity_filter=%s"%hostname
response, content = callRestServer(request.user, filter, "libvirt", "hvinfo")
if response.status == 200:
virtual = json.loads(content)[0]
domains = []
for dom in virtual['data']['inactive_domains']:
info = {'name': dom,
'active': False,
'start_url': reverse('call_mcollective_with_arguments', kwargs={'filters':filter, 'agent':"libvirt", 'action':"start", 'args':"domain=%s"%dom}),
'stop_url': reverse('call_mcollective_with_arguments', kwargs={'filters':filter, 'agent':"libvirt", 'action':"shutdown", 'args':"domain=%s"%dom})
}
domains.append(info)
for dom in virtual['data']['active_domains']:
info = {'name': dom,
'active': True,
'start_url': reverse('call_mcollective_with_arguments', kwargs={'filters':filter, 'agent':"libvirt", 'action':"start", 'args':"domain=%s"%dom}),
'stop_url': reverse('call_mcollective_with_arguments', kwargs={'filters':filter, 'agent':"libvirt", 'action':"shutdown", 'args':"domain=%s"%dom})
}
domains.append(info)
return render_to_response('platforms/virtualization/server.html', {"base_url": settings.BASE_URL, "static_url":settings.STATIC_URL, "hostname": hostname, 'filter': filter ,'virtual': virtual['data'], 'domains': domains}, context_instance=RequestContext(request))
else:
return render_to_response('platforms/virtualization/server.html', {"base_url": settings.BASE_URL, "static_url":settings.STATIC_URL, "hostname": hostname}, context_instance=RequestContext(request))
def update_all_puppet_classes(user):
try:
if settings.PUPPET_MASTER_SERVER_HOSTNAME:
filters = 'identity=%s' % settings.PUPPET_MASTER_SERVER_HOSTNAME
else:
logger.warn("You should specify your puppet master hostname in settings file to improve KermIT performances")
filters = None
resp, content = callRestServer(user, filters, 'puppetmaster', 'classlist', None, True, False)
if resp.getStatus() == 200:
i = 0
total_classes = 0
for response in content:
if not "classlist" in response.getData():
continue
total_classes = total_classes + len(response.getData()["classlist"])
logger.debug("Total classes found: %s" % total_classes)
for response in content:
if not "classlist" in response.getData():
continue
for current_class in response.getData()["classlist"]:
try:
PuppetClass.objects.get(name=current_class)
logger.debug("Class already present in KermIT database")
except:
logger.debug("Cannot find class with name %s" % current_class)
logger.info("Creating new class %s" % current_class)
PuppetClass.objects.create(name=current_class)
i = i + 1
update_all_puppet_classes.update_state(state="PROGRESS", meta={"current": i, "total": total_classes})
except Exception, err:
logger.error('ERROR: ' + str(err))
def get_log(request, filters, dialog_name, xhr=None):
if request.method == "POST":
logger.debug("Recreating form")
form = LogForm(request.POST)
#Check if the <xhr> var had something passed to it.
if xhr == "xhr":
#TODO: Try to use dynamic form validation
clean = form.is_valid()
rdict = {'bad': 'false', 'filters': filters}
try:
instancename = request.POST['instancename']
except:
instancename = None
if instancename:
logger.debug("Parameters check: OK.")
logger.debug(
"Calling MCollective to get log on %s filtered server" %
(filters))
response, content = callRestServer(
request.user, filters, 'jboss', 'get_log',
'instancename=%s' % (instancename), True)
if response.status == 200:
json_content = json.loads(content)
s_resps = []
for server_response in json_content:
if server_response['statuscode'] == 0:
s_resps.append({
"server":
server_response["sender"],
"logfile":
server_response["data"]["logfile"]
})
else:
s_resps.append({
"server":
server_response["sender"],
"message":
server_response["statusmsg"]
})
rdict.update({"result": s_resps})
else:
rdict.update({
"result": "KO",
"message": "Error communicating with server"
})
rdict.update({'dialog_name': dialog_name})
# And send it off.
else:
rdict.update({'bad': 'true'})
d = {}
# This was painful, but I can't find a better way to extract the error messages:
for e in form.errors.iteritems():
d.update({
e[0]: unicode(e[1])
}) # e[0] is the id, unicode(e[1]) is the error HTML.
# Bung all that into the dict
rdict.update({'errs': d})
# Make a json whatsit to send back.
return HttpResponse(json.dumps(rdict, ensure_ascii=False),
mimetype='application/javascript')
# It's a normal submit - non ajax.
else:
if form.is_valid():
# We don't accept non-ajax requests for the moment
return HttpResponseRedirect("/")
else:
# It's not post so make a new form
logger.warn("Cannot access this page using GET")
raise Http404
