def configuration_post(request): for setting in ("imsiUpdate", "smsUpdate", "silentSms", "welcomeMessage", "replyMessage"): obj = DBSession.query(Settings).filter_by(name=setting).one() obj.value = request.POST.get(setting) DBSession.add(obj) return configuration_get(request)
def start_new_session(self): with transaction.manager: DBSession.query(Measure).delete() HLRDBSession.query(Sms).delete() HLRDBSession.query(Subscriber).filter(Subscriber.extension != self.pf_phone_number).delete() return True
def __init__(self, resource, playbook_path, req_id, model): super(MyPlaybook, self).__init__(resource) self.results_raw = None self.playbook_path = playbook_path self.req = req_id self.model = model self.count = 0 self.session = DBSession()
def start_new_session(self): with transaction.manager: DBSession.query(Measure).delete() HLRDBSession.query(Sms).delete() HLRDBSession.query(Subscriber).filter( Subscriber.extension != self.pf_phone_number).delete() return True
def gen_save_idsession(session, path): value = session if 'id' in session: print('Registra no banco a requisição') else: print('ID da session gerado.') value['id'] = str(uuid4()) # DBSession.begin() DBSession.add(LogModel(idsession=value['id'], endpoint=path)) transaction.commit() return value
def post(self): self.set_header('Content-Type', 'application/json') try: print self.request.body data = json.loads(self.request.body) except ValueError as e: self.set_status(400) return self.write( json.dumps({"message": "username and password are required!"})) username = data.get("username", None) password = data.get("password", None) if username and password: session = DBSession() try: user = session.query(User).filter( User.username == username).one() except Exception as e: logger.error("query db failed, %s" % e.message) user = None self.set_status(403) self.write( json.dumps({"message": "user %s not exist!" % username})) finally: session.close() if user: if hashlib.sha256(password).hexdigest() == user.password: payload = { 'id': user.id, 'username': username, 'exp': datetime.datetime.utcnow() + datetime.timedelta(seconds=43200), } token = jwt.encode(payload, SECRET_KEY, algorithm='HS256') response = {'token': token} self.write(response) else: self.set_status(403) self.write( json.dumps({"message": 'authentication failed!'})) else: self.set_status(400) self.write( json.dumps({"message": 'username and password are required.'}))
def get_imsi_circles(request): imsi = request.matchdict['imsi'] ts_begin = request.GET.get('timestamp_begin') ts_end = request.GET.get('timestamp_end') query = DBSession.query( Measure.distance, Measure.gps_lat, Measure.gps_lon, Measure.timestamp).filter( (Measure.imsi == imsi) & (Measure.gps_lat != None) & (Measure.gps_lon != None) & (Measure.timestamp <= datetime.fromtimestamp( float(ts_end) / 1000))).order_by(Measure.timestamp.asc()) if ts_begin is not None: query = query.filter(Measure.timestamp >= datetime.fromtimestamp( float(ts_begin) / 1000)) result = {'imsi': imsi, 'circles': []} for circle in query.all(): result['circles'].append({ 'center': [circle.gps_lat, circle.gps_lon], 'radius': circle.distance, 'ts': time.mktime(circle.timestamp.timetuple()) }) return result
def get_last_measure(self, imsi): last_measures = DBSession.query(Measure).filter( Measure.imsi == imsi).order_by(Measure.id.desc()).limit(1).all() if len(last_measures) == 0: return None return last_measures[0]
def get_imsi_list(request): result = [] messages = [] query = DBSession.query( Measure.id, Measure.imsi, func.max(Measure.timestamp).label('last') ).group_by(Measure.imsi).all() for measure in query: dtime = datetime.now() - measure.last result.append({ 'id': measure.id, 'imsi': measure.imsi, 'last_lur': dtime.total_seconds() // 60 }) # Calculate message count for each IMSI imsi_list = map(lambda item: item['imsi'], result); query = HLRDBSession.query( Subscriber.imsi, func.count(Sms.id).label('sms_count') ).filter(( (Sms.src_addr == Subscriber.extension) | (Sms.dest_addr == Subscriber.extension)) & (Sms.protocol_id != 64) & (Subscriber.imsi.in_(imsi_list)) ).group_by( Subscriber.imsi ).all() for record in query: messages.append({ 'imsi': int(record.imsi), 'count': record.sms_count }) if 'jtSorting' in request.GET: sorting_params = request.GET['jtSorting'].split(' ') sorting_field = sorting_params[0] reverse = sorting_params[1] == 'DESC' result.sort(key=lambda x: x[sorting_field], reverse=reverse) try: gps_status = all(request.xmlrpc.get_current_gps()) gps_status = 'yes' if gps_status else 'no' except (socket.error, xmlrpclib.Error) as e: gps_status = 'failed' return { 'Result': 'OK', 'Records': result, 'Messages': messages, 'GpsStatus': gps_status }
def get_formated_reply_message(self, **wargs): wargs["ph_phone_number"] = self.pf_phone_number reply_message_res = DBSession.query(Settings.value).filter(Settings.name == "replyMessage").all() if len(reply_message_res) != 1: self.logger.error("Settings table not have replyMessage value!") return None return reply_message_res[0][0].format(**wargs)
def configuration_get(request): query = DBSession.query(Settings.name, Settings.value) result = {} for setting in query.all(): result[setting.name] = setting.value return result
def save_measure_to_db(self, meas, extension): self.logger.debug("Save measure to DB!") distance = self.__calculate_distance(long(meas['meas_rep']['L1_TA'])) self.logger.debug("distance: {0}".format(distance)) with transaction.manager: obj = Measure(imsi=meas['imsi'], timestamp=datetime.datetime.fromtimestamp(meas['time']), timing_advance=meas['meas_rep']['L1_TA'], distance=distance, phone_number=extension, gps_lat=meas['lat'], gps_lon=meas['lon'], ) self.logger.info("Add measure: imsi={0}, ta={1}, lat={2}, lon={3}".format(meas['imsi'], meas['meas_rep']['L1_TA'], meas['lat'], meas['lon'])) DBSession.add(obj)
def get_formated_reply_message(self, **wargs): wargs["ph_phone_number"] = self.pf_phone_number reply_message_res = DBSession.query( Settings.value).filter(Settings.name == "replyMessage").all() if len(reply_message_res) != 1: self.logger.error("Settings table not have replyMessage value!") return None return reply_message_res[0][0].format(**wargs)
def main(argv=sys.argv): if len(argv) != 2: usage(argv) config_uri = argv[1] setup_logging(config_uri) settings = get_appsettings(config_uri) engine = engine_from_config(settings, 'sqlalchemy.pf.') DBSession.configure(bind=engine) Base.metadata.create_all(engine) hlr_engine = engine_from_config(settings, 'sqlalchemy.hlr.') HLRDBSession.configure(bind=hlr_engine) # initial settings with transaction.manager: DBSession.add_all([ Settings(name='imsiUpdate', value=3000), Settings(name='smsUpdate', value=3000), Settings(name='silentSms', value=3000), Settings( name='welcomeMessage', value='You are connected to a mobile search and rescue team. ' + \ 'Please SMS to {ph_phone_number} to communicate. ' + \ 'Your temporary phone number is {ms_phone_number}' ), Settings( name='replyMessage', value='Your SMSs are being sent to a mobile search and rescue team. ' + \ 'Reply to this message to communicate.' ), ]) HLRDBSession.add_all([ Subscriber( created=datetime.datetime.fromtimestamp(time.time()), updated=datetime.datetime.fromtimestamp(time.time()), imsi=pf_subscriber_imsi, name=pf_subscriber_name, extension=pf_subscriber_extension, authorized=1, lac=0 ) ])
def get_last_measure(self, imsi): last_measures = DBSession.query( Measure ).filter( Measure.imsi == imsi ).order_by( Measure.id.desc() ).limit(1).all() if len(last_measures) == 0: return None return last_measures[0]
def main(global_config, **settings): engine = engine_from_config(settings, 'sqlalchemy.pf.') DBSession.configure(bind=engine) Base.metadata.bind = engine engine = engine_from_config(settings, 'sqlalchemy.hlr.') HLRDBSession.configure(bind=engine) xmlrpc_url = 'http://%(xmlrpc.host)s:%(xmlrpc.port)s' % settings xmlrpc = lambda request: xmlrpclib.ServerProxy(xmlrpc_url) tile_dir = lambda request: settings.get('tile_dir') config = Configurator(settings=settings) config.include('pyramid_mako') config.add_static_view('static', 'static', cache_max_age=3600) config.add_route('home', '/') config.add_route('configuration', '/configuration') config.add_route('start_tracking', '/tracking/start') config.add_route('stop_tracking', '/tracking/stop') config.add_route('get_imsi_list', '/imsi/list') config.add_route('get_imsi_messages', 'imsi/{imsi}/messages') config.add_route('get_imsi_circles', 'imsi/{imsi}/circles') config.add_route('send_imsi_message', 'imsi/{imsi}/message') config.add_route('download_tiles_start', '/tiles/download/start') config.add_route('download_tiles_stop', '/tiles/download/stop') config.add_route('download_tiles_status', '/tiles/download/status') config.add_static_view(name='tiles', path=settings.get('tile_dir')) config.add_route('clear_data', '/data/clear/all') config.add_request_method(xmlrpc, 'xmlrpc', reify=True) config.add_request_method(tile_dir, 'tile_dir', reify=True) config.scan() return config.make_wsgi_app()
def save_measure_to_db(self, meas, extension): self.logger.debug("Save measure to DB!") distance = self.__calculate_distance(long(meas['meas_rep']['L1_TA'])) self.logger.debug("distance: {0}".format(distance)) with transaction.manager: obj = Measure( imsi=meas['imsi'], timestamp=datetime.datetime.fromtimestamp(meas['time']), timing_advance=meas['meas_rep']['L1_TA'], distance=distance, phone_number=extension, gps_lat=meas['lat'], gps_lon=meas['lon'], ) self.logger.info( "Add measure: imsi={0}, ta={1}, lat={2}, lon={3}".format( meas['imsi'], meas['meas_rep']['L1_TA'], meas['lat'], meas['lon'])) DBSession.add(obj)
def get_imsi_list(request): result = [] messages = [] query = DBSession.query(Measure.id, Measure.imsi, func.max( Measure.timestamp).label('last')).group_by( Measure.imsi).all() for measure in query: dtime = datetime.now() - measure.last result.append({ 'id': measure.id, 'imsi': measure.imsi, 'last_lur': dtime.total_seconds() // 60 }) # Calculate message count for each IMSI imsi_list = map(lambda item: item['imsi'], result) query = HLRDBSession.query( Subscriber.imsi, func.count(Sms.id).label( 'sms_count')).filter(((Sms.src_addr == Subscriber.extension) | (Sms.dest_addr == Subscriber.extension)) & (Sms.protocol_id != 64) & (Subscriber.imsi.in_(imsi_list))).group_by( Subscriber.imsi).all() for record in query: messages.append({'imsi': int(record.imsi), 'count': record.sms_count}) if 'jtSorting' in request.GET: sorting_params = request.GET['jtSorting'].split(' ') sorting_field = sorting_params[0] reverse = sorting_params[1] == 'DESC' result.sort(key=lambda x: x[sorting_field], reverse=reverse) try: gps_status = all(request.xmlrpc.get_current_gps()) gps_status = 'yes' if gps_status else 'no' except (socket.error, xmlrpclib.Error) as e: gps_status = 'failed' return { 'Result': 'OK', 'Records': result, 'Messages': messages, 'GpsStatus': gps_status }
def prepare_ready_for_silent_sms(self): while self.__stop_trackin_event.is_set() is False: sub_sms = HLRDBSession.query( Subscriber.imsi, Sms.dest_addr, Sms.sent, func.max(Sms.created) ).select_from( Subscriber ).outerjoin( Sms, ( (Sms.dest_addr == Subscriber.extension) and (Sms.protocol_id == 64) ) ).group_by( Sms.dest_addr ).filter( Subscriber.extension != self.pf_phone_number ).all() for (imsi, dest_addr, sent, created) in sub_sms: if dest_addr is not None: #if (sent is not None) or (self.__tracking_cicle_number == 0): if (sent is not None): self.__imis_reday_for_silent_sms_list.put(imsi) self.logger.debug("Tracking. Put imsi {0} to queue for send silent sms!".format(imsi)) else: self.logger.debug("Tracking. Don't put imsi {0} to queue for send silent sms - not answer previous one!".format(imsi)) else: self.logger.debug("Tracking. Put imsi {0} to queue for send silent sms!".format(imsi)) self.__imis_reday_for_silent_sms_list.put(imsi) silent_sms_interval = DBSession.query(Settings.value).filter(Settings.name == "silentSms").all() if len(silent_sms_interval) != 1: self.logger.error("Settings table not have silentSms value!") silent_sms_interval = self.measure_update_period else: silent_sms_interval = int(silent_sms_interval[0][0]) / 1000 time.sleep(silent_sms_interval) self.__tracking_cicle_number += 1
class TaskAsyncHandler(RequestHandler): executor = ThreadPoolExecutor(THREAD_POOL_MAX) def __init__(self, *args, **kwargs): self.session = DBSession() super(TaskAsyncHandler, self).__init__(*args, **kwargs) @gen.coroutine def get(self): self.set_header('Content-Type', 'application/json') req_id = self.get_argument('id') if req_id: results = yield self.get_data(req_id) results self.write(json.dumps(results)) else: self.write("id are required!") self.finish() @run_on_executor def get_data(self, req_id): """ 执行ansible playbook Args: resource: ditto playbook: ditto variable_dict: playbook variable dict """ results_objs = self.session.query(Record).filter( Record.req == str(req_id)).all() results_list = [{ 'submit_time': obj.submit_time.strftime('"%Y-%m-%d %H:%M:%S'), 'states': obj.states, 'step': obj.step, 'msg': obj.msg } for obj in results_objs] return results_list
class SSHPrivateKey(RequestHandler, CommonMiXin): executor = ThreadPoolExecutor(THREAD_POOL_MAX) def __init__(self, *args, **kwargs): self.session = DBSession() super(SSHPrivateKey, self).__init__(*args, **kwargs) @gen.coroutine def get(self, id): """ download ssh private key """ try: try: ssh_key = self.session.query(SSHKey).get(id) private_file = os.path.join(ssh_key.cache_dir, 'id_rsa') username = ssh_key.username except Exception as e: raise WorkFlowError("query database error, %s" % e.message) self.set_header('Content-Type', 'application/force-download') self.set_header( 'Content-Disposition', 'attachment; filename=%s-%s' % (username, 'id_rsa')) with open(private_file, "rb") as f: try: while True: _buffer = f.read(4096) if _buffer: self.write(_buffer) else: f.close() self.finish() return except Exception as e: raise HTTPError(500, reason='read file failed: %s' % e.message) except Exception as e: logger.error(e.message) self.my_response(400, e.message)
def get_imsi_circles(request): imsi = request.matchdict['imsi'] ts_begin = request.GET.get('timestamp_begin') ts_end = request.GET.get('timestamp_end') query = DBSession.query( Measure.distance, Measure.gps_lat, Measure.gps_lon, Measure.timestamp ).filter( (Measure.imsi == imsi) & (Measure.gps_lat != None) & (Measure.gps_lon != None) & (Measure.timestamp <= datetime.fromtimestamp(float(ts_end) / 1000)) ).order_by(Measure.timestamp.asc()) if ts_begin is not None: query = query.filter( Measure.timestamp >= datetime.fromtimestamp(float(ts_begin) / 1000) ) result = { 'imsi': imsi, 'circles': [] } for circle in query.all(): result['circles'].append({ 'center': [ circle.gps_lat, circle.gps_lon ], 'radius': circle.distance, 'ts': time.mktime(circle.timestamp.timetuple()) }) return result
def prepare_ready_for_silent_sms(self): while self.__stop_trackin_event.is_set() is False: sub_sms = HLRDBSession.query( Subscriber.imsi, Sms.dest_addr, Sms.sent, func.max(Sms.created)).select_from(Subscriber).outerjoin( Sms, ((Sms.dest_addr == Subscriber.extension) and (Sms.protocol_id == 64))).group_by(Sms.dest_addr).filter( Subscriber.extension != self.pf_phone_number).all() for (imsi, dest_addr, sent, created) in sub_sms: if dest_addr is not None: #if (sent is not None) or (self.__tracking_cicle_number == 0): if (sent is not None): self.__imis_reday_for_silent_sms_list.put(imsi) self.logger.debug( "Tracking. Put imsi {0} to queue for send silent sms!" .format(imsi)) else: self.logger.debug( "Tracking. Don't put imsi {0} to queue for send silent sms - not answer previous one!" .format(imsi)) else: self.logger.debug( "Tracking. Put imsi {0} to queue for send silent sms!". format(imsi)) self.__imis_reday_for_silent_sms_list.put(imsi) silent_sms_interval = DBSession.query( Settings.value).filter(Settings.name == "silentSms").all() if len(silent_sms_interval) != 1: self.logger.error("Settings table not have silentSms value!") silent_sms_interval = self.measure_update_period else: silent_sms_interval = int(silent_sms_interval[0][0]) / 1000 time.sleep(silent_sms_interval) self.__tracking_cicle_number += 1
def __init__(self, *args, **kwargs): super(SysUserHandler, self).__init__(*args, **kwargs) self.validate_data = Dict() self.session = DBSession()
class MyPlaybook(ResourceBase): """ this is my playbook object for execute playbook. Attributes: resource: resource dict ,see ResourceBase class playbook_path: relational playbook path, the default playbook directory is: <PLAYBOOK_DIR> req: required id model: sqlalchemy data model ws_function: web socket write message function """ def __init__(self, resource, playbook_path, req_id, model): super(MyPlaybook, self).__init__(resource) self.results_raw = None self.playbook_path = playbook_path self.req = req_id self.model = model self.count = 0 self.session = DBSession() def save(self, msg): if isinstance(msg, dict): msg = json.dumps(msg) states = 'SUCCESS' else: states = 'STARTED' try: msg = msg.decode('utf-8') except UnicodeEncodeError: msg = msg record = self.model(step=self.count, req=self.req, msg=msg, states=states) self.session.add(record) self.session.commit() self.session.close() def send_web(self, msg, color): pass def display(self, msg, color=None, stderr=False, screen_only=False, log_only=False, runner=None): self.count += 1 self.save(msg) self.send_web(msg, color) def run(self, extra_vars=None): """ run ansible playbook, only surport relational path. Args: extra_vars: playbook extra variables. """ task_results = [] stats = CustomAggregateStats(task_results) callbacks.display = self.display playbook_cb = CustomePlaybookCallbacks(verbose=utils.VERBOSITY, task_results=task_results) runner_cb = PlaybookRunnerCallbacks(stats=stats, verbose=utils.VERBOSITY) playbook_path = os.path.join(PLAYBOOK_DIR, self.playbook_path) pb = PlayBook(playbook=playbook_path, stats=stats, callbacks=playbook_cb, runner_callbacks=runner_cb, inventory=self.inventory, extra_vars=extra_vars, module_path=C.DEFAULT_MODULE_PATH, check=False) self.results_raw = pb.run() self.count += 1 self.save(self.results_raw) return self.results_raw
def __init__(self, *args, **kwargs): self.session = DBSession() super(TaskAsyncHandler, self).__init__(*args, **kwargs)
def __init__(self, *args, **kwargs): self.session = DBSession() super(SSHPrivateKey, self).__init__(*args, **kwargs)
logger = logging_utils.get_logger("main") logger.info("Comm interface started! pid: {0}".format(os.getpid())) # Init DB ================================================================ pf_db_conn_str = None try: pf_db_conn_str = configuration.get('app:main', 'sqlalchemy.pf.url') except ConfigParser.Error as err: logger.error("Identification People Finder DB fail: {0}".format(err.message)) sys.exit(1) logger.info("PF db sqlite path: {0}".format(pf_db_conn_str)) try: bind_session(pf_db_conn_str) DBSession.query(Measure).count() DBSession.query(Settings).count() except: logger.error("People finder DB connection err") raise hlr_db_conn_str = None try: hlr_db_conn_str = configuration.get('app:main', 'sqlalchemy.hlr.url') except ConfigParser.Error as err: logger.error("Identification HLR fail: {0}".format(err.message)) sys.exit(1) logger.info("HLR db sqlite path: {0}".format(hlr_db_conn_str)) try: bind_hlr_session(hlr_db_conn_str)
from wsgiref.simple_server import make_server from pyramid.session import SignedCookieSessionFactory from pyramid.config import Configurator from sqlalchemy import engine_from_config from model.models import DBSession, Base my_session_factory = SignedCookieSessionFactory ('kvbjoeifHG4woi7rtc3ndxhq3x0xj398HR47yroq3dj93r98yriwxhiuhd7teu7e') settings = {'sqlalchemy.url': 'sqlite:///./database/logurlaccess.db', 'sqlalchemy.echo': 'True'} if __name__ == '__main__': with Configurator ( ) as config: engine = engine_from_config (settings, 'sqlalchemy.') DBSession.configure (bind=engine) Base.metadata.bind = engine Base.metadata.create_all (engine) config.add_route ('home', '/') config.add_route ('quotes', '/quotes') config.add_route ('values', '/quotes/{value}') config.add_route ('consultas', '/consultas') config.set_session_factory (my_session_factory) config.include ('pyramid_jinja2') config.scan ('views') app = config.make_wsgi_app ( ) server = make_server ('0.0.0.0', 8080, app) server.serve_forever ( )
def consultas(request): retorno = DBSession.query(LogModel).all() json_string = json.dumps([ob.__dict__ for ob in retorno], default=datetime_handler) return Response(json_body=json.loads(json_string))
class SysUserHandler(RequestHandler, CommonMiXin): executor = ThreadPoolExecutor(THREAD_POOL_MAX) def __init__(self, *args, **kwargs): super(SysUserHandler, self).__init__(*args, **kwargs) self.validate_data = Dict() self.session = DBSession() def _validate_json(self): try: data = json.loads(self.request.body) self.validate_data.data = data except ValueError as e: logger.error("dump input data error: %s" % e.message) raise WorkFlowError("input data must be json data structure!") def _validate_required(self): required_field = ['resource', 'username'] for required in required_field: if required not in self.validate_data.data: raise WorkFlowError("%s must be required!" % required) self.validate_data.resource = self.validate_data.data['resource'] self.validate_data.username = self.validate_data.data['username'] self.validate_data.key_pass = self.validate_data.data.get( "key_pass", None) def validate(self): try: self._validate_json() self._validate_required() except Exception as e: return False, e.message return True, None @gen.coroutine def post(self): self.add_my_header() status, message = self.validate() if status: response = yield self.add_system_user(self.validate_data.resource, self.validate_data.username, self.validate_data.key_pass) code = 200 else: code = 400 response = message self.my_response(code, response) @gen.coroutine def put(self): self.ImplementError() @gen.coroutine def get(self): self.ImplementError() @gen.coroutine def delete(self, *args, **kwargs): self.add_my_header() status, message = self.validate() if status: response = yield self.del_system_user(self.validate_data.resource, self.validate_data.username) code = 200 else: code = 400 response = message self.my_response(code, response) @run_on_executor def add_system_user(self, resource, username, key_password): """ use ansible shell module to execute command on inventory. Args: resource: inventory resource, see Resource Class username: which user you want to add key_password: the ssh private key password Returns: AnsibleReuslt: AnsibleResult instance, contain the all ansible return information. """ task = Task(resource) key_dir = os.path.join(SSH_KEY_DIR, uuid4().hex) private, public = gen_keys(key_password) pri_file, pub_file = save_key_to_file(private, public, key_password, key_dir) add_user = task.add_user(username) add_key = task.push_key(username, pub_file) try: ssh_key = SSHKey(username=username, private_key=private, public_key=public, key_password=key_password, cache_dir=key_dir) self.session.add(ssh_key) self.session.commit() except Exception as e: self.session.rollback() logger.error("save ssh key instance to database failed!, %s" % e.message) finally: self.session.close() result = { "add_user": add_user.result_deal, "add_key": add_key.result_deal } return result @run_on_executor def del_system_user(self, resource, username): """ use ansible shell module to execute command on inventory. Args: resource: inventory resource, see Resource Class username: which user you want to add Returns: AnsibleReuslt: AnsibleResult instance, contain the all ansible return information. """ task = Task(resource) del_user = task.del_user(username) return del_user.result_deal