Example #1
0
def get_delta(sock):
    print 'GET DELTA'
    message = protocol_pb2.Message()
    message.id = 7
    message.type = protocol_pb2.Message.GET_DELTA
    message.get_delta.from_generation = 11
    message.get_delta.share = '2867b9fd-5cac-4d01-9c72-be2f769b7429'
    message.get_delta.from_scratch = False
    send_protobuf(sock, message)
    listing = True
    files = []
    while listing:
        rep = recv_message(sock)
        if rep.type == protocol_pb2.Message.DELTA_END:
            print 'delta end'
            listing = False
        elif rep.type == protocol_pb2.Message.DELTA_INFO:
            print 'rep type:', msg_type(rep), 'number', rep.id
            print 'generation:', rep.delta_info.generation, 'is_live:', rep.delta_info.is_live, 'type:', rep.delta_info.type
            print 'file infos:'
            print 'type:', rep.delta_info.file_info.type, 'parent:', rep.delta_info.file_info.parent, 'share:', rep.delta_info.file_info.share, 'node:', rep.delta_info.file_info.node, 'name:', rep.delta_info.file_info.name, 'is_public:', rep.delta_info.file_info.is_public, 'content hash:', rep.delta_info.file_info.content_hash, 'crc32:', rep.delta_info.file_info.crc32, 'size:', rep.delta_info.file_info.size, 'last modified:', rep.delta_info.file_info.last_modified
            files.append(rep.delta_info.file_info.name)
        else:
            print 'error', rep.error.type, rep.error.comment
            listing = False
    print '(', len(files), 'files )', files
    print ''
Example #2
0
 def run(self):
     while 1:
         """Приём собщений"""
         try:
             incoming_thread = protocol_pb2.Message()
             incoming_thread.ParseFromString(incoming_data(self.__stream))
             # client_name = incoming_thread.client_name
             msg = incoming_thread.msg
             # if msg == 'chart_list':
             #     for name in self.connected_clients.dict:
             #         for name in self.connected_clients.dict:
             #             self.connected_clients.dict[name].send_data(
             #                 self.connected_clients.string_of_online_clients()
             #             )
             for name in self.__connected_clients.dict:
                 self.__connected_clients.dict[name].send_data(msg)
         except:
             print('Клиет {} вышел из чата'.format(self.__client_ip))
             self.__connected_clients.remove_from_online_clients(
                 self.__client_name)
             self.__stream.close()
             for name in self.__connected_clients.dict:
                 self.__connected_clients.dict[name].send_data(
                     self.__connected_clients.string_of_online_clients())
                 self.__connected_clients.dict[name].send_data(
                     'polzovatel2017:::Пользователь {} '
                     'покинул чат'.format(self.__client_name))
             break
Example #3
0
 def process_message(self, data):
     """Function called when a message is received"""
     msg = protocol_pb2.Message()
     msg.ParseFromString(data)
     # print 'Servent sent message id', msg.id, 'type', msg.type, 'msg:', msg
     if msg.id % 2 != 0: # Odd = it's a response to one of our requests
         try:
             self.requests[msg.id].process(msg)
         except KeyError as ke: # should not happen because it always should be in response to one of our previous requests
             print 'Server error on message : {} ({})'.format(msg, ke),  # TODO: what to do ?
             self.io_loop.stop()
         except U1Requests.RequestException as re: # The request couldn't handle the response
             print 'Request exception: {}'.format(re)
             self.io_loop.stop()
         except Exception as e: # whatever happened
             print 'Unhandled exception: {}'.format(e)
             self.io_loop.stop()
     else: # Even : it's an unsolicited message from the server
         # call the function handling this kind of messages
         req_name = U1Requests.msg_type(msg)
         handler = getattr(self, "handle_" + req_name, None)
         if handler is not None:
             handler(msg)
         else: # Not supposed to happen (obsolete protocol ?)
             raise Exception("Cant handle message '{}' {}".format(U1Requests.msg_type(msg), str(message).replace("\n", " ")))
     self.receive_message() # wait for a new message
