Ejemplo n.º 1
0
    def read(self, request):

        api_obs = u"Exclusão de usuário"

        api_log_referencia_id = None
        api_log_action_nome = "delete"
        api_log_tipo_nome = "usuario"

        alog = Log.saveAlog(request)

        usuario_usuario = request.GET.get("usuario", None)

        if filter(lambda value: not value or value is None, [usuario_usuario]):
            return raiseError(alog, "param_missing", request, None, api_obs,
                              api_log_referencia_id, api_log_action_nome,
                              api_log_tipo_nome)
        else:
            pass

        try:
            usuario = Usuario.objects.get(usuario=usuario_usuario)
        except Exception, e:
            return raiseError(alog, "user_not_exist", request, e, api_obs,
                              api_log_referencia_id, api_log_action_nome,
                              api_log_tipo_nome)
Ejemplo n.º 2
0
    def read(self, request):

        api_obs = u"Edicao de usuário"

        api_log_referencia_id = None
        api_log_action_nome = "update"
        api_log_tipo_nome = "usuario"

        alog = Log.saveAlog(request)

        usuario_servidor = request.GET.get("servidor")
        usuario_label = request.GET.get("label")
        usuario_nome = request.GET.get("nome")
        usuario_usuario = request.GET.get("usuario")
        usuario_email = request.GET.get("email")
        usuario_senha = request.GET.get("senha")
        usuario_status = request.GET.get("status")

        #valida usuario_nome
        if filter(lambda value: not value or value is None, [usuario_nome]):
            return raiseError(alog, "param_missing", request, None, api_obs,
                              api_log_referencia_id, api_log_action_nome,
                              api_log_tipo_nome)
        else:
            pass

        try:
            usuario = Usuario.objects.get(nome=usuario_nome)
        except Exception, e:
            return raiseError(alog, "user_not_exist", request, e, api_obs,
                              api_log_referencia_id, api_log_action_nome,
                              api_log_tipo_nome)
Ejemplo n.º 3
0
    def read(self, request):
        api_obs = u"Listagem de Usuários"
        api_log_referencia_id = None
        api_log_action_nome = "listar"
        api_log_tipo_nome = "usuario"

        alog = Log.saveAlog(request)

        usuario_nome = request.GET.get('nome')
        usuario_usuario = request.GET.get('usuario')
        usuario_email = request.GET.get('email')

        #listar com parametros
        if usuario_nome or usuario_usuario or usuario_email:
            try:
                usuario = Usuario.objects.filter(
                    Q(nome=usuario_nome) | Q(usuario=usuario_usuario)
                    | Q(email=usuario_email))
                retorno = {
                    'nome': usuario[0].nome,
                    'label': usuario[0].label,
                    'email': usuario[0].email,
                    'senha': usuario[0].senha,
                    'tentativa': usuario[0].tentativa,
                    'servidor': usuario[0].servidor.label,
                    'status': usuario[0].status.label
                }
            except Exception, error:
                return raiseError(alog, "list_error", request, None, api_obs,
                                  api_log_referencia_id, api_log_action_nome,
                                  api_log_tipo_nome)
Ejemplo n.º 4
0
    def read(self, request):

        api_obs = u"Edição de Status"

        api_log_referencia_id = None
        api_log_action_nome = "update"
        api_log_tipo_nome = "status"

        alog = Log.saveAlog(request)

        status_nome = request.GET.get('nome', None)
        status_label = request.GET.get('label', None)

        if filter(lambda value: not value or value is None,
                  [status_nome, status_label]):
            return raiseError(alog, "param_missing", request, None, api_obs,
                              api_log_referencia_id, api_log_action_nome,
                              api_log_tipo_nome)
        else:
            pass

        try:
            status = Status.objects.get(nome=status_nome)
        except Exception, e:
            return raiseError(alog, "status_not_exist", request, e, api_obs,
                              api_log_referencia_id, api_log_action_nome,
                              api_log_tipo_nome)
Ejemplo n.º 5
0
    def read(self, request):
        api_obs = u"Exclusão de servidor"
        api_log_referencia_id = None
        api_log_action_nome = "delete"
        api_log_tipo_nome = "servidor"
        alog = Log.saveAlog(request)

        if filter(lambda value: not value or value is None, [servidor_nome]):
            return raiseError(alog, "param_missing", request, None, api_obs,
                              api_log_referencia_id, api_log_action_nome,
                              api_log_tipo_nome)
        else:
            pass

        retorno = {"Success": True}
        api_log_referencia_id = servidor.id
        Log.saveAlog(request, alog, retorno, api_obs, api_log_referencia_id,
                     api_log_action_nome, api_log_tipo_nome)
        return retorno
