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()