people: Show SIP agent status

[ipfire.org.git] / src / backend / talk.py

#!/usr/bin/python

import ipaddress
import logging
import re
import time

from . import database

from .misc import Object
from .decorators import *

class Freeswitch(Object):
	@lazy_property
	def db(self):
		credentials = {
			"host"     : self.settings.get("freeswitch_database_host"),
			"database" : self.settings.get("freeswitch_database_name", "freeswitch"),
			"user"     : self.settings.get("freeswitch_database_user"),
			"password" : self.settings.get("freeswitch_database_password"),
		}

		return database.Connection(**credentials)

	def get_sip_registrations(self, sip_uri):
		logging.debug("Fetching SIP registrations for %s" % sip_uri)

		user, delim, domain = sip_uri.partition("@")

		res = self.db.query("SELECT * FROM sip_registrations \
			WHERE sip_user = %s AND sip_host = %s AND expires >= EXTRACT(epoch FROM CURRENT_TIMESTAMP) \
			ORDER BY contact", user, domain)

		for row in res:
			yield SIPRegistration(self, data=row)

	def _get_channels(self, query, *args):
		res = self.db.query(query, *args)

		channels = []
		for row in res:
			c = Channel(self, data=row)
			channels.append(c)

		return channels

	def get_sip_channels(self, account):
		return self._get_channels("SELECT * FROM channels \
			WHERE (direction = %s AND cid_num = %s) OR \
				(direction = %s AND (callee_num = %s OR callee_num = ANY(%s))) \
				AND callstate != %s ORDER BY created_epoch",
			"inbound", account.sip_id, "outbound", account.sip_id,
			account._all_telephone_numbers, "DOWN")

	def get_cdr_by_account(self, account, date=None, limit=None):
		res = self.db.query("SELECT * FROM cdr \
			WHERE ((caller_id_number = ANY(%s) AND bleg_uuid IS NOT NULL) \
				OR (destination_number = ANY(%s) AND bleg_uuid IS NULL)) \
				AND (%s IS NULL OR start_stamp::date = %s) \
			ORDER BY end_stamp DESC LIMIT %s", account._all_telephone_numbers,
			account._all_telephone_numbers, date, date, limit)

		for row in res:
			yield CDR(self, data=row)

	def get_call_by_uuid(self, uuid):
		res = self.db.get("SELECT * FROM cdr \
			WHERE uuid = %s", uuid)

		if res:
			return CDR(self, data=res)

	def get_conferences(self):
		res = self.db.query("SELECT DISTINCT application_data AS handle FROM channels \
			WHERE application = %s AND application_data LIKE %s \
			ORDER BY application_data", "conference", "%%@ipfire.org")

		conferences = []
		for row in res:
			c = Conference(self, row.handle)
			conferences.append(c)

		return conferences

	def get_agent_status(self, account):
		res = self.db.get("SELECT status FROM agents \
			WHERE name = %s", account.sip_url)

		if res:
			return res.status

class SIPRegistration(object):
	def __init__(self, freeswitch, data):
		self.freeswitch = freeswitch
		self.data = data

	@lazy_property
	def protocol(self):
		m = re.match(r"Registered\(([A-Z]+)(\-NAT)?\)", self.data.status)

		if m:
			return m.group(1)

	@property
	def network_ip(self):
		return ipaddress.ip_address(self.data.network_ip)

	@property
	def network_port(self):
		return self.data.network_port

	@property
	def user_agent(self):
		return self.data.user_agent

	def is_reachable(self):
		return self.data.ping_status == "Reachable"

	@lazy_property
	def latency(self):
		if self.is_reachable() and self.data.ping_time:
			return self.data.ping_time / 1000.0


class Channel(object):
	def __init__(self, freeswitch, data):
		self.freeswitch = freeswitch
		self.data = data

	@property
	def backend(self):
		return self.freeswitch.backend

	@property
	def uuid(self):
		return self.data.uuid

	@property
	def direction(self):
		return self.data.direction

	@lazy_property
	def caller(self):
		return self.backend.accounts.get_by_sip_id(self.caller_number)

	@property
	def caller_name(self):
		return self.data.cid_name

	@property
	def caller_number(self):
		return self.data.cid_num

	@lazy_property
	def callee(self):
		return self.backend.accounts.get_by_sip_id(self.callee_number)

	@property
	def callee_name(self):
		return self.data.callee_name

	@property
	def callee_number(self):
		return self.data.callee_num

	@property
	def called_number(self):
		return self.data.dest

	@property
	def state(self):
		return self.data.callstate

	@property
	def application(self):
		return self.data.application

	@property
	def application_data(self):
		return self.data.application_data

	@lazy_property
	def conference(self):
		if self.application == "conference":
			return Conference(self.freeswitch, self.application_data)

	@property
	def duration(self):
		return time.time() - self.data.created_epoch

	@property
	def codec(self):
		# We always assume a symmetric codec
		return format_codec(self.data.write_codec, int(self.data.write_rate or 0), int(self.data.write_bit_rate or 0))

	def is_secure(self):
		if self.data.secure:
			return True

		return False

	@property
	def secure(self):
		try:
			transport_protocol, key_negotiation, cipher_suite = self.data.secure.split(":")
		except:
			return

		return "%s: %s" % (key_negotiation.upper(), cipher_suite.replace("_", "-"))


class CDR(object):
	def __init__(self, freeswitch, data):
		self.freeswitch = freeswitch
		self.data = data

	@property
	def backend(self):
		return self.freeswitch.backend

	@property
	def db(self):
		return self.freeswitch.db

	@property
	def uuid(self):
		return self.data.uuid

	@lazy_property
	def bleg(self):
		if self.data.bleg_uuid:
			return self.freeswitch.get_call_by_uuid(self.data.bleg_uuid)

		# If we are the bleg, we need to search for one where UUID is the bleg
		res = self.db.get("SELECT * FROM cdr WHERE bleg_uuid = %s", self.uuid)

		if res:
			return CDR(self.freeswitch, data=res)

	@property
	def direction(self):
		if self.data.bleg_uuid:
			return "inbound"

		return "outbound"

	@lazy_property
	def caller(self):
		return self.backend.accounts.get_by_phone_number(self.data.caller_id_number)

	@property
	def caller_number(self):
		return self.data.caller_id_number

	@lazy_property
	def callee(self):
		return self.backend.accounts.get_by_phone_number(self.data.destination_number)

	@property
	def callee_number(self):
		return self.data.destination_number

	@property
	def time_start(self):
		return self.data.start_stamp

	@property
	def time_answered(self):
		return self.data.answer_stamp

	@property
	def duration(self):
		return self.data.duration

	@property
	def codec(self):
		return format_codec(self.data.write_codec, int(self.data.write_rate or 0), int(self.data.write_bit_rate or 0))

	@property
	def user_agent(self):
		if self.data.user_agent:
			return self.data.user_agent.replace("_", " ")

	@property
	def size(self):
		return sum((self.data.rtp_audio_in_raw_bytes or 0, self.data.rtp_audio_out_raw_bytes or 0))

	@property
	def mos(self):
		return self.data.rtp_audio_in_mos


class Conference(object):
	def __init__(self, freeswitch, handle):
		self.freeswitch = freeswitch
		self.handle = handle

	def __repr__(self):
		return "<%s %s>" % (self.__class__.__name__, self.handle)

	def __len__(self):
		return len(self.channels)

	def __eq__(self, other):
		if isinstance(other, self.__class__):
			return self.handle == other.handle

	def __iter__(self):
		return iter(self.channels)

	@lazy_property
	def number(self):
		m = re.match(r"conf(\d+)@", self.handle)
		if m:
			i = m.group(1)

			return int(i)

	@property
	def sip_id(self):
		return 900 + self.number

	@lazy_property
	def channels(self):
		return self.freeswitch._get_channels("SELECT * FROM channels \
			WHERE application = %s AND application_data = %s \
			ORDER BY created_epoch", "conference", self.handle)


class Talk(Object):
	def init(self):
		# Connect to FreeSWITCH
		self.freeswitch = Freeswitch(self.backend)

	@property
	def conferences(self):
		return self.freeswitch.get_conferences()


def format_codec(name, bit_rate, bandwidth):
	if not name:
		return

	s = [
		name,
	]

	if bit_rate:
		s.append("%.0f kHz" % (bit_rate / 1000.0))

	if bandwidth:
		s.append("%.0f kBit/s" % (bandwidth / 1000.0))
	else:
		s.append("VBR")

	return " ".join(s)