Ejemplo n.º 6
0
    def Add(self, request):
        api_obs = u"Inclusao de grupo de usuarios no Zabbix"
        api_log_referencia_id = None
        api_log_action_nome = "criar"
        api_log_tipo_nome = "zab"
        alog = Log.saveAlog(request)

        #buscando id do servidor
        try:
            servidor = Servidor.objects.get(nome=local.SERVER_ZABBIX_DEFAULT)
        except ObjectDoesNotExist:
            return raiseError(alog, "server_not_exist", request, None, api_obs,
                              api_log_referencia_id, api_log_action_nome,
                              api_log_tipo_nome)
        else:
            self.usuario_servidor = servidor.id

        # valores caso nao consiga incluir usuario no Zabbix
        error_transaction = None
        grupo_usuario_tentativa = 1
        status = Status.objects.get(label='INCLUIR')
        usrgrpids = 0

        # tentando incluir grupo de usuarios no Zabbix
        try:
            zab_usuario = local.SERVER_ZABBIX[servidor.nome]['usuario']
            zab_senha = local.SERVER_ZABBIX[servidor.nome]['senha']
            zab = Zabbix()
            zab.setHost(servidor.endereco)
            zab.setUser(zab_usuario)
            zab.setPassword(zab_senha)
            if zab.login() == True:
                create_resp = zab.createUserGroup(self.grupousuario_nome)
                if create_resp:
                    jresp = json.loads(create_resp)
                    usrgrpids = int(jresp['result']['usrgrpids'][0])
        except:
            retorno = {"Success": False, "Error": "ZabbixError"}
            return retorno

        #retornando da inclusao
        retorno = {
            "Success": True,
            "UserGroupIds": usrgrpids,
            "Nome": self.grupousuario_nome
        }
        return retorno
Ejemplo n.º 7
0
    def Add(self, request):
        api_obs = u"Inclusao de action no Zabbix"
        api_log_referencia_id = None
        api_log_action_nome = "criar"
        api_log_tipo_nome = "zab"
        alog = Log.saveAlog(request)

        #buscando id do servidor
        try:
            servidor   = Servidor.objects.get(nome=local.SERVER_ZABBIX_DEFAULT)
        except  ObjectDoesNotExist:
            return raiseError(alog,"server_not_exist",request,None,api_obs,api_log_referencia_id,api_log_action_nome,api_log_tipo_nome) 
        else:
            self.usuario_servidor = servidor.id

        #buscando id do host
        try:
            host    = Host.objects.get(nome=self.nome)
        except  ObjectDoesNotExist:
            return raiseError(alog,"host_not_exist",request,None,api_obs,api_log_referencia_id,api_log_action_nome,api_log_tipo_nome) 
        else:
            host_id  = host.id

        # valores caso nao consiga incluir action no Zabbix
        error_transaction = None
        self.tentativa = 1
        status   = Status.objects.get(label='INCLUIR')
        actionids = 0

        # tentando incluir action no Zabbix
        try:
            zab_usuario    = local.SERVER_ZABBIX[servidor.nome]['usuario']
            zab_senha       = local.SERVER_ZABBIX[servidor.nome]['senha']
            zab = Zabbix()
            zab.setHost(servidor.endereco)
            zab.setUser(zab_usuario)
            zab.setPassword(zab_senha)
            if zab.login() == True:
                create_resp = zab.createPingAction( self.nome, int(self.user_group_id), int(self.host_group_id))
                if  create_resp:
                    jresp = json.loads(create_resp)
                    actionids = int(jresp['result']['actionids'][0])
                    status   = Status.objects.get(label='ATIVO')
                    self.tentativa = 0
        except Exception, error:
            return False
