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 event_disconnect(message):
log.info("%s disconnected" % current_user.username)
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 disconnect_request():
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():
print 'here'
count = increment_message_number()
emit('receive system', {'data': 'Disconnected!', 'count': count})
disconnect()
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 current_user.is_authenticated:
disconnect()
else:
return f(*args, **kwargs)
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):
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()
def on_exit(self, data):
disconnect()
