Пример #1
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
Пример #2
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
Пример #3
0
    def incluirUsuario():
        api_obs = u"Incluir Usuario"
        api_log_referencia_id = None
        api_log_action_nome = "add"
        api_log_tipo_nome = "script"
        alog = "script"

        usuario = Usuario.objects.filter(status__label='incluir')
        status = Status.objects.get(label='ativo')
        if status:
            usuario_status = status.id

        for aUsuario in usuario:
            servidor = aUsuario.servidor.nome
            email = aUsuario.email
            senha = aUsuario.senha
            userids = 0
            zab_endereco = aUsuario.servidor.endereco
            zab_usuario = local.SERVER_ZABBIX[servidor]['usuario']
            zab_senha = local.SERVER_ZABBIX[servidor]['senha']
            zab = Zabbix()
            zab.setHost(zab_endereco)
            zab.setUser(zab_usuario)
            zab.setPassword(zab_senha)
            if zab.login() == True:
                create_resp = zab.createUser(email, senha,
                                             local.ZABBIX_USRGRPID)
                if create_resp:
                    jresp = json.loads(create_resp)
                    userids = int(jresp['result']['userids'][0])

            with transaction.commit_manually():
                try:
                    if userids != 0:
                        print '1'
                        usuario.status = usuario_status
                        usuario.zabbix_id = userids
                    else:
                        print '0'
                        usuario.tentativa = usuario.tentativa + 1
                    usuario.save()
                except:
                    pass

        return True
Пример #4
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)
Пример #5
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:
Пример #6
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:
Пример #7
0
#!/usr/bin/env python
import os
import sys, traceback, json
import logging, logging.handlers
from daemon import runner
import time
import datetime
import requests

homeDir = os.getenv("HOME")
project_path = os.path.join(homeDir, 'azabbix/azabbix')
sys.path.append(project_path)

os.environ.setdefault("DJANGO_SETTINGS_MODULE", "settings")
from api.models import *
from api.zabbix import Zabbix
import local

zab = Zabbix()
zab.setHost("https://localhost/zabbix")
zab.setUser("Admin_user")
zab.setPassword("Admin_password")
if zab.login() == True:
    create_resp = zab.createUser("zezinho", "teste", local.ZABBIX_USRGRPID)
    if create_resp:
        jresp = json.loads(create_resp)
        userids = int(jresp['result']['userids'][0])
        print userids
    else:
        print create_resp
Пример #8
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
Пример #9
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: