Ejemplo n.º 1
0
class ZenSNPP(IZen, Client):

	server = None

	log = None

	def __init__(self):
		self.conf = ConfUtil.zen(__file__)

		daemon = Util.filename(__file__)

		self.log = Log(daemon)

		Client.__init__(self, daemon, self.log)

		self.server = Server(
			self.conf['snpp']['host'],
			self.conf['snpp']['port']
		)

	def get(self):
		boxes = []

		for box in sorted(self.conf['boxes']):
			url = 'http://%s:81/gsm1.html' % self.conf['boxes'][box]

			try:
				response = urlopen(url, timeout=self.conf['timeout'])

				if response.getcode() != 200:
					continue
			except URLError:
				continue

			html = response.read()

			if 'ERROR' in html:
				continue

			info = html.split()

			_, _, _, _, _, _, _, signal, _ = info

			signal = signal.replace(',', '.')
			signal = float(signal)
			signal = int(signal)

			if signal < 2 or signal == 99:
				continue

			boxes.append(box)

		if len(boxes) == 0:
			raise MyException

		return boxes

	def post(self, box, to, data):
		to = ';'.join(map(str, to))

		url = 'http://%s/source/send_sms.php' % self.conf['boxes'][box]

		data = {
			'username'	: 'admin',
			'pwd'		: 'zenoss',
			'from'		: 'Zenoss',
			'nphone'	: to,
			'outCh'		: 'GSM1',
			'testo'		: data
		}

		data = urlencode(data)

		request = Request(url, data)

		try:
			response = urlopen(request, timeout=self.conf['timeout'])

			if response.getcode() != 200:
				raise MyException
		except URLError:
			raise MyException

	def sms(self, host, allow, packet):
		i = isinstance(packet['to'], int)

		targets = [packet['to']] if i else packet['to']['phones']

		if not allow:
			debug = DebugUtil.sms(host, targets, packet['data'])

			self.log.info('Message dropped %s' % debug)

			return

		try:
			boxes = self.get()

			if all(d not in packet['data'] for d in self.conf['devices']):
				boxes = [boxes.pop(0)]

			for box in boxes:
				self.post(box, targets, packet['data'])

				smsfrom = {
					'host'	: host,
					'box'	: box
				}

				debug = DebugUtil.sms(smsfrom, targets, packet['data'])

				self.log.info('Message sent %s' % debug)
		except MyException:
			if i:
				self.log.critical('Test message not sent')

				return

			mail = DictUtil.copy(self.conf['mail'])

			mail['to'] = packet['to']['mails']
			mail['body'] = packet['data']

			debug = DebugUtil.mail(host, mail)

			if Mail.sendraw(mail):
				self.log.info('Mail sent %s' % debug)
			else:
				self.log.critical('Mail not sent %s' % debug)

	def run(self):
		try:
			self.log.clear()

			while True:
				read = self.server.select()

				for socket in read:
					if self.server.accept(socket):
						try:
							client, ip, packet = self.server.recv()

							client = ClientProxy(client)

							self.server.attach(client)

							host = Util.hostname(ip)

							d = {'host': host}

							self.send(d)

							pkt = self.recv()

							self.sms(host, pkt['allow'], packet)
						except MyException:
							pass
					else:
						client = ClientProxy(socket)

						self.server.dettach(client)
		except KeyboardInterrupt:
			pass
Ejemplo n.º 2
0
class ZenStatus(IZen, Client):

	down = []

	hosts = {}

	log = None

	def __init__(self):
		zen = ConfUtil.zen()

		conf = ConfUtil.zen(__file__)

		conf['localhost'] = zen['localhost']

		self.conf = conf

		daemon = Util.filename(__file__)

		self.log = Log(daemon)

		Client.__init__(self, daemon, self.log)

	def mail(self, host, success):
		status = 'up' if success else 'down'

		mail = DictUtil.copy(self.conf['mail'])

		mail['subject'] %= status.upper()
		mail['body'] %= host

		debug = DebugUtil.mail(self.conf['localhost']['name'], mail)

		if Mail.sendraw(mail):
			self.log.info('Mail sent %s' % debug)
		else:
			self.log.critical('Mail not sent %s' % debug)

	def start(self, ip):
		up = False

		host = Util.hostname(ip)

		for _ in range(self.conf['start']['retries']):
			if 'backup' in self.hosts[host] and self.hosts[host]['backup']:
				up = True

				break

			cmd = ['ssh', ip, 'service', 'serviced', 'start']

			check_call(cmd, stderr=PIPE)

			cmd = ['ssh', ip, 'service', 'serviced', 'status']

			output = check_output(cmd, stderr=PIPE)

			if 'running' not in output:
				sleep(self.conf['start']['timeout'])

				continue

			cmd = ['ssh', ip, 'serviced', 'service', 'start', 'Zenoss.core']

			output = check_output(cmd)

			if 'started' not in output:
				sleep(self.conf['start']['timeout'])

				continue

			up = True

			break

		if host in self.down:
			if up:
				self.mail(host, True)

				self.down.remove(host)
		else:
			if not up:
				self.mail(host, False)

				self.down.append(host)

		return up

	def status(self):
		_hosts = self.hosts.keys()

		hosts = {h: {} for h in _hosts}

		for host in sorted(_hosts):
			if not self.hosts[host]['ping']:
				hosts[host]['status'] = False

				self.log.error(host)

				continue

			if self.start(self.hosts[host]['ip']):
				hosts[host]['status'] = True

				self.log.success(host)
			else:
				hosts[host]['status'] = False

				self.log.error(host)

		d = {'hosts': hosts}

		self.send(d)

	def run(self):
		try:
			worker = None

			self.log.clear()

			while True:
				packet = self.recv()

				self.hosts = packet['hosts']

				if worker is not None and worker.is_alive():
					continue

				self.log.clear()

				worker = Thread(target=self.status)

				worker.start()
		except KeyboardInterrupt:
			pass
Ejemplo n.º 3
0
class ZenTrap(IZen, Client):

	hosts = {}

	queue = []

	log = None

	udp = None

	@staticmethod
	def mac(ip):
		try:
			arp = sep + path.join('proc', 'net', 'arp')

			cmd = ['grep', ip, arp]

			fields = check_output(cmd).split()

			if len(fields) != 6:
				raise MacException

			_, _, _, mac, _, _ = fields

			if mac == '00:00:00:00:00:00':
				raise MacException

			return mac
		except CalledProcessError:
			raise MacException

	def __init__(self):
		self.conf = ConfUtil.zen(__file__)

		daemon = Util.filename(__file__)

		self.log = Log(daemon)

		Client.__init__(self, daemon, self.log)

	def loop(self):
		while True:
			try:
				packet = self.udp.recv()

				if packet['dst_port'] != self.conf['port']:
					continue

				self.queue.append(packet)
			except UdpException:
				pass

	def run(self):
		try:
			self.log.clear()

			packet = self.recv()

			self.hosts, self.udp = packet['hosts'], UDP()

			Thread(target=self.loop).start()

			while True:
				if len(self.queue) == 0:
					continue

				packet, targets = self.queue.pop(0), []

				for host in sorted(self.hosts):
					d = {'host': host}

					self.send(d)

					_packet = self.recv()

					if not _packet['allow']:
						continue

					if 'mac' not in self.hosts[host]:
						try:
							mac = ZenTrap.mac(self.hosts[host]['ip'])

							self.hosts[host]['mac'] = mac
						except MacException:
							continue

					packet['dst_mac'] = self.hosts[host]['mac']
					packet['dst_ip'] = self.hosts[host]['ip']

					self.udp.send(packet)

					targets.append(host)

				if len(targets) == 0:
					self.log.info('Trap dropped')
				else:
					to = ', '.join(map(Util.repr, targets))

					if len(targets) > 1:
						to = '(%s)' % to

					self.log.info('Trap sent (%s: %s)' % (Util.repr('To'), to))
		except KeyboardInterrupt:
			pass
Ejemplo n.º 4
0
class ZenSMTP(IZen, Client):

	log = None

	def __init__(self):
		self.conf = ConfUtil.zen(__file__)

		daemon = Util.filename(__file__)

		self.log = Log(daemon)

		Client.__init__(self, daemon, self.log)

	def process_message(self, peer, mailfrom, rcpttos, data):
		ip, _ = peer

		host = Util.hostname(ip)

		fr = '(%s, %s)' % (Util.repr(host), Util.repr(mailfrom))

		fr = '%s: %s' % (Util.repr('From'), fr)

		to = ', '.join(map(Util.repr, rcpttos))

		if len(rcpttos) > 1:
			to = '(%s)' % to

		to = '%s: %s' % (Util.repr('To'), to)

		msg = message_from_string(data)

		subject = Util.repr(msg['Subject'])

		subject = '%s: %s' % (Util.repr('Subject'), subject)

		debug = '(%s, %s, %s)' % (fr, to, subject)

		d = {'host': host}

		self.send(d)

		packet = self.recv()

		if packet['allow']:
			if Mail.send(mailfrom, rcpttos, data):
				self.log.info('Mail sent %s' % debug)
			else:
				self.log.critical('Mail not sent %s' % debug)
		else:
			self.log.info('Mail dropped %s' % debug)

	def run(self):
		try:
			self.log.clear()

			server = SMTPServer(
				(self.conf['smtp']['host'], self.conf['smtp']['port']),
				None
			)

			server.process_message = self.process_message

			loop()
		except KeyboardInterrupt:
			pass
Ejemplo n.º 5
0
class ZenPing(IZen, Client):

	hosts = {}

	mails = {
		'up'	: [],
		'down'	: []
	}

	down = []

	log = None

	@staticmethod
	def ping(ip):
		try:
			cmd = ['ping', '-c', '1', '-w', '1', '-q', ip]

			output = check_output(cmd)

			return ' 0% packet loss' in output
		except CalledProcessError:
			return False

	def __init__(self):
		zen = ConfUtil.zen()

		conf = ConfUtil.zen(__file__)

		conf['localhost'] = zen['localhost']

		self.conf = conf

		daemon = Util.filename(__file__)

		self.log = Log(daemon)

		Client.__init__(self, daemon, self.log)

	def mail(self, up):
		status = 'up' if up else 'down'

		mail = DictUtil.copy(self.conf['mail'])

		mail['subject'] %= status.upper()

		body = self.mails[status].pop()

		if len(self.mails[status]) > 0:
			hosts = ', '.join(self.mails[status])

			body = '%s & %s' % (hosts, body)

		mail['body'] %= body

		debug = DebugUtil.mail(self.conf['localhost']['name'], mail)

		if Mail.sendraw(mail):
			self.log.info('Mail sent %s' % debug)
		else:
			self.log.critical('Mail not sent %s' % debug)

	def run(self):
		try:
			self.log.clear()

			packet = self.recv()

			self.hosts = packet['hosts']

			hosts = {h: {} for h in self.hosts.keys()}

			while True:
				for host in sorted(self.hosts):
					if ZenPing.ping(self.hosts[host]['ip']):
						if host in self.down:
							self.down.remove(host)

							self.mails['up'].append(host)

						hosts[host]['ping'] = True

						self.log.success(host)
					else:
						if host not in self.down:
							self.down.append(host)

							self.mails['down'].append(host)

						hosts[host]['ping'] = False

						self.log.error(host)

				if len(self.mails['down']) > 0:
					self.mail(False)

					self.mails['down'] = []

				if len(self.mails['up']) > 0:
					self.mail(True)

					self.mails['up'] = []

				d = {'hosts': hosts}

				self.send(d)

				sleep(self.conf['sleep'])

				self.log.clear()
		except KeyboardInterrupt:
			pass