import socket
import threading
import os
import os.path
import time

##########################################################
# Datos importantes
##########################################################
#bind_ip = '0.0.0.0'
#bind_ip = '127.0.0.1'
bind_ip = input('Digite IP del servidor (Remoto: 0.0.0.0. Local: 127.0.0.1): ')
#bind_port = 5005
bind_port = int(input('Digite puerto del servidor (5005): '))
TAM_BUFFER = 1024
MAX_THREADS = 100
threads = []
dir_src = os.getcwd()
dir_data = os.path.join(dir_src[:-(len(os.sep)+len("src"))],"data")
dir_archivos = os.path.join(dir_src[:-(len(os.sep)+len("src"))],"archivos")
# Se crea el socket de espera y se conecta el servidor
servidor = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
servidor.bind((bind_ip, bind_port))
servidor.listen(5)

print ('Escuchando en (ip:puerto){}:{}'.format(bind_ip, bind_port))

##########################################################
# Se declaran los threads!
##########################################################

##### Esta funcion es un thread, maneja la transferencia de archivos con un cliente.
##### el cliente entra por parametro
def manejador_conexion(socket__conexion_servidor_cliente, nombre_cliente, puerto_cliente):
    #se envia la lista de archivos primero (sin los archivos de python!)
    os.chdir(dir_archivos)
    lista_archivos = [a for a in os.listdir() if os.path.isfile(a)]
    #esta linea envia un string. Toca codificarlo a un stream de bytes.
    socket__conexion_servidor_cliente.sendto(str(lista_archivos).encode(), (nombre_cliente, puerto_cliente))

    #se recibe la peticion del archivo a enviar
    peticion = ''
    tiempo_inicio_conexion = time.time()
    while peticion != b'TERMINADA':
        peticion = socket__conexion_servidor_cliente.recv(TAM_BUFFER)
        print ('Pidieron: {}'.format(peticion))
        #si la peticion no existe, espera una peticion correcta del cliente
        while not os.path.isfile(peticion):
            print('No existe!')
            socket__conexion_servidor_cliente.sendto('No existe'.encode(), (nombre_cliente, puerto_cliente))
            peticion = socket__conexion_servidor_cliente.recv(TAM_BUFFER)

        #se debe enviar el tamanho del archivo antes
        #con el tamanho el cliente puede ver progreso y transferir correctamente los archivos
        tam_archivo = os.path.getsize(peticion)
        print('El archivo pedido {} tiene tamanho {}'.format(peticion,tam_archivo))
        socket__conexion_servidor_cliente.sendto(str(tam_archivo).encode(), (nombre_cliente, puerto_cliente))
        #se abre el archivo que se quiere enviar, se lee en pedazos de tamanho TAM_BUFFER
        tiempo_inicial = time.time()
        with open(peticion, 'rb') as f:
            archivo_enviar = f.read(TAM_BUFFER)
            #este while envia el archivo pedazo a pedazo hasta que ya no se lee mas.
            while archivo_enviar:
                socket__conexion_servidor_cliente.send(archivo_enviar)
                archivo_enviar = f.read(TAM_BUFFER)
        #se cierra el socket para escritura para prevenir errores raros
        tiempo_final = float(socket__conexion_servidor_cliente.recv(TAM_BUFFER).decode())
        tiempo_transcurrido = tiempo_final - tiempo_inicial
        print('Descarga finalizada con {}:{}. Tiempo transcurrido: {}'.format(nombre_cliente, puerto_cliente, tiempo_transcurrido))
        socket__conexion_servidor_cliente.sendto(str(tiempo_transcurrido).encode(), (nombre_cliente, puerto_cliente))
    socket__conexion_servidor_cliente.shutdown(socket.SHUT_WR)
    #se cierra el socket ahora si
    socket__conexion_servidor_cliente.close()
    tiempo_total =time.time() - tiempo_inicio_conexion
    print('Conexion cerrada con {}:{}. Tiempo transcurrido: {}'.format(nombre_cliente, puerto_cliente, tiempo_total))