Ejemplo n.º 8
0
    def Add(self, request):
        api_obs = u"Inclusao de grupo de hosts no Zabbix"
        api_log_referencia_id = None
        api_log_action_nome = "criar"
        api_log_tipo_nome = "zab"
        alog = Log.saveAlog(request)

        #buscando id do servidor
        try:
            servidor = Servidor.objects.get(nome=self.grupohost_servidor)
        except ObjectDoesNotExist:
            return raiseError(alog, "server_not_exist", request, None, api_obs,
                              api_log_referencia_id, api_log_action_nome,
                              api_log_tipo_nome)
        else:
            servidor_id = servidor.id

        # valores caso nao consiga incluir host no Zabbix
        error_transaction = None
        grupo_host_tentativa = 1
        status = Status.objects.get(label='INCLUIR')
        hostgrpids = 0

        # tentando incluir grupo de hosts no Zabbix
        try:
            zab_usuario = local.SERVER_ZABBIX[servidor.nome]['usuario']
            zab_senha = local.SERVER_ZABBIX[servidor.nome]['senha']
            zab = Zabbix()
            zab.setHost(servidor.endereco)
            zab.setUser(zab_usuario)
            zab.setPassword(zab_senha)
            if zab.login() == True:
                create_resp = zab.createHostGroup(self.grupohost_nome)
                if create_resp:
                    jresp = json.loads(create_resp)
                    hostgrpids = int(jresp['result']['groupids'][0])
        except Exception, error:
            return str(error)
Ejemplo n.º 9
0
    def read(self, request):

        api_obs = u"Listagem de Status"
        api_log_referencia_id = None
        api_log_action_nome = "listar"
        api_log_tipo_nome = "status"
        alog = Log.saveAlog(request)

        status_label = request.GET.get('label')

        if not status_nome:
            try:
                retorno = []
                for item in Status.objects.all():
                    val = {}
                    val['nome'] = item.nome
                    val['label'] = item.label
                    val['data_criacao'] = item.data_criacao
                    retorno.append(val)
            except Exception, error:
                return raiseError(alog, "list_error", request, None, api_obs,
                                  api_log_referencia_id, api_log_action_nome,
                                  api_log_tipo_nome)
Ejemplo n.º 10
0
    def read(self, request):

        api_obs = u"Adição de Status"
        api_log_referencia_id = None
        api_log_action_nome = "criar"
        api_log_tipo_nome = "status"

        alog = Log.saveAlog(request)

        status_label = request.GET.get('label', None)

        if filter(lambda value: not value or value is None, [status_label]):
            return raiseError(alog, "param_missing", request, None, api_obs,
                              api_log_referencia_id, api_log_action_nome,
                              api_log_tipo_nome)
        else:
            pass

        NAME_LENGTH = 10
        NAME_CHARS = "abcdefghjkmnpqrstuvwxyz23456789"
        nome_hash = User.objects.make_random_password(length=NAME_LENGTH,
                                                      allowed_chars=NAME_CHARS)

        error_transaction = None

        with transaction.commit_manually():
            try:
                status = Status(nome=status_nome,
                                label=status_label,
                                data_criacao=datetime.datetime.now())
                status.save()

            except Exception, error:
                error_transaction = error
                transaction.rollback()

            else:
Ejemplo n.º 11
0
    def read(self, request):
        api_obs = u"Inclusao de icmpping no Zabbix"
        api_log_referencia_id = None
        api_log_action_nome = "criar"
        api_log_tipo_nome = "zab"

        alog = Log.saveAlog(request)

        NAME_LENGTH = 10
        NAME_CHARS = "abcdefghjkmnpqrstuvwxyz23456789"
        nome_hash = User.objects.make_random_password(length=NAME_LENGTH,
                                                      allowed_chars=NAME_CHARS)

        #recebendo parametros
        nome = str(nome_hash)
        endereco = request.GET.get('endereco', None)
        contrato = request.GET.get('contrato', None)
        email = request.GET.get('email', None)

        #verificando parametros
        if filter(lambda value: not value or value is None,
                  [nome, endereco, contrato, email]):
            return raiseError(alog, "param_missing", request, None, api_obs,
                              api_log_referencia_id, api_log_action_nome,
                              api_log_tipo_nome)
        else:
            pass

        #validação das entradas de dados
        oUtils = ZabbixUtils()
        if oUtils.validarEmail(email) == False:
            return raiseError(alog, "invalid_email", request, None, api_obs,
                              api_log_referencia_id, api_log_action_nome,
                              api_log_tipo_nome)

        if oUtils.validarIP(endereco) == False:
            return raiseError(alog, "invalid_ip", request, None, api_obs,
                              api_log_referencia_id, api_log_action_nome,
                              api_log_tipo_nome)

        if oUtils.validarContrato(contrato) == False:
            return raiseError(alog, "invalid_contract", request, None, api_obs,
                              api_log_referencia_id, api_log_action_nome,
                              api_log_tipo_nome)

        #grupo de usuarios
        oGrupoUsuario = ZabbixGrupoUsuario(nome)
        dGrupoUsuario = oGrupoUsuario.Add(request)
        try:
            if dGrupoUsuario.get('Success', False) != True:
                if dGrupoUsuario.get('Error', False) == 'ZabbixError':
                    return raiseError(alog, "create_group_user_fail", request,
                                      None, api_obs, api_log_referencia_id,
                                      api_log_action_nome, api_log_tipo_nome)
                else:
                    return str(dGrupoUsuario)
            else:
                GrupoNome = dGrupoUsuario.get('Nome', False)
                UserGroupIds = dGrupoUsuario.get('UserGroupIds', False)
        except:
            return raiseError(alog, "create_group_user_fail", request, None,
                              api_obs, api_log_referencia_id,
                              api_log_action_nome, api_log_tipo_nome)

        #usuario
        oUsuario = ZabbixUsuario(nome, endereco, contrato, email, UserGroupIds)
        dUsuario = oUsuario.Add(request)
        try:
            if dUsuario.get('Success', False) != True:
                return str(dUsuario)
            else:
                Nome = dUsuario.get('Nome', False)
                Userids = dUsuario.get('Userids', False)
                Label = dUsuario.get('Label', False)
                Endereco = dUsuario.get('Endereco', False)
                Usuario = dUsuario.get('Usuario', False)
                Email = dUsuario.get('Email', False)
                Senha = dUsuario.get('Senha', False)
                Servidor = dUsuario.get('Servidor', False)
        except:
            return raiseError(alog, "create_user_fail", request, None, api_obs,
                              api_log_referencia_id, api_log_action_nome,
                              api_log_tipo_nome)

        #grupo de hosts
        oGrupoHost = ZabbixGrupoHost(nome, Servidor)
        dGrupoHost = oGrupoHost.Add(request)
        try:
            if dGrupoHost.get('Success', False) != True:
                return str(dGrupoHost)
            else:
                HostGrupoNome = str(dGrupoHost['Nome'])
                HostGroupIds = str(dGrupoHost['HostGroupIds'])
        except:
            return raiseError(alog, "create_group_host_fail", request, None,
                              api_obs, api_log_referencia_id,
                              api_log_action_nome, api_log_tipo_nome)

        #host
        oHost = ZabbixHost(Nome, Usuario, Email, Label, Endereco, HostGroupIds,
                           'IP', '0')
        dHost = oHost.Add(request)
        if dHost.get('Success', False) != True:
            return str(dHost)
            #return raiseError(alog,"create_host_fail",request,None,api_obs,api_log_referencia_id,api_log_action_nome,api_log_tipo_nome)
        else:
            Nome = str(dHost['Nome'])
            Endereco = str(dHost['Endereco'])
            Hostids = dHost['Hostids']

        #item
        oItem = ZabbixItem(Nome, Endereco, Hostids)
        dItem = oItem.Add(request)
        if dItem.get('Success', False) != True:
            return str(dItem)
            #return raiseError(alog,"create_item_fail",request,None,api_obs,api_log_referencia_id,api_log_action_nome,api_log_tipo_nome)
        else:
            Nome = str(dItem['Nome'])
            Endereco = str(dItem['Endereco'])
            Itemids = dItem['Itemids']

        #Trigger
        oTrigger = ZabbixTrigger(Nome, Endereco, str(Hostids))
        dTrigger = oTrigger.Add(request)
        if dTrigger.get('Success', False) != True:
            return str(dTrigger)
            #return raiseError(alog,"create_trigger_fail",request,None,api_obs,api_log_referencia_id,api_log_action_nome,api_log_tipo_nome)
        else:
            Triggerids = dTrigger['Triggerids']

        #MassAdd
        oMassAdd = ZabbixMassAdd(UserGroupIds, HostGroupIds)
        dMassAdd = oMassAdd.Add(request)
        if dMassAdd.get('Success', False) != True:
            return str(dMassAdd)
            #return raiseError(alog,"create_group_user_fail",request,None,api_obs,api_log_referencia_id,api_log_action_nome,api_log_tipo_nome)
        else:
            MassAddIds = dMassAdd['UserGroupIds']

        #Action
        oAction = ZabbixAction(Nome, UserGroupIds, HostGroupIds)
        dAction = oAction.Add(request)
        if dAction.get('Success', False) != True:
            return str(dAction)
            #return raiseError(alog,"create_group_user_fail",request,None,api_obs,api_log_referencia_id,api_log_action_nome,api_log_tipo_nome)
        else:
            ActionIds = dAction['Actionids']
            retorno = {
                'Success': True,
                'Email': Email,
                'Nome': Nome,
                'Senha': Senha,
                'Userids': Userids,
                'UserGroupIds': UserGroupIds,
                'Hostids': Hostids,
                'HostGroupIds': HostGroupIds,
                'Itemids': Itemids,
                'Triggerids': Triggerids,
                'MassAddIds': MassAddIds,
                'ActionIds': ActionIds
            }
            return retorno
