Exemplo n.º 1
0
def main():
    # Inicializa enlace ... variavel com possui todos os metodos e propriedades do enlace, que funciona em threading
    com = Enlace(serialName) # repare que o metodo construtor recebe um string (nome)
    # Ativa comunicacao
    com.enable()
    com.rx.clearBuffer()


    my_server = Protocol.sever_number
    
    packer = Packer()
    unpacker = Unpacker()

    file_num = 1
    try_num = 1

    # Log
    print("-------------------------")
    print("Comunicação inicializada")
    print("  porta : {}".format(com.fisica.name))
    print("-------------------------")
    
    ocioso = True
    serverReady_message_sent = False
    count = 1

    while(True):

        # Server está ocioso
        if ocioso:
            dataRx = com.getData(Protocol.max_size, time.time())
            data, code, kind, total, server, client = unpacker.unpack(dataRx, first=True)

            # Server checa se o código e número de server da mensagem estão certos
            if code == Protocol.type_client_call and server == my_server:
                # Log do server é inicializado
                log = open("log/fille{:02}log_try{:02}.txt".format(file_num, try_num),"w+")
                # Server deixa de estar ocioso
                ocioso = False
                client_number = client
                print("-------------------------")
                print("Server chamado pelo client")
                print("-------------------------")
                log.write("Msg: {} – recebida: {} – remetente: {}\n".format(code, time.ctime(time.time()), client))

        # Server não está mais ociono mas ainda não mandou uma mensagem com Código 2   
        elif serverReady_message_sent == False:
            
            message = packer.pack_message(Protocol.type_server_ready, total, total, my_server, client_number)
            com.sendData(message)
            while(com.tx.getIsBussy()):
                pass
            
            serverReady_message_sent = True
            log.write("Msg: {} – enviada: {} – destinatário: {}\n".format(Protocol.type_server_ready, time.ctime(time.time()), client_number))

            print("-------------------------")
            print("Total de pacotes a receber : {}".format(total))
            print("Tipo de arquivo : {}".format(Protocol.from_kind[kind]))
            print("-------------------------")

            # Variáveis são iniciadas aqui para que não sejam mudadas indevidamente no loop de envio
            recieved = bytes()
            start = time.time()
            time_out_time = time.time()

        # Server recebe os pacotes e checa seus conteúdos
        else:

            # Enquanto todos os pacotes ainda não foram recebido, é checado se ainda não ocorreu um timeout
            if count <= total and (time.time() - time_out_time) < Protocol.great_timeout:
                dataRx = com.getData(Protocol.max_size, time.time())
                data, code, atual, client = unpacker.unpack(dataRx)

                print("-------------------------")
                print("Pacote aberto")
                print("Contador {} e atual {} e código {}".format(count, atual, code))
                print("-------------------------")

                log.write("Msg: {} – recebida: {} – remetente: {}\n".format(code, time.ctime(time.time()), client))

                # Se o pacote recebido conter o código certo e seu número bater com o esperado,
                # seu conteúdo é adicionado e uma mensagem de confirmação é enviada
                if code == Protocol.type_package_delivery and atual == count and client == client_number:
                    
                    print("-------------------------")
                    print("Pacote {} de {} recebido".format(atual, total))
                    print("-------------------------")

                    recieved += data
                    message = packer.pack_message(Protocol.type_package_ok, count, total, Protocol.sever_number, client_number)
                    com.sendData(message)
                    while(com.tx.getIsBussy()):
                        pass

                    count += 1
                    time_out_time = time.time()
                    log.write("Msg: {} –  enviada: {} – destinatário: {}\n".format(Protocol.type_package_ok, time.ctime(time.time()), client_number))

                # Se o pacote recebido não conter o código certo eou seu número não bater com o esperado,
                # seu conteúdo é ignorado e uma mensage de erro com o pacote esperado é enviada
                else:
                    print("-------------------------")
                    print("Erro")
                    print("Aguardando reenvio")
                    print("-------------------------")

                    message = packer.pack_message(Protocol.type_error, count, total, Protocol.sever_number, client_number)
                    com.sendData(message)
                    while(com.tx.getIsBussy()):
                        pass

                    log.write("Msg: {} –  enviada: {} – destinatário: {}\n".format(Protocol.type_error, time.ctime(time.time()), client_number))
                    
            # Quando todos os pacotes forem recebidos o stuffing, se houver, é removido e o arquivo salvo
            # O server volta para seu estado ocioso
            elif count > total:
                end = time.time() - start

                print("-------------------------")
                print("Pacotes recebidos com sucesso")
                print("Taxa de recepção: {:02}".format(total*Protocol.max_size/end))
                print("Salvando")
                print("-------------------------")
                
                to_save = unpacker.destuff(recieved)
                open("recieved/recieved{:02}".format(file_num) + Protocol.from_kind[kind],"wb").write(to_save)
                log.write("Salvo em: {}\n".format(time.ctime(time.time())))
                log.close()
                file_num += 1

                print("-------------------------")
                print("Aguardando novo envio")
                print("-------------------------")

                ocioso = True
                serverReady_message_sent = False
                com.rx.clearBuffer()
                count = 1
                try_num = 1

            # Se mais tempo que o estipulado para um timeout passou, o server volta para seu estado ocioso
            else:
                print("-------------------------")
                print("Timeout")
                print("Aguardando novo envio")
                print("-------------------------")
                message = packer.pack_message(Protocol.type_time_out, count, total, my_server, client_number)
                com.sendData(message)
                while(com.tx.getIsBussy()):
                    pass
                
                ocioso = True
                serverReady_message_sent = False
                count = 1
                log.write("Msg: {} –  enviada: {} – destinatário: {}\n".format(Protocol.type_time_out, time.ctime(time.time()), client_number))
                log.write("Encerrado\n")
                log.close()
Exemplo n.º 2
0
def main():
    # Inicializa enlace ... variavel com possui todos os metodos e propriedades do enlace, que funciona em threading
    com = Enlace(serialName)
    # Ativa comunicacao
    com.enable()
    com.rx.clearBuffer()

    packer = Packer()
    unpacker = Unpacker()

    # Log

    run = True
    call = True
    response = False
    serverReady_message_get = False
    count = 1

    while (run):

        if not response:

            if call:
                selected = select_file()

                print("-------------------------")
                print("Gerando dados para transmissao :")
                print("-------------------------")

                data = open(selected, "rb").read()
                delivery, total = packer.pack(data,
                                              get_kind(selected),
                                              Protocol.type_package_delivery,
                                              get_total=True)

                print("-------------------------")
                print("Chamando o server para tranferência de dados")
                print("-------------------------")
                message_timeot = time.time()
                call = False

            else:
                if (time.time() - message_timeot) < Protocol.great_timeout:
                    message = packer.pack_message(Protocol.type_client_call,
                                                  total, total,
                                                  Protocol.sever_number)
                    com.sendData(message)
                    while (com.tx.getIsBussy()):
                        pass

                    dataRx = com.getData(Protocol.max_size, time.time())
                    data, code, atual = unpacker.unpack(dataRx)

                    if code == Protocol.type_server_ready:
                        serverReady_message_get = True
                        response = True

                        print("-------------------------")
                        print("Server pronto, começando o envio")
                        print("-------------------------")

                        start = time.time()
                        time_out_time = time.time()
                        count = 1

                else:
                    response = True

        elif not call and serverReady_message_get:

            if count <= total and (time.time() -
                                   time_out_time) < Protocol.great_timeout:

                print("-------------------------")
                print("Envindo pacote {} de {}".format(count, total))
                print("-------------------------")
                com.sendData(delivery[count - 1])
                while (com.tx.getIsBussy()):
                    pass

                dataRx = com.getData(Protocol.max_size, time.time())
                data, code, atual = unpacker.unpack(dataRx)

                if code == Protocol.type_package_ok and atual == count:
                    print("-------------------------")
                    print("Pacote {} de {} enviado com sucesso".format(
                        count, total))
                    print("-------------------------")
                    count += 1
                    time_out_time = time.time()

                else:
                    print("-------------------------")
                    print("Erro")
                    print("-------------------------")

                    if 1 <= atual <= total:
                        count = atual

            elif count > total:
                end = time.time() - start

                print("-------------------------")
                print("Pacotes enviados com sucesso")
                print("Taxa de recepção: {:02}".format(
                    total * Protocol.max_size / end))
                print("-------------------------")

                print("-------------------------")
                go_on = input(
                    "Se desejar um novo envio digite sim, caso contrário outro caractere: "
                )
                print("-------------------------")

                call = True
                serverReady_message_get = False
                response = False
                count = 1

                if go_on != "sim":
                    print("-------------------------")
                    print("Até mais!")
                    print("-------------------------")
                    run = False

            else:
                print("-------------------------")
                print("O server não respondeu e um timeout ocorreu")
                print("-------------------------")

                print("-------------------------")
                go_on = input(
                    "Se desejar um novo envio digite sim, caso contrário outro caractere: "
                )
                print("-------------------------")

                call = True
                serverReady_message_get = False
                response = False
                count = 1

                if go_on != "sim":
                    print("-------------------------")
                    print("Até mais!")
                    print("-------------------------")
                    run = False

        else:
            print("-------------------------")
            print("O server não respondeu e um timeout ocorreu")
            print("-------------------------")

            print("-------------------------")
            go_on = input(
                "Se desejar um novo envio digite sim, caso contrário outro caractere: "
            )
            print("-------------------------")

            call = True
            serverReady_message_get = False
            response = False
            count = 1

            if go_on != "sim":
                print("-------------------------")
                print("Até mais!")
                print("-------------------------")
                run = False