#####Esta funcion es un thread para la recepcion de clientes.
def manejador_clientes():
    #while True obligatorio para escuchar siempre
    while True:
        print('aceptando conexion!')
        #se acepta conexion y se crea el socket de la comunicacion
        socket__conexion_servidor_cliente, direccion = servidor.accept()
        nombre_cliente = direccion[0]
        puerto_cliente = direccion[1]
        print ('Se acepto una conexion desde {}:{}'.format(direccion[0], direccion[1]))
        ##Esto inicia el threading de la comunicacion para un solo cliente
        e = threading.Event()
        if len(threads) < MAX_THREADS:
            thread_cliente = threading.Thread(
                target=manejador_conexion,
                args=(socket__conexion_servidor_cliente, nombre_cliente, puerto_cliente,)  #con la coma!!
            )
            thread_cliente.start()
            threads.append(thread_cliente)
        #Se espera 15 segundos para ver actividad en el thread, o se cierra
        thread_cliente.join(15)
        if thread_cliente.is_alive():
            e.set()
        thread_cliente.join()


##########################################################
# Ahora si empieza el programa
##########################################################
#Se crea el thread para manejar clientes
thread_generador_clientes = threading.Thread(
    target=manejador_clientes
)
thread_generador_clientes.start()
#Se mantiene vivo un conteo de threads.
while True:
    print('Numero de threads activos: {}'.format(threading.activeCount()))
    time.sleep(3)

62515af4678ad47133a11451c43f2c7b8937ece1
<mask token>


def manejador_conexion(socket__conexion_servidor_cliente, nombre_cliente,
    puerto_cliente):
    os.chdir(dir_archivos)
    lista_archivos = [a for a in os.listdir() if os.path.isfile(a)]
    socket__conexion_servidor_cliente.sendto(str(lista_archivos).encode(),
        (nombre_cliente, puerto_cliente))
    peticion = ''
    tiempo_inicio_conexion = time.time()
    while peticion != b'TERMINADA':
        peticion = socket__conexion_servidor_cliente.recv(TAM_BUFFER)
        print('Pidieron: {}'.format(peticion))
        while not os.path.isfile(peticion):
            print('No existe!')
            socket__conexion_servidor_cliente.sendto('No existe'.encode(),
                (nombre_cliente, puerto_cliente))
            peticion = socket__conexion_servidor_cliente.recv(TAM_BUFFER)
        tam_archivo = os.path.getsize(peticion)
        print('El archivo pedido {} tiene tamanho {}'.format(peticion,
            tam_archivo))
        socket__conexion_servidor_cliente.sendto(str(tam_archivo).encode(),
            (nombre_cliente, puerto_cliente))
        tiempo_inicial = time.time()
        with open(peticion, 'rb') as f:
            archivo_enviar = f.read(TAM_BUFFER)
            while archivo_enviar:
                socket__conexion_servidor_cliente.send(archivo_enviar)
                archivo_enviar = f.read(TAM_BUFFER)
        tiempo_final = float(socket__conexion_servidor_cliente.recv(
            TAM_BUFFER).decode())
        tiempo_transcurrido = tiempo_final - tiempo_inicial
        print('Descarga finalizada con {}:{}. Tiempo transcurrido: {}'.
            format(nombre_cliente, puerto_cliente, tiempo_transcurrido))
        socket__conexion_servidor_cliente.sendto(str(tiempo_transcurrido).
            encode(), (nombre_cliente, puerto_cliente))
    socket__conexion_servidor_cliente.shutdown(socket.SHUT_WR)
    socket__conexion_servidor_cliente.close()
    tiempo_total = time.time() - tiempo_inicio_conexion
    print('Conexion cerrada con {}:{}. Tiempo transcurrido: {}'.format(
        nombre_cliente, puerto_cliente, tiempo_total))


def manejador_clientes():
    while True:
        print('aceptando conexion!')
        socket__conexion_servidor_cliente, direccion = servidor.accept()
        nombre_cliente = direccion[0]
        puerto_cliente = direccion[1]
        print('Se acepto una conexion desde {}:{}'.format(direccion[0],
            direccion[1]))
        e = threading.Event()
        if len(threads) < MAX_THREADS:
            thread_cliente = threading.Thread(target=manejador_conexion,
                args=(socket__conexion_servidor_cliente, nombre_cliente,
                puerto_cliente))
            thread_cliente.start()
            threads.append(thread_cliente)
        thread_cliente.join(15)
        if thread_cliente.is_alive():
            e.set()
        thread_cliente.join()