Ejemplo n.º 12
0
    def read(self, request):

        api_obs = u"Adição de usuário"
        api_log_referencia_id = None
        api_log_action_nome = "criar"
        api_log_tipo_nome = "usuario"

        alog = Log.saveAlog(request)

        #gerando nome
        NAME_LENGTH = 10
        NAME_CHARS = "abcdefghjkmnpqrstuvwxyz23456789"
        nome_hash = User.objects.make_random_password(length=NAME_LENGTH,
                                                      allowed_chars=NAME_CHARS)

        usuario_nome = str(nome_hash)
        usuario_contrato = request.GET.get("contrato")
        usuario_usuario = request.GET.get("usuario")
        usuario_label = request.GET.get("label")
        usuario_servidor = request.GET.get("servidor")
        usuario_email = request.GET.get("email")
        usuario_senha = request.GET.get("senha")

        #validando parametros
        if filter(lambda value: not value or value is None, [
                usuario_label, usuario_usuario, usuario_email, usuario_senha,
                usuario_contrato, usuario_servidor
        ]):
            return raiseError(alog, "param_missing", request, None, api_obs,
                              api_log_referencia_id, api_log_action_nome,
                              api_log_tipo_nome)

        #buscando id do servidor
        try:
            servidor = Servidor.objects.get(nome=usuario_servidor)
        except ObjectDoesNotExist:
            return raiseError(alog, "server_not_exist", request, None, api_obs,
                              api_log_referencia_id, api_log_action_nome,
                              api_log_tipo_nome)
        else:
            usuario_servidor = servidor.id

        usuario = Usuario.objects.filter(usuario=usuario_usuario)
        email = Usuario.objects.filter(email=usuario_email)

        #verificando se usuario ou e-mail existem
        if usuario:
            return raiseError(alog, "user_exist", request, None, api_obs,
                              api_log_referencia_id, api_log_action_nome,
                              api_log_tipo_nome)
        elif email:
            return raiseError(alog, "email_exist", request, None, api_obs,
                              api_log_referencia_id, api_log_action_nome,
                              api_log_tipo_nome)
        error_transaction = None

        # valores caso nao consiga incluir no Zabbix
        usuario_tentativa = 1
        status = Status.objects.get(label='INCLUIR')
        userids = 0

        # tentando incluir no Zabbix
        try:
            zab_usuario = local.SERVER_ZABBIX[servidor.nome]['usuario']
            zab_senha = local.SERVER_ZABBIX[servidor.nome]['senha']
            zab = Zabbix()
            zab.setHost(servidor.endereco)
            zab.setUser(zab_usuario)
            zab.setPassword(zab_senha)
            if zab.login() == True:
                create_resp = zab.createUser(usuario_email, usuario_senha,
                                             local.ZABBIX_USRGRPID)
                if create_resp:
                    jresp = json.loads(create_resp)
                    userids = int(jresp['result']['userids'][0])
                    status = Status.objects.get(label='ATIVO')
                    usuario_tentativa = 0
        except:
            pass

        #incluindo
        with transaction.commit_manually():
            try:
                usuario = Usuario(nome=usuario_nome,
                                  usuario=usuario_usuario,
                                  label=usuario_label,
                                  servidor=servidor,
                                  email=usuario_email,
                                  zabbix_id=userids,
                                  senha=usuario_senha,
                                  contrato=usuario_contrato,
                                  tentativa=usuario_tentativa,
                                  status=status,
                                  data_criacao=datetime.datetime.now())
                usuario.save()

            except Exception, error:
                error_transaction = error
                transaction.rollback()

            else:
Ejemplo n.º 13
0
                transaction.rollback()

            else:
                transaction.commit()

        if error_transaction:
            return raiseError(alog, "error_in_transaction", request,
                              error_transaction, api_obs,
                              api_log_referencia_id, api_log_action_nome,
                              api_log_tipo_nome)

        retorno = {"Success": True}

        api_log_referencia_id = usuario.id

        Log.saveAlog(request, alog, retorno, api_obs, api_log_referencia_id,
                     api_log_action_nome, api_log_tipo_nome)
        return retorno

    def create(self, request):
        pass


class Update(BaseHandler):
    allowed_methods = ("GET", )

    def read(self, request):

        api_obs = u"Edicao de usuário"

        api_log_referencia_id = None
        api_log_action_nome = "update"
Ejemplo n.º 14
0
    def Add(self, request):
        api_obs = u"Inclusao de usuario no Zabbix"
        api_log_referencia_id = None
        api_log_action_nome = "criar"
        api_log_tipo_nome = "zab"
        alog = Log.saveAlog(request)

        #buscando id do servidor
        try:
            servidor   = Servidor.objects.get(nome=local.SERVER_ZABBIX_DEFAULT)
        except  ObjectDoesNotExist:
            return raiseError(alog,"server_not_exist",request,None,api_obs,api_log_referencia_id,api_log_action_nome,api_log_tipo_nome) 
        else:
            self.usuario_servidor = servidor.id
        usuario = Usuario.objects.filter(usuario=self.usuario_usuario)
        email   = Usuario.objects.filter(email=self.usuario_email)

        #verificando se usuario ou e-mail existem
        if usuario:
            return raiseError(alog,"user_exist",request,None,api_obs,api_log_referencia_id,api_log_action_nome,api_log_tipo_nome)
        elif email:
            return raiseError(alog,"email_exist",request,None,api_obs,api_log_referencia_id,api_log_action_nome,api_log_tipo_nome)
        error_transaction = None

        # valores caso nao consiga incluir usuario no Zabbix
        usuario_tentativa = 1
        status   = Status.objects.get(label='INCLUIR')
        userids = 0

        # tentando incluir usuario no Zabbix
        try:
            zab_usuario    = local.SERVER_ZABBIX[servidor.nome]['usuario']
            zab_senha       = local.SERVER_ZABBIX[servidor.nome]['senha']
            zab = Zabbix()
            zab.setHost(servidor.endereco)
            zab.setUser(zab_usuario)
            zab.setPassword(zab_senha)
            if zab.login() == True:
                create_resp = zab.createUser(self.usuario_nome, self.usuario_senha, self.usuario_grupo_id)
                if create_resp :
                    jresp = json.loads(create_resp)
                    userids = int(jresp['result']['userids'][0])
                    status   = Status.objects.get(label='ATIVO')
                    zab.createMedia(userids, self.usuario_email)
                    usuario_tentativa = 0
        except:
            pass

        #incluindo usuario no mysql
        with transaction.commit_manually():
            try:
                usuario = Usuario(
                    nome=self.usuario_nome,
                    usuario=self.usuario_usuario,
                    label=self.usuario_label,
                    servidor =servidor,
                    email=self.usuario_email,
                    zabbix_id=userids,
                    zabbix_grupo_id=self.usuario_grupo_id,
                    contrato=self.usuario_contrato,
                    tentativa=usuario_tentativa,
                    status =status, 
                    data_criacao=datetime.datetime.now())
                usuario.save()
            except Exception,error:
                error_transaction = error
                transaction.rollback()
            else:
Ejemplo n.º 15
0
    def Add(self, request):
        api_obs = u"Inclusao de host no Zabbix"
        api_log_referencia_id = None
        api_log_action_nome = "criar"
        api_log_tipo_nome = "zab"
        alog = Log.saveAlog(request)

        #buscando id do servidor
        try:
            servidor   = Servidor.objects.get(nome=local.SERVER_ZABBIX_DEFAULT)
        except  ObjectDoesNotExist:
            return raiseError(alog,"server_not_exist",request,None,api_obs,api_log_referencia_id,api_log_action_nome,api_log_tipo_nome) 
        else:
            self.usuario_servidor = servidor.id

        usuario = Usuario.objects.filter(usuario=self.usuario)
        email   = Usuario.objects.filter(email=self.email)

        #incluindo host, buscando id do usuario
        try:
            usuario   = Usuario.objects.get(nome=self.nome)
        except  ObjectDoesNotExist:
            return raiseError(alog,"user_not_exist",request,None,api_obs,api_log_referencia_id,api_log_action_nome,api_log_tipo_nome) 
        else:
            host_usuario  = usuario.id
            usuario_servidor = usuario.servidor_id
            host_servidor_endereco = servidor.endereco
         
        #verificando porta e endereço iguais
        endereco    = Host.objects.filter(endereco=self.endereco)
        porta           = Host.objects.filter(porta=self.porta)
        if endereco and porta:
            return raiseError(alog,"host_same_address_port",request,None,api_obs,api_log_referencia_id,api_log_action_nome,api_log_tipo_nome)
        else:
            pass
       
        # valores caso nao consiga incluir no Zabbix
        error_transaction = None
        self.tentativa = 1
        status   = Status.objects.get(label='INCLUIR')
        hostids = 0

        # tentando incluir host no Zabbix
        try:
            zab_usuario    = local.SERVER_ZABBIX[servidor.nome]['usuario']
            zab_senha       = local.SERVER_ZABBIX[servidor.nome]['senha']
            zab = Zabbix()
            zab.setHost(servidor.endereco)
            zab.setUser(zab_usuario)
            zab.setPassword(zab_senha)

            if zab.login() == True:
                useip = 1
                dns = ''
                interfaces =   { 
                    "type":  1, 
                    "main":  1, 
                    "useip":  useip, 
                    "ip":  self.endereco, 
                    "dns":  dns, 
                    "port":  self.porta
                }
                groups = {
                    "groupid" :  self.grupo_id
                }
                create_resp = zab.createHost(self.nome, interfaces, groups)
                if create_resp :
                    jresp = json.loads(create_resp)
                    hostids = int(jresp['hostids'][0])
                    status   = Status.objects.get(label='ATIVO')
                    self.tentativa = 0
        except Exception, error:
            pass
Ejemplo n.º 16
0
    def Add(self, request):
        api_obs = u"Inclusao de item no Zabbix"
        api_log_referencia_id = None
        api_log_action_nome = "criar"
        api_log_tipo_nome = "zab"
        alog = Log.saveAlog(request)

        #buscando id do servidor
        try:
            servidor = Servidor.objects.get(nome=local.SERVER_ZABBIX_DEFAULT)
        except ObjectDoesNotExist:
            return raiseError(alog, "server_not_exist", request, None, api_obs,
                              api_log_referencia_id, api_log_action_nome,
                              api_log_tipo_nome)
        else:
            self.usuario_servidor = servidor.id

        try:
            host = Host.objects.get(nome=self.nome)
        except ObjectDoesNotExist:
            return raiseError(alog, "host_not_exist", request, None, api_obs,
                              api_log_referencia_id, api_log_action_nome,
                              api_log_tipo_nome)
        else:
            host_id = host.id

        # valores caso nao consiga incluir item no Zabbix
        error_transaction = None
        self.tentativa = 1
        status = Status.objects.get(label='INCLUIR')
        itemids = 0

        # tentando incluir item no Zabbix
        try:
            zab_usuario = local.SERVER_ZABBIX[servidor.nome]['usuario']
            zab_senha = local.SERVER_ZABBIX[servidor.nome]['senha']
            zab = Zabbix()
            zab.setHost(servidor.endereco)
            zab.setUser(zab_usuario)
            zab.setPassword(zab_senha)

            if zab.login() == True:
                interfaceIds = zab.getHostInterface(self.hostids)
                for a in interfaceIds:
                    if str(a['hostid'] == self.hostids):
                        interface_id = a['interfaceid']

                create_resp = zab.createPingItem(self.label, int(self.hostids),
                                                 int(interface_id))
                if create_resp:
                    jresp = json.loads(create_resp)
                    itemids = int(jresp['itemids'][0])
                    status = Status.objects.get(label='ATIVO')
                    self.tentativa = 0
        except:
            pass

        #incluindo item no mysql
        with transaction.commit_manually():
            try:
                item = Item(nome=self.nome,
                            label=self.label,
                            tentativa=self.tentativa,
                            status=status,
                            host=host,
                            zabbix_id=itemids,
                            data_criacao=datetime.datetime.now())
                item.save()
            except Exception, error:
                error_transaction = error
                transaction.rollback()
            else: