def update_host(self, host_ip, name, state, loading, supervisor_url):
"""Update state of host
"""
host = self.get_host_by_ip(host_ip)
if state == 'online':
host.online_time = tables.now_func()
host.alive = True
self.logger.info('Host %s goes online', host)
elif state == 'offline':
host.alive = False
self.logger.info('Host %s goes offline', host)
elif state == 'normal':
# Listen to Still alive: http://www.youtube.com/watch?v=Y6ljFaKRTrI
# :)
# the server back online
if not host.alive:
self.logger.info('Host %s is back online', host)
else:
self.logger.info('Host %s is still alive', host)
host.alive = True
host.name = name
host.loading = loading
host.supervisor_url = supervisor_url
host.last_updated = tables.now_func()
self.session.add(host)
self.session.flush()
def test_now_func(self):
from nowin_core.database import tables
for _ in range(100):
self.assertEqual(tables.now_func(), self.now_func.now)
self.now_func.now += datetime.timedelta(seconds=99)
self.assertEqual(tables.now_func(), self.now_func.now)
self.now_func.now -= datetime.timedelta(seconds=888)
self.assertEqual(tables.now_func(), self.now_func.now)
def expire_servers(self, timeout):
"""set servers whose last_updated is before current - timeout as dead
"""
from sqlalchemy.sql.expression import func, text
Server = tables.Server
OnAir = tables.OnAir
now = tables.now_func()
if isinstance(now, datetime.datetime):
deadline = now - datetime.timedelta(seconds=timeout)
else:
deadline = func.timestampadd(text('second'), -timeout, now)
query = self.session \
.query(Server.id) \
.filter(Server.alive) \
.filter(Server.last_updated < deadline)
# delete on airs of broadcast server
broadcasts = query \
.filter_by(type='broadcast') \
.subquery()
self.session \
.query(OnAir) \
.filter(OnAir.server_id.in_(broadcasts)) \
.delete('fetch')
# update server state to dead
count = query.count()
query.update(dict(alive=False), False)
self.session.flush()
self.logger.info('Expire %s servers', count)
def add_host(self, host_ip, name, alive, loading, supervisor_url=None):
"""Add a host and return
"""
host = tables.Host(
ip=host_ip,
name=name,
alive=alive,
loading=loading,
supervisor_url=supervisor_url,
online_time=tables.now_func(),
last_updated=tables.now_func(),
created=tables.now_func()
)
self.session.add(host)
self.session.flush()
host = self.get_host_by_ip(host_ip)
self.logger.info('Add host %s', host)
def create_user(
self,
user_name,
email,
display_name,
password
):
"""Create a new user and return verification
"""
user_name = user_name.lower()
email = email.lower()
# create user
user = tables.User(
user_name=unicode(user_name),
email=unicode(email),
display_name=unicode(display_name),
password=password,
created=tables.now_func()
)
# create verification
code = utils.generateRandomCode()
verification = tables.Verification(
user=user,
type=u'create_user',
code=code,
created=tables.now_func()
)
self.session.add(user)
self.session.add(verification)
# flush the change, so we can get real user id
self.session.flush()
assert user.user_id is not None, 'User id should not be none here'
user_id = user.user_id
signals.user_created_event(user_id)
self.session.flush()
self.logger.info('Create user %s with verification %s',
user, verification)
return user_id
def create_verification(self, user_id, type, code):
"""Create a verification
"""
Verification = tables.Verification
verify = Verification(user_id=user_id,
type=type,
code=code,
created=tables.now_func())
self.session.add(verify)
self.session.flush()
def update_on_airs(self, server_name, radios):
"""Update on-airs of a broadcast server
radios is a list of current online radio user name
"""
User = tables.User
OnAir = tables.OnAir
broadcast = self.get_server_by_name(server_name)
if broadcast is None:
msg = 'Update on-air to non-exist server %s' % server_name
self.logger.error(msg)
raise Exception(msg)
radios = map(unicode, radios)
# get old on-airs
old_on_airs = set([on_air.user_id for on_air in broadcast.on_airs])
# get new current on-airs
if radios:
users = self.session \
.query(User) \
.filter(User.user_name.in_(radios)) \
.all()
new_on_airs = set([user.user_id for user in users])
else:
new_on_airs = set()
# the set of on-air that we don't have to do anything with them
remain_on_airs = old_on_airs & new_on_airs
# to delete on-airs
to_delete = old_on_airs - remain_on_airs
# to add on_airs
to_add = new_on_airs - remain_on_airs
# delete off-line radios
if to_delete:
self.session \
.query(OnAir) \
.filter(OnAir.user_id.in_(to_delete)) \
.delete('fetch')
# add online radios
for user_id in to_add:
on_air = OnAir(
server_id=broadcast.id,
user_id=user_id,
online_time=tables.now_func()
)
self.session.add(on_air)
self.session.flush()
self.logger.info('Update on-air %s of broadcast %s',
len(radios), server_name)
def expire_hosts(self, timeout):
"""set hosts whose last_updated is before current - timeout as dead
"""
from sqlalchemy.sql.expression import func, text
Host = tables.Host
# delete out-dated hosts
# func.timestampadd()
now = tables.now_func()
if isinstance(now, datetime.datetime):
deadline = now - datetime.timedelta(seconds=timeout)
else:
deadline = func.timestampadd(text('second'), -timeout, now)
query = self.session \
.query(Host) \
.filter(Host.alive) \
.filter(Host.last_updated < deadline)
count = query.count()
query.update(dict(alive=False), False)
self.session.flush()
self.logger.info('Expire %s hosts', count)
def create_group(
self,
group_name,
display_name=None,
):
"""Create a new group and return its id
"""
group = tables.Group(
group_name=unicode(group_name),
display_name=unicode(
display_name) if display_name is not None else None,
created=tables.now_func()
)
self.session.add(group)
# flush the change, so we can get real user id
self.session.flush()
assert group.group_id is not None, 'Group id should not be none here'
group_id = group.group_id
self.logger.info('Create group %s', group_name)
return group_id
def add_on_airs(self, server_name, radios):
"""Add on-air radios
"""
from sqlalchemy.orm import joinedload
if not radios:
self.logger.info('No radio gets offline')
return
server = self.session \
.query(tables.Broadcast) \
.filter_by(name=server_name) \
.first()
if not server:
self.logger.error('Radio gets online from a non-exist server %s',
server_name)
return
users = self.session \
.query(tables.User) \
.options(joinedload('on_air')) \
.filter(tables.User.user_name.in_(radios)) \
.all()
for user in users:
onair = user.on_air
if not onair:
onair = tables.OnAir()
else:
self.logger.warn('OnAir %s already exist', onair)
continue
onair.online_time = tables.now_func()
onair.server_id = server.id
user.on_air = onair
self.session.add(server)
self.session.flush()
self.logger.info('Add on-air %s of broadcast %s',
len(radios), server_name)
def update_server(
self,
server_name,
type,
host,
state,
ports,
pid,
revision,
user_count,
user_limit,
resource_count,
resource_limit,
inbound_rate,
outbound_rate,
loading,
):
"""Update state of server
server_name
name of serverto update
type
type of server
state
current state of server heart beat
ports
ports of server, format should be
dict(port_name=port_address, ...)
pid
pid of process
revision
revision of server
user_count
count of user
user_limit
limit of user
resource_count
count of resource
resource_limit
limit of resource
inbound_rate
inbound bandwidth
outbound_rate
outbound bandwidth
loading
loading of server
radios
map of listener count on proxy server or
name of alive radios on braodcast server
"""
now = tables.now_func()
table_type = self.get_server_table(type)
server = self.session \
.query(table_type) \
.filter_by(name=server_name) \
.first()
if server is None:
server = table_type(name=server_name)
server.created = now
server.online_time = now
self.logger.info('Add server %r', server_name)
if state == 'online':
server.online_time = now
server.alive = True
self.logger.info('Server %r goes online',
server.name)
elif state == 'offline':
server.alive = False
self.logger.info('Server %r goes offline',
server.name)
elif state == 'normal':
# Listen to Still alive: http://www.youtube.com/watch?v=Y6ljFaKRTrI
# :)
if not server.alive:
self.logger.info('Server %r is back online',
server.name)
else:
self.logger.info('Server %r is still alive',
server.name)
server.alive = True
# get all old ports
old_ports = {}
for port in server.ports:
old_ports[port.name] = port
old_set = set(old_ports)
# get all new ports
new_ports = ports
new_set = set(new_ports)
# set of port to update
to_update = old_set & new_set
# set of port to delete
to_delete = old_set - to_update
# set of port to add
to_add = new_set - to_update
self.logger.debug('old: %s, new: %s', old_set, new_set)
self.logger.debug(
'to_update: %s, to_delete: %s, to_add: %s',
to_update, to_delete, to_add
)
# update old ports
for name in to_update:
port = old_ports[name]
port.address = new_ports[name]
self.session.add(port)
# delete outdate ports
for name in to_delete:
port = old_ports[name]
self.session.delete(port)
# add new ports
for name in to_add:
address = new_ports[name]
port = tables.Port(name=name, address=address)
server.ports.append(port)
self.session.add(port)
server.host = host
server.pid = pid
server.revision = revision
server.user_limit = user_limit
server.user_count = user_count
server.resource_limit = resource_limit
server.resource_count = resource_count
server.inbound_rate = inbound_rate
server.outbound_rate = outbound_rate
server.loading = loading
server.last_updated = now
self.session.add(server)
self.session.flush()
