def watchdog_disconnect_request(): if sentrygund.config.debug: print '[debug][views] %s connected' % (request.sid) clients.remove(request.sid) disconnect()
def disconnect_request(message): if message["data"] != "": clients.pop(message["data"]) print("updating client dict...") emit('new client', {'all_clients': clients}, namespace='/test', broadcast=True) emit('closing chat', {"from": message["data"]}, namespace='/test', broadcast=True) disconnect()
def chat_connect(): if not session.get('logged_in'): emit('Message', {'prefix': '', 'data': 'Not logged in.'}) return False global userlist session['id'] = request.sid if session.get('user', False): userlist[session['user'].upper()] = session['id'] mailbox = Chatroom(session['user'], True) rooms.append(mailbox) session['rooms'] = [mailbox, rooms[0]] try: prevmode = session['chatmode'] except: prevmode = 'talk' session['activeroom'] = session['rooms'][1] join_room(session['activeroom'].name) session['chatmode'] = prevmode session['activeroom'] = rooms[0] rooms[0].userjoin(session['user']) join_room(rooms[0]) emit('Message', {'data': 'Hello and Welcome to the NosferatuNetwork Chatserver.\n'}) else: disconnect() return False
def disconnect_request(): session['receive_count'] = session.get('receive_count', 0) + 1 report_status(session['receive_count']) try: drone.land() except Exception as e: print(e) emit('indy response', {'data': 'Disconnected and landed', 'count': session['receive_count']}) disconnect()
def disconnect_request(): session['receive_count'] = session.get('receive_count', 0) + 1 indiv_msg = 'You have disconnected.' gr_msg = session['nick'] + ' has disconnected.' del connected_users[session['room']][session['uid']] emit('my response', {'data': indiv_msg, 'bot': 'true'}, room=session['uid']) disconnect() emit('my response', {'data': gr_msg, 'bot': 'true'}, room=session['room']) render_template('index.html')
def on_connect(): from onelove.models import User token = request.args.get('token', None) request.namespace = '/onelove' if token is None: disconnect() return current_identity = None try: current_identity = onelove.jwt.jwt_decode_callback(token) except: disconnect() if current_identity is None: disconnect() return user = User.objects.get(id=current_identity['identity']) join_room(str(user.id))
def accept(self, headers, data, **kwargs): ''' Goal : as a participant of a chat - discharge/remove/delete the provided chat - thus clearing all of the related messages and participations. Arguments:headers:dict, data:dict, kwargs:key-word-argument. headers : meant to contain all headers data , in this particular case - an Authorization field as a sign of authority, must contain a "Bearer <token> , which is the access_token: access_token={user_id:int, token_type: "access":str, activity:int , dnt:float} Note: This argument is used in the authorized decorator - to perform proper authorization process, the result of which is stored in the kwargs. To know more about the authorized decorator - view a separate documentation for the authorized method in the chathouse/utilities/security/validation/headers.py. data : meant to store any data that's passed into the request - json body: { id:<int> } Note: This argument is used in the verification process of the incoming request data, which is handled by the derived class template - which on itself is a result of create_a_template function, meant to return a proper template instance according to the route. To know more about the create_a_template - view a separate documentation for the create_a_template function in the ./template.py. kwargs: meant to store any data passed into the accept method, from the initial requrest, up to the authorization steps. In particular stores the authorization key , which on it's own stores shall store more nested information related to a token_type. In this instance the token_type is the access one - so kwargs shall store:{ authorization:{ access:{ valid:bool, status:int, owner:UserService|None, token:{ object:None|Token, location:str|None } } } } Full verification and actions: 0.Verify the access_token , which on it's own - verifies ownership - makes sure of the existance of a user with the user_id - establishing a UserService, and verifies the provided activity with the current one related to the UserService : If 0. is invalid - disconnect the client. [Note, on the response the user reconnects ,after they try to reestablish a new access_token] Otherwise proceed to the next steps. 1.At this point the access_token is valid - validate the incoming data: Set up a template - using a custom create_template, which builds and returns a Template instance. Validate the data against the template: If the verification has been successful and: The product of the validation / validated shall contain an "id" which refers to an ID of a chat , of which the owner ,of the request/access token, must be a participant! 2. Therefore verify if the owner is a participant of the provided chat: Then perform the discharging/removing/trashing the chat. 2.1 If everything has been successful: Having previously stored the participants of the removed chat, notify each each of them , with a proper notification on "discharged_chat" event. 2.1[-] Otherwise there has been a confilct inside of the database inform the requester to try again. 2.[-] Otherwise: Notify with a message implying about the unauthorized access. 1.[-] Otherwise - the resolution wasn't able to figure out the user based on the credentials proceed to the mention about the failure. 1.[-] Otherwise proceed to mention about the failure. Exceptions: Raises: TypeError - if headers and data arguments are not dictionaries. ''' #Code: #Exceptions: assert all( map(lambda argument: isinstance(argument, dict), (headers, data)) ), TypeError( 'Arguments , such as : headers and data - must be dictionaries') #Step 0. if not kwargs['authorization']['access']['valid'] or ( owner := kwargs['authorization']['access']['owner']) is None: disconnect() return None
def disconnect_request(): session['receive_count'] = session.get('receive_count', 0) + 1 emit(SERVER_GEN_RESPONSE, {'data': 'Disconnected!', 'count': session['receive_count']}) disconnect()
def can_disconnect(): disconnect()
def disconnect_request(): disconnect()
def on_disconnect(): print('Client disconnected') disconnect()
def test_disconnect(): disconnect('/test') print('Client disconnected ')
def disconnect_request(): log.info('publisher asked for a disconnect, disconnecting...') disconnect()
def disconnect_event(): emit('disconnect', {'status': 0, 'message': 'Disconnected!'}) disconnect()
def on_disconnect(self): emit('disconnect', {'data': 'Disconnected!'}) disconnect()
def wrapped(*args, **kwargs): if session.get("username") is None: disconnect() else: return f(*args, **kwargs)
def wrapped(*args, **kwargs): if current_user.is_authenticated or Config.LOGIN_DISABLED: return f(*args, **kwargs) else: disconnect()
def wrapped(*args, **kwargs): if not get_user_by_sid(session.sid): flask_socketio.disconnect() else: return f(*args, **kwargs)
def handle_please_disconnect(): print("please_disconnect received.") disconnect() SESSION['USERNAMES'] = {} # Reset the list of users, as part of
def on_disconnect(self): _id = session['socket_id'] running_process[_id] = False print('Client disconnected', request.sid) disconnect()
def disconnect_request(): thread_stop_event.set() disconnect()
def disconnect_request(): session['receive_count'] = session.get('receive_count', 0) + 1 print("disconnect request") emit('my response', {'data': 'Disconnected!', 'count': session['receive_count']}) disconnect()
def event_disconnect(message): log.info("%s disconnected" % current_user.username) disconnect()
def disconnect_request(): print 'here' count = increment_message_number() emit('receive system', {'data': 'Disconnected!', 'count': count}) disconnect()
def disconnect_request(): global contectedClients session['receive_count'] = session.get('receive_count', 0) + 1 contectedClients.discard(request.sid) emit('my response 2', {'data': 'Disconnected!', 'count': session['receive_count']}) disconnect()
def disconnect_request(message): print 'disconnecting' disconnect()
def _validate_access_token(): access_token = request.headers.environ.get('HTTP_X_ACCESS_TOKEN') if access_token != os.environ.get("ACCESS_TOKEN"): disconnect()
def disconnect_request(req): print 'disconnecting' disconnect()
def wrapped(*args, **kwargs): if not current_user.is_authenticated: disconnect() else: return f(*args, **kwargs)
def on_exit(self, data): disconnect()
def wrapped(*args, **kwargs): if not is_logged_in(): disconnect() else: return f(*args, **kwargs)
def disconnect_request(): emit('status', {'status': 'Disconnected!'}) disconnect()
def on_logout(socket_id): disconnect(socket_id)
def on_disconnect_request(self): session['receive_count'] = session.get('receive_count', 0) + 1 emit('my_response', {'data': 'Disconnected!', 'count': session['receive_count']}) disconnect()
def wrapped(*args, **kwargs): """Wrapper.""" if not current_user.is_authenticated: disconnect() else: return func(*args, **kwargs)
def on_disconnect_request(): disconnect()
def disconnect_request(): session['receive_count'] = session.get('receive_count', 0) + 1 emit('message recieved', {'data': 'Disconnected!', 'count': session['receive_count']}) disconnect()
def _inner_fn(*args, **kwargs): if not request.sid in ActiveUsers.active_sids: disconnect() return fn(*args, **kwargs)
def disconnect_request(): emit('my_response', {'data': 'Disconnected!'}) disconnect()
def test_disconnect(): if not APP.game: print('Removing Clients from non-active game server') disconnect() print('Client disconnected')
def disconnect_request(): # emit('user left', connection[getRealIP(request)][request.sid], broadcast = True) # del connection[getRealIP(request)][request.sid] disconnect()
def disconnect_request(): emit('my response', {'data': 'Disconnected!'}) disconnect()
def disconnect_request(message): emit('disconnect notification', {'user': message['user']}, broadcast=True) emit('my response', {'data': 'Disconnected!'}) disconnect()
def disconnect_request(): """Disconnect websocket""" disconnect()
def disconnect(socket_id: str, reason: enums.DisconnectReason): """Disconnect a user from a socket.""" helpers.send_room('game_disconnect', {'reason': reason.value}, socket_id) sockets.disconnect(socket_id)
def disconnect_request(): emit('my response', {'roll': '(sin dato)', 'pitch': '(sin dato)', 'yaw': '(sin dato)'}) disconnect()
def wrapped(*args, **kwargs): if not User.query.get(session.get('user_id') or -1): disconnect() else: return func(*args, **kwargs)
def disconnect_request(): #session['receive_count'] = session.get('receive_count', 0) + 1 #emit('my response', # {'data': 'Disconnected!', 'count': session['receive_count']}) thread_stop_event.set() disconnect()
def local_disconnect_request(): emit('lweb_response', {'data': 'Disconnected!'}) socketio.sleep(0) print('WEB DISCONNECTED ON CLOSE/REFRESH') disconnect()
def disconnect_request(): session['receive_count'] = session.get('receive_count', 0) + 1 emit('my response', {'data': 'Disconnected!', 'user': flask_login.current_user.username}) disconnect()
def log_diver(data): REQUEST_HEADER = 1 RESPONSE_HEADER = 2 LOG = 3 IMAGE_LOG = 4 ORIGIN = 5 input_url = data['input_url'] server_ip = data['server_ip'] req_header = data['req_header'] url_obj = urlparse(input_url) hostname = url_obj.hostname if not hostname: emit('log_diver', json.dumps({ 'type': 'error', 'message': 'Invalid URL or input http(s)://', })) disconnect(); return try: ipaddress.ip_address(hostname) emit('log_diver', json.dumps({ 'type': 'error', 'message': 'Cannot input IP in URL', })) disconnect(); return except ValueError: pass if server_ip: try: # IP Check to [ValueError] ipaddress.ip_address(server_ip) # Akamaized IP Check to [socket.gaierror] socket.gethostbyname('a' + server_ip.replace('.','-') +'.deploy.akamaitechnologies.com') except ValueError: try: server_ip = socket.gethostbyname(server_ip) socket.gethostbyname('a' + server_ip.replace('.','-') +'.deploy.akamaitechnologies.com') except socket.gaierror: emit('log_diver', json.dumps({ 'type': 'error', 'message': 'This hostname or ip isn\'t akamaized.', })) disconnect(); return except socket.gaierror: emit('log_diver', json.dumps({ 'type': 'error', 'message': 'Invalid IP.', })) disconnect(); return new_url = '{}://{}{}{}{}{}'.format(url_obj.scheme, server_ip, url_obj.path, url_obj.params, \ '?' + url_obj.query if url_obj.query else '', url_obj.fragment) if req_header: kurl_req_header = '\"-H ' + ' -H '.join(req_header.strip().replace(' ', '\ ').split('\n')) + '\"' pipe = subprocess.Popen(secrets.LSG_COMMAND_WITH_HOST_AND_HEADER.format(new_url, hostname, kurl_req_header), shell=True, stdout=subprocess.PIPE) else: pipe = subprocess.Popen(secrets.LSG_COMMAND_WITH_HOST.format(new_url, hostname), shell=True, stdout=subprocess.PIPE) else: try: socket.gethostbyname('a' + socket.gethostbyname(hostname).replace('.','-') +'.deploy.akamaitechnologies.com') except socket.gaierror: emit('log_diver', json.dumps({ 'type': 'error', 'message': 'Your hostname isn\'t akamaized, you can input akamaized IP or Hostname in \"Server IP\" textbox', })) disconnect(); return if req_header: kurl_req_header = '\"-H ' + ' -H '.join(req_header.strip().replace(' ', '\ ').split('\n')) + '\"' pipe = subprocess.Popen(secrets.LSG_COMMAND_WITH_HEADER.format(input_url, kurl_req_header), shell=True, stdout=subprocess.PIPE) else: pipe = subprocess.Popen(secrets.LSG_COMMAND.format(input_url), shell=True, stdout=subprocess.PIPE) status = 0 progress = '' request_header = '' response_header = '' logs = '' origin = [] others = '' summery = [['U', 37.3519, -121.952, 0, '0.0.0.0', 'US SANTACLARA', '', ''],] while pipe.poll() is None: line = pipe.stdout.readline().decode('utf-8') if line.startswith("[Request Header]"): status = REQUEST_HEADER continue elif line.startswith("[Response Header]"): status = RESPONSE_HEADER continue elif line.startswith("[Log]"): status = LOG edge_log = line.split('] [')[1] location_log = line.split('] [')[2][:-2].split('|') if edge_log.startswith('image_server'): edge = 'I' ip_address = edge_log.split(' ')[1] summery.append([edge, location_log[1], location_log[2], '-', ip_address, location_log[0], '-', '-']) status = IMAGE_LOG others = "[Image Logs]\n" elif edge_log.startswith('origin'): edge = 'O' ip_address = edge_log.split(' ')[1] origin = [edge, location_log[1], location_log[2], '-', ip_address, location_log[0], '-', '-'] status = ORIGIN continue elif line.startswith("[Console]"): console = line.split("|")[1] if console.startswith("[error]"): emit('log_diver', json.dumps({ 'type': 'error', 'message': console })) disconnect() return else: emit('log_diver', json.dumps({ 'type': 'console', 'content': console })) continue elif line.startswith("[Progress]"): emit('log_diver', json.dumps({ 'type': 'progress', 'content': line.split(" ")[1] })) continue if status == REQUEST_HEADER: if line.startswith("[/Request Header]"): emit('log_diver', json.dumps({ 'type': 'request', 'content': request_header })) request_header = request_header + line elif status == RESPONSE_HEADER: if line.startswith("[/Response Header]"): emit('log_diver', json.dumps({ 'type': 'response', 'content': response_header })) response_header = response_header + line elif status == LOG: if line.startswith("[/Log]") or line.startswith("\"\""): pass elif line.strip() != '': edge = '' ip_address = '' if edge_log.startswith('parent'): edge = 'P' ip_address = edge_log.split(' ')[1] elif edge_log.startswith('icp'): edge = 'G' ip_address = edge_log.split(' ')[1] else: # child edge = 'C' ip_address = edge_log logs = logs + line raw_log = line.split(' ') if raw_log[1] == 'r': if raw_log[10] == '127.0.0.1' or \ re.match('.*[t|X|C|U|T].*' , raw_log[15]): continue total_time = (int(raw_log[4]) + int(raw_log[5]) + int(raw_log[6])) \ + (0 if raw_log[3] == '-' else int(raw_log[3])) summery.append([edge, location_log[1], location_log[2], round(total_time * 0.001, 2), ip_address, location_log[0], raw_log[13], raw_log[7]]) elif raw_log[1] == 'S': if raw_log[10] == '127.0.0.1' or \ re.match('.*[t|X|C|U|T].*' , raw_log[17]): continue total_time = (int(raw_log[4]) + int(raw_log[5]) + int(raw_log[6])) \ + (0 if raw_log[3] == '-' else int(raw_log[3])) summery.append([edge, location_log[1], location_log[2], round(total_time * 0.001, 2), ip_address, location_log[0], raw_log[15], raw_log[7]]) # elif raw_log[1] == 'f': # if raw_log[11] == '127.0.0.1' or \ # re.match('.*[w|l|F|C|U|T].*', raw_log[18]): # continue # total_time += int(raw_log[7]) else: continue elif status == IMAGE_LOG: if line.startswith("[/Log]") or line.startswith("\"\""): pass else: others = others + line if origin: summery.append(origin) emit('log_diver', json.dumps({ 'type': 'log', 'content': logs, 'others': others, 'summery': str(summery) })) disconnect() # import re # from jinja2 import evalcontextfilter, Markup, escape # _paragraph_re = re.compile(r'(?:\r\n|\r|\n){2,}') # @application.template_filter() # @evalcontextfilter # def nl2br(eval_ctx, value): # result = u'\n\n'.join(u'<p>%s</p>' % p.replace('\n', '<br>\n') \ # for p in _paragraph_re.split(escape(value))) # if eval_ctx.autoescape: # result = Markup(result) # return result # if __name__ == "__main__": # socketio.run(application)
def wrapped(*args, **kwargs): if not request.headers.get('Authentication') == config['secret']: disconnect() else: return f(*args, **kwargs)
def default_socketio_error_handler(e): disconnect()
def disconnect_request(): session['receive_count'] = session.get('receive_count', 0) + 1 emit('Server response', {'data': 'Disconnected!', 'count': session['receive_count']}) disconnect()