Example #4
0
 def run(self):
     while 1:
         try:
             incoming_thread = protocol_pb2.Message()
             a = self.__client.receive_data()
             incoming_thread.ParseFromString(a)
             msg = incoming_thread.msg
             command_key = msg.split(':::')
             if command_key[0] == 'polzovatel2017':
                 client_update_status = ' '.join(command_key[1:])
                 self.client_update_status(client_update_status)
                 continue
             if command_key[0] == 'spisok2017':
                 # clients_list = ' '.join(command_key[1:])
                 clients_list = (command_key[1]).split(';')
                 self.__client.add_clients_list(clients_list)
                 self.update_chart_list(clients_list)
                 continue
             if msg == 'Авторизация не удалась':
                 os._exit(0)
             self.handle_msg(msg)
         except:
             print('Сервер разорвал соединение')
             self.__client.close_conn()
             os._exit(0)
Example #5
0
def query(sock):
    print 'QUERY'
    message = protocol_pb2.Message()
    message.id = 9
    message.type = protocol_pb2.Message.QUERY
    query = message.query.add()
    query.share = '2867b9fd-5cac-4d01-9c72-be2f769b7429'
    query.node = '372abcb4-5d19-43ba-aa17-005a6aec9714'
    query.hash = 'sha1:6b163fa3bad47a62474afcb81fb9f27bcb549d82'
    send_protobuf(sock, message)

    print 'sent'
    rep = recv_message(sock)
    print 'rep type:', msg_type(rep)
    print ''
Example #6
0
def recv_message(sock):
    """sad and ugly way to receive a message, and nothing more (temporary !!)"""
    received = 0
    data = ''
    sizeLen = struct.calcsize("!I")
    while received < sizeLen:
        data += sock.read(sizeLen - received)
        received += len(data)
    msgLength = struct.unpack("!I", data[:sizeLen])[0]
    data = data[sizeLen:]
    received -= sizeLen
    while received < msgLength:
        data += sock.read(msgLength - received)
        received += len(data)
    rep = protocol_pb2.Message()
    rep.ParseFromString(data)
    return rep
Example #7
0
 def __init__(self, handler, kwargs):
     self.handler = handler  # the u1 requests handler
     self.handler.requests[self.handler.msg_id] = self
     # Setting a function to call when the request is complete.
     try:
         self.callback = kwargs['callback']
     except KeyError:  # No callback given: do nothing
         self.callback = None
     # If the request has been created from an unsolicited server message, take it
     if 'unsolicited' in kwargs:
         self.message = kwargs['server_msg']  # the server message
     else:  # Otherwise, initialize a new protobuf message
         self.message = protocol_pb2.Message()
         self.message.id = self.handler.msg_id
         self.handler.msg_id += 2  # to stay odd !
     self.responses = []
     self.states = {}  # Dict of message type -> function to call
     self.counter = 0  # Response counter
Example #8
0
 def run(self):
     count = 0
     maxcount = 3
     while count < maxcount:
         my_message = input()
         if not my_message:
             print('Введена пустая строка')
             count += 1
             continue
         if my_message == 'chart_list':
             print(self.__client.get_clients_list())
             continue
         message = protocol_pb2.Message()
         message.msg = my_message
         message.client_name = self.__client.client_name
         self.__client.send_data(message.SerializeToString())
     print('Перезапустите клиент')
     self.__client.close_conn()
     os._exit(0)
Example #9
0
def send_message(sock, id, type, oauth_creds=None):
    message = protocol_pb2.Message()
    message.id = id
    message.type = type
    # Signs the message with oauth (only at authentication time)
    if oauth_creds is not None:
        client = oauthlib.oauth1.Client(oauth_creds["consumer_key"],
                                        oauth_creds["consumer_secret"],
                                        oauth_creds["token"],
                                        oauth_creds["token_secret"],
                                        signature_method=SIGNATURE_PLAINTEXT,
                                        signature_type=SIGNATURE_TYPE_QUERY)
        url, headers, body = client.sign('http://server')
        # Parse out the authentication parameters from the query string.
        auth_parameters = dict(
            (name, value) for name, value in parse_qsl(urlparse(url).query)
            if name.startswith('oauth_'))
        # add the authentication informations
        for key, value in auth_parameters.items():
            param = message.auth_parameters.add()
            param.name = key
            param.value = value
    send_protobuf(sock, message)
Example #10
0
 def send_msg(self, msg):
     message = protocol_pb2.Message()
     message.msg = msg
     # message.client_name = self.client.client_name
     self.__client.send_data(message.SerializeToString())
Example #11
0
def send_msg(in_conn, msg):
    message = protocol_pb2.Message()
    message.msg = msg
    message = message.SerializeToString()
    packed_len = struct.pack('>L', len(message))
    write_volume(in_conn, packed_len + message)
Example #12
0
    def run(self):
        count = 0
        maxcount = 3
        try:
            while count < maxcount:
                """Аутефикация пользователя"""
                send_msg(
                    self.__stream,
                    'Существующий пользователь - введите 1. Если хотите зарегистрироваться - введите 0'
                )
                incoming_thread = protocol_pb2.Message()
                incoming_thread.ParseFromString(incoming_data(self.__stream))
                msg = incoming_thread.msg
                if msg != '1' and msg != '0':
                    send_msg(self.__stream, 'Введите либо 0 либо 1')
                    count += 1
                    continue
                """Аутефикация существующего пользователя"""
                if msg == '1':
                    send_msg(self.__stream, 'Введите имя пользователя')
                    incoming_thread = protocol_pb2.Message()
                    incoming_thread.ParseFromString(
                        incoming_data(self.__stream))
                    client_name = incoming_thread.msg
                    if client_name != database.read_name_by_name(
                            client_name
                    ) or self.__connected_clients.find_by_name(client_name):
                        count += 1
                        send_msg(
                            self.__stream,
                            'Имя пользователя не существует или пользователь онлайн,'
                            ' попробуйте снова.'
                            'Осталось {} попыток'.format(maxcount - count))
                        continue
                    send_msg(self.__stream, 'Введите пароль')
                    incoming_thread = protocol_pb2.Message()
                    incoming_thread.ParseFromString(
                        incoming_data(self.__stream))
                    msg = incoming_thread.msg
                    if msg != database.read_pass_by_name(client_name):
                        count += 1
                        send_msg(
                            self.__stream,
                            'Пароль введён неверно, попробуйте снова. '
                            'Осталось {} попыток'.format(maxcount - count))
                        continue
                    """Создаём поток для общения авторизованного клиента"""
                    send_msg(self.__stream, 'Добро пожаловать в общий чат')
                    data_thread = DataThread(self.__stream, self.__client_ip,
                                             self.__connected_clients,
                                             client_name)
                    self.__connected_clients.add_online_clients(
                        client_name, data_thread)
                    for name in self.__connected_clients.dict:
                        self.__connected_clients.dict[name].send_data(
                            self.__connected_clients.string_of_online_clients(
                            ))
                    for name in self.__connected_clients.dict:
                        self.__connected_clients.dict[name].send_data(
                            'polzovatel2017:::Пользователь {} '
                            'присоединился к чату'.format(client_name))
                    data_thread.start()
                    break
                """Аутефикация нового пользователя"""
                if msg == '0':
                    send_msg(
                        self.__stream,
                        'Введите имя пользователя. Только латинские буквы и цифры'
                    )
                    incoming_thread = protocol_pb2.Message()
                    incoming_thread.ParseFromString(
                        incoming_data(self.__stream))
                    client_name = incoming_thread.msg
                    if not client_name or validators.name_validator(
                            client_name) == False:
                        count += 1
                        send_msg(
                            self.__stream,
                            'Неверный ввод, осталось {} попыток'.format(
                                maxcount - count))
                        continue
                    if client_name == database.read_name_by_name(client_name):
                        count += 1
                        send_msg(
                            self.__stream,
                            'Пользователь с таким именем существует, попробуйте снова.'
                            'Осталось {} попыток'.format(maxcount - count))
                        continue
                    send_msg(self.__stream, 'Введите пароль')
                    incoming_thread = protocol_pb2.Message()
                    incoming_thread.ParseFromString(
                        incoming_data(self.__stream))
                    client_pass = incoming_thread.msg
                    if not client_pass or validators.name_validator(
                            client_name) == False:
                        count += 1
                        send_msg(
                            self.__stream,
                            'Неверный ввод, осталось {} попыток'.format(
                                maxcount - count))
                        continue
                    send_msg(
                        self.__stream, 'Пользователь {} добавлен, пройдите '
                        'авторизацию для существующего пользователя'.format(
                            client_name))
                    database.add_to_base(client_name, client_pass)

                    count = 0

            if count == maxcount:
                send_msg(self.__stream, 'Авторизация не удалась')
        except:
            print('Клиет {} вышел из чата'.format(self.__client_ip))
            self.__stream.close()
Example #13
0
 def Send(self,datatype,data):
     res=protobuf.Message()
     res.messagetype=datatype
     res.data=data
     self.SendToUDP(res.SerializeToString())