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 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 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 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 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_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 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 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 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 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 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 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 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 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 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()