<mask token>

<mask token>
servidor.bind((bind_ip, bind_port))
servidor.listen(5)
print('Escuchando en (ip:puerto){}:{}'.format(bind_ip, bind_port))


def manejador_conexion(socket__conexion_servidor_cliente, nombre_cliente,
    puerto_cliente):
    os.chdir(dir_archivos)
    lista_archivos = [a for a in os.listdir() if os.path.isfile(a)]
    socket__conexion_servidor_cliente.sendto(str(lista_archivos).encode(),
        (nombre_cliente, puerto_cliente))
    peticion = ''
    tiempo_inicio_conexion = time.time()
    while peticion != b'TERMINADA':
        peticion = socket__conexion_servidor_cliente.recv(TAM_BUFFER)
        print('Pidieron: {}'.format(peticion))
        while not os.path.isfile(peticion):
            print('No existe!')
            socket__conexion_servidor_cliente.sendto('No existe'.encode(),
                (nombre_cliente, puerto_cliente))
            peticion = socket__conexion_servidor_cliente.recv(TAM_BUFFER)
        tam_archivo = os.path.getsize(peticion)
        print('El archivo pedido {} tiene tamanho {}'.format(peticion,
            tam_archivo))
        socket__conexion_servidor_cliente.sendto(str(tam_archivo).encode(),
            (nombre_cliente, puerto_cliente))
        tiempo_inicial = time.time()
        with open(peticion, 'rb') as f:
            archivo_enviar = f.read(TAM_BUFFER)
            while archivo_enviar:
                socket__conexion_servidor_cliente.send(archivo_enviar)
                archivo_enviar = f.read(TAM_BUFFER)
        tiempo_final = float(socket__conexion_servidor_cliente.recv(
            TAM_BUFFER).decode())
        tiempo_transcurrido = tiempo_final - tiempo_inicial
        print('Descarga finalizada con {}:{}. Tiempo transcurrido: {}'.
            format(nombre_cliente, puerto_cliente, tiempo_transcurrido))
        socket__conexion_servidor_cliente.sendto(str(tiempo_transcurrido).
            encode(), (nombre_cliente, puerto_cliente))
    socket__conexion_servidor_cliente.shutdown(socket.SHUT_WR)
    socket__conexion_servidor_cliente.close()
    tiempo_total = time.time() - tiempo_inicio_conexion
    print('Conexion cerrada con {}:{}. Tiempo transcurrido: {}'.format(
        nombre_cliente, puerto_cliente, tiempo_total))


def manejador_clientes():
    while True:
        print('aceptando conexion!')
        socket__conexion_servidor_cliente, direccion = servidor.accept()
        nombre_cliente = direccion[0]
        puerto_cliente = direccion[1]
        print('Se acepto una conexion desde {}:{}'.format(direccion[0],
            direccion[1]))
        e = threading.Event()
        if len(threads) < MAX_THREADS:
            thread_cliente = threading.Thread(target=manejador_conexion,
                args=(socket__conexion_servidor_cliente, nombre_cliente,
                puerto_cliente))
            thread_cliente.start()
            threads.append(thread_cliente)
        thread_cliente.join(15)
        if thread_cliente.is_alive():
            e.set()
        thread_cliente.join()


<mask token>
thread_generador_clientes.start()
while True:
    print('Numero de threads activos: {}'.format(threading.activeCount()))
    time.sleep(3)

<mask token>
bind_ip = input('Digite IP del servidor (Remoto: 0.0.0.0. Local: 127.0.0.1): ')
bind_port = int(input('Digite puerto del servidor (5005): '))
TAM_BUFFER = 1024
MAX_THREADS = 100
threads = []
dir_src = os.getcwd()
dir_data = os.path.join(dir_src[:-(len(os.sep) + len('src'))], 'data')
dir_archivos = os.path.join(dir_src[:-(len(os.sep) + len('src'))], 'archivos')
servidor = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
servidor.bind((bind_ip, bind_port))
servidor.listen(5)
print('Escuchando en (ip:puerto){}:{}'.format(bind_ip, bind_port))


def manejador_conexion(socket__conexion_servidor_cliente, nombre_cliente,
    puerto_cliente):
    os.chdir(dir_archivos)
    lista_archivos = [a for a in os.listdir() if os.path.isfile(a)]
    socket__conexion_servidor_cliente.sendto(str(lista_archivos).encode(),
        (nombre_cliente, puerto_cliente))
    peticion = ''
    tiempo_inicio_conexion = time.time()
    while peticion != b'TERMINADA':
        peticion = socket__conexion_servidor_cliente.recv(TAM_BUFFER)
        print('Pidieron: {}'.format(peticion))
        while not os.path.isfile(peticion):
            print('No existe!')
            socket__conexion_servidor_cliente.sendto('No existe'.encode(),
                (nombre_cliente, puerto_cliente))
            peticion = socket__conexion_servidor_cliente.recv(TAM_BUFFER)
        tam_archivo = os.path.getsize(peticion)
        print('El archivo pedido {} tiene tamanho {}'.format(peticion,
            tam_archivo))
        socket__conexion_servidor_cliente.sendto(str(tam_archivo).encode(),
            (nombre_cliente, puerto_cliente))
        tiempo_inicial = time.time()
        with open(peticion, 'rb') as f:
            archivo_enviar = f.read(TAM_BUFFER)
            while archivo_enviar:
                socket__conexion_servidor_cliente.send(archivo_enviar)
                archivo_enviar = f.read(TAM_BUFFER)
        tiempo_final = float(socket__conexion_servidor_cliente.recv(
            TAM_BUFFER).decode())
        tiempo_transcurrido = tiempo_final - tiempo_inicial
        print('Descarga finalizada con {}:{}. Tiempo transcurrido: {}'.
            format(nombre_cliente, puerto_cliente, tiempo_transcurrido))
        socket__conexion_servidor_cliente.sendto(str(tiempo_transcurrido).
            encode(), (nombre_cliente, puerto_cliente))
    socket__conexion_servidor_cliente.shutdown(socket.SHUT_WR)
    socket__conexion_servidor_cliente.close()
    tiempo_total = time.time() - tiempo_inicio_conexion
    print('Conexion cerrada con {}:{}. Tiempo transcurrido: {}'.format(
        nombre_cliente, puerto_cliente, tiempo_total))


def manejador_clientes():
    while True:
        print('aceptando conexion!')
        socket__conexion_servidor_cliente, direccion = servidor.accept()
        nombre_cliente = direccion[0]
        puerto_cliente = direccion[1]
        print('Se acepto una conexion desde {}:{}'.format(direccion[0],
            direccion[1]))
        e = threading.Event()
        if len(threads) < MAX_THREADS:
            thread_cliente = threading.Thread(target=manejador_conexion,
                args=(socket__conexion_servidor_cliente, nombre_cliente,
                puerto_cliente))
            thread_cliente.start()
            threads.append(thread_cliente)
        thread_cliente.join(15)
        if thread_cliente.is_alive():
            e.set()
        thread_cliente.join()


thread_generador_clientes = threading.Thread(target=manejador_clientes)
thread_generador_clientes.start()
while True:
    print('Numero de threads activos: {}'.format(threading.activeCount()))
    time.sleep(3)

import socket
import threading
import os
import os.path
import time
bind_ip = input('Digite IP del servidor (Remoto: 0.0.0.0. Local: 127.0.0.1): ')
bind_port = int(input('Digite puerto del servidor (5005): '))
TAM_BUFFER = 1024
MAX_THREADS = 100
threads = []
dir_src = os.getcwd()
dir_data = os.path.join(dir_src[:-(len(os.sep) + len('src'))], 'data')
dir_archivos = os.path.join(dir_src[:-(len(os.sep) + len('src'))], 'archivos')
servidor = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
servidor.bind((bind_ip, bind_port))
servidor.listen(5)
print('Escuchando en (ip:puerto){}:{}'.format(bind_ip, bind_port))


def manejador_conexion(socket__conexion_servidor_cliente, nombre_cliente,
    puerto_cliente):
    os.chdir(dir_archivos)
    lista_archivos = [a for a in os.listdir() if os.path.isfile(a)]
    socket__conexion_servidor_cliente.sendto(str(lista_archivos).encode(),
        (nombre_cliente, puerto_cliente))
    peticion = ''
    tiempo_inicio_conexion = time.time()
    while peticion != b'TERMINADA':
        peticion = socket__conexion_servidor_cliente.recv(TAM_BUFFER)
        print('Pidieron: {}'.format(peticion))
        while not os.path.isfile(peticion):
            print('No existe!')
            socket__conexion_servidor_cliente.sendto('No existe'.encode(),
                (nombre_cliente, puerto_cliente))
            peticion = socket__conexion_servidor_cliente.recv(TAM_BUFFER)
        tam_archivo = os.path.getsize(peticion)
        print('El archivo pedido {} tiene tamanho {}'.format(peticion,
            tam_archivo))
        socket__conexion_servidor_cliente.sendto(str(tam_archivo).encode(),
            (nombre_cliente, puerto_cliente))
        tiempo_inicial = time.time()
        with open(peticion, 'rb') as f:
            archivo_enviar = f.read(TAM_BUFFER)
            while archivo_enviar:
                socket__conexion_servidor_cliente.send(archivo_enviar)
                archivo_enviar = f.read(TAM_BUFFER)
        tiempo_final = float(socket__conexion_servidor_cliente.recv(
            TAM_BUFFER).decode())
        tiempo_transcurrido = tiempo_final - tiempo_inicial
        print('Descarga finalizada con {}:{}. Tiempo transcurrido: {}'.
            format(nombre_cliente, puerto_cliente, tiempo_transcurrido))
        socket__conexion_servidor_cliente.sendto(str(tiempo_transcurrido).
            encode(), (nombre_cliente, puerto_cliente))
    socket__conexion_servidor_cliente.shutdown(socket.SHUT_WR)
    socket__conexion_servidor_cliente.close()
    tiempo_total = time.time() - tiempo_inicio_conexion
    print('Conexion cerrada con {}:{}. Tiempo transcurrido: {}'.format(
        nombre_cliente, puerto_cliente, tiempo_total))


def manejador_clientes():
    while True:
        print('aceptando conexion!')
        socket__conexion_servidor_cliente, direccion = servidor.accept()
        nombre_cliente = direccion[0]
        puerto_cliente = direccion[1]
        print('Se acepto una conexion desde {}:{}'.format(direccion[0],
            direccion[1]))
        e = threading.Event()
        if len(threads) < MAX_THREADS:
            thread_cliente = threading.Thread(target=manejador_conexion,
                args=(socket__conexion_servidor_cliente, nombre_cliente,
                puerto_cliente))
            thread_cliente.start()
            threads.append(thread_cliente)
        thread_cliente.join(15)
        if thread_cliente.is_alive():
            e.set()
        thread_cliente.join()


thread_generador_clientes = threading.Thread(target=manejador_clientes)
thread_generador_clientes.start()
while True:
    print('Numero de threads activos: {}'.format(threading.activeCount()))
    time.sleep(3)

import socket
import threading
import os
import os.path
import time

##########################################################
# Datos importantes
##########################################################
#bind_ip = '0.0.0.0'
#bind_ip = '127.0.0.1'
bind_ip = input('Digite IP del servidor (Remoto: 0.0.0.0. Local: 127.0.0.1): ')
#bind_port = 5005
bind_port = int(input('Digite puerto del servidor (5005): '))
TAM_BUFFER = 1024
MAX_THREADS = 100
threads = []
dir_src = os.getcwd()
dir_data = os.path.join(dir_src[:-(len(os.sep)+len("src"))],"data")
dir_archivos = os.path.join(dir_src[:-(len(os.sep)+len("src"))],"archivos")
# Se crea el socket de espera y se conecta el servidor
servidor = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
servidor.bind((bind_ip, bind_port))
servidor.listen(5)

print ('Escuchando en (ip:puerto){}:{}'.format(bind_ip, bind_port))

##########################################################
# Se declaran los threads!
##########################################################

##### Esta funcion es un thread, maneja la transferencia de archivos con un cliente.
##### el cliente entra por parametro
def manejador_conexion(socket__conexion_servidor_cliente, nombre_cliente, puerto_cliente):
    #se envia la lista de archivos primero (sin los archivos de python!)
    os.chdir(dir_archivos)
    lista_archivos = [a for a in os.listdir() if os.path.isfile(a)]
    #esta linea envia un string. Toca codificarlo a un stream de bytes.
    socket__conexion_servidor_cliente.sendto(str(lista_archivos).encode(), (nombre_cliente, puerto_cliente))

    #se recibe la peticion del archivo a enviar
    peticion = ''
    tiempo_inicio_conexion = time.time()
    while peticion != b'TERMINADA':
        peticion = socket__conexion_servidor_cliente.recv(TAM_BUFFER)
        print ('Pidieron: {}'.format(peticion))
        #si la peticion no existe, espera una peticion correcta del cliente
        while not os.path.isfile(peticion):
            print('No existe!')
            socket__conexion_servidor_cliente.sendto('No existe'.encode(), (nombre_cliente, puerto_cliente))
            peticion = socket__conexion_servidor_cliente.recv(TAM_BUFFER)

        #se debe enviar el tamanho del archivo antes
        #con el tamanho el cliente puede ver progreso y transferir correctamente los archivos
        tam_archivo = os.path.getsize(peticion)
        print('El archivo pedido {} tiene tamanho {}'.format(peticion,tam_archivo))
        socket__conexion_servidor_cliente.sendto(str(tam_archivo).encode(), (nombre_cliente, puerto_cliente))
        #se abre el archivo que se quiere enviar, se lee en pedazos de tamanho TAM_BUFFER
        tiempo_inicial = time.time()
        with open(peticion, 'rb') as f:
            archivo_enviar = f.read(TAM_BUFFER)
            #este while envia el archivo pedazo a pedazo hasta que ya no se lee mas.
            while archivo_enviar:
                socket__conexion_servidor_cliente.send(archivo_enviar)
                archivo_enviar = f.read(TAM_BUFFER)
        #se cierra el socket para escritura para prevenir errores raros
        tiempo_final = float(socket__conexion_servidor_cliente.recv(TAM_BUFFER).decode())
        tiempo_transcurrido = tiempo_final - tiempo_inicial
        print('Descarga finalizada con {}:{}. Tiempo transcurrido: {}'.format(nombre_cliente, puerto_cliente, tiempo_transcurrido))
        socket__conexion_servidor_cliente.sendto(str(tiempo_transcurrido).encode(), (nombre_cliente, puerto_cliente))
    socket__conexion_servidor_cliente.shutdown(socket.SHUT_WR)
    #se cierra el socket ahora si
    socket__conexion_servidor_cliente.close()
    tiempo_total =time.time() - tiempo_inicio_conexion
    print('Conexion cerrada con {}:{}. Tiempo transcurrido: {}'.format(nombre_cliente, puerto_cliente, tiempo_total))

#####Esta funcion es un thread para la recepcion de clientes.
def manejador_clientes():
    #while True obligatorio para escuchar siempre
    while True:
        print('aceptando conexion!')
        #se acepta conexion y se crea el socket de la comunicacion
        socket__conexion_servidor_cliente, direccion = servidor.accept()
        nombre_cliente = direccion[0]
        puerto_cliente = direccion[1]
        print ('Se acepto una conexion desde {}:{}'.format(direccion[0], direccion[1]))
        ##Esto inicia el threading de la comunicacion para un solo cliente
        e = threading.Event()
        if len(threads) < MAX_THREADS:
            thread_cliente = threading.Thread(
                target=manejador_conexion,
                args=(socket__conexion_servidor_cliente, nombre_cliente, puerto_cliente,)  #con la coma!!
            )
            thread_cliente.start()
            threads.append(thread_cliente)
        #Se espera 15 segundos para ver actividad en el thread, o se cierra
        thread_cliente.join(15)
        if thread_cliente.is_alive():
            e.set()
        thread_cliente.join()


##########################################################
# Ahora si empieza el programa
##########################################################
#Se crea el thread para manejar clientes
thread_generador_clientes = threading.Thread(
    target=manejador_clientes
)
thread_generador_clientes.start()
#Se mantiene vivo un conteo de threads.
while True:
    print('Numero de threads activos: {}'.format(threading.activeCount()))
    time.sleep(3)
