title: python error: [Errno 32] Broken pipe in Socket.sendall()
body: <p>I am writing a multi-threaded client/server program. It splits a large file into smaller files in its client side and sends the smaller files to the server concurrently.   </p>
  
  <p>The problem is that in every run, the server can only receive two of the smaller files (the first one and another random one). Meanwhile, I encounter the error: "[Errno 32] Broken pipe" in client side of the program in <code>s.sendall(part)</code>. The error arises in every thread that starts to send one of the smaller files before reception of the first file (on the server). In other words, every thread that starts to send after the reception the first file (on the server) can complete its task.    </p>
  
  <p>I run each of the client and server codes on different computers (both have the following specification: Ubuntu 14.04 desktop, 64 bit, 16GiB ram) </p>
  
  <p>Client side Error:</p>
  
  <pre><code>Traceback (most recent call last):
    File "Desktop/File_transmission/Client.py", line 56, in sendSplittedFile
      s.sendall(part)
    File "/usr/lib/python2.7/socket.py", line 224, in meth
      return getattr(self._sock,name)(*args)
  error: [Errno 32] Broken pipe
  </code></pre>
  
  <p>Client.py:</p>
  
  <pre><code>import random
  import socket
  import time
  import threading
  import errno
  import select
  import File_manipulation
  import sys, traceback
  
  class Client:
      nodesIpAddr = ["....", "...."] #Server = ....
      dataPort = 45678
      delay = 2
      inputFileAddress = 'tosend.dat'
      fileOutputPrefix = 'output'
      fileOutputSuffix = ".dat"
      bufferSize = 2048
      max_size_splitted_file = 10*(2**20) # 10 MiB
  
      def __init__ (self, my_ip):
          self.ip = my_ip
  
  
      def send(self, ip_toSend, dataPort):         
          print "\tSend function is runing."
          totalNumSplittedFile = File_manipulation.split_file(Client.inputFileAddress, Client.fileOutputPrefix, Client.max_size_splitted_file , Client.bufferSize)
          for i in range(0, totalNumSplittedFile):
              thread_send = threading.Thread(target = self.sendSplittedFile, args = (ip_toSend, dataPort, Client.bufferSize, i, Client.fileOutputPrefix, totalNumSplittedFile))
                  thread_send.start()  
  
  
      def sendSplittedFile(self, ip_toSend, dataPort, bufferSize, fileNumber, fileNamePrefix, totalNumSplittedFile):        
          # Create a socket (SOCK_STREAM means a TCP socket)
          s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
          BUFFER_SIZE = bufferSize
  
          try:
              s.connect((ip_toSend, dataPort))
              f = open(fileNamePrefix + '.%s' % fileNumber,'rb')
              s.send(str(fileNumber) + " " + str(totalNumSplittedFile))
              part = f.read(BUFFER_SIZE)
              while (part):
                  s.sendall(part)
                  part = f.read(BUFFER_SIZE)
  
              f.close()
              s.sendall(part)
              time.sleep(Client.delay)
              s.sendall('EOF')
              print "Done Sending."
              print s.recv(BUFFER_SIZE)
              s.close()
              print "\tData is sent to ", ip_toSend,
  
          except socket.error, v:
              traceback.print_exception(*sys.exc_info())           
          s.close()
  
  
  nodeIP = [(s.connect(('8.8.8.8', 80)), s.getsockname()[0], s.close()) for s in [socket.socket(socket.AF_INET, socket.SOCK_DGRAM)]][0][1]
  n = Client(nodeIP)
  n.send(n.nodesIpAddr[0], n.dataPort)
  </code></pre>
  
  <p>Server Side Error:</p>
  
  <pre><code>Traceback (most recent call last):
    File "/usr/lib/python2.7/SocketServer.py", line 295, in _handle_request_noblock
      self.process_request(request, client_address)
    File "/usr/lib/python2.7/SocketServer.py", line 321, in process_request
      self.finish_request(request, client_address)
    File "/usr/lib/python2.7/SocketServer.py", line 334, in finish_request
      self.RequestHandlerClass(request, client_address, self)
    File "/usr/lib/python2.7/SocketServer.py", line 649, in __init__
      self.handle()
    File "Desktop/File_transmissionServer.py", line 37, in handle
      totalFileNumber = int(details[1])
  ValueError: null byte in argument for int()
  </code></pre>
  
  <p>Server.py</p>
  
  <pre><code>import socket
  import time
  import threading
  import errno
  import select
  import SocketServer
  import File_manipulation
  
  class ServerThreadHandler(SocketServer.BaseRequestHandler):
      nodesIpAddr = ["....", "...."] #Server = ....
      fileOutputPrefix = 'torec '
      fileOutputSuffix = '.dat'
      dataPort = 45678
      delay = 3
      maxNumClientListenedTo = 200
      timeout_in_seconds = 5 
      bufferSize = 2048
      totalFileNumber = 0 #Total number of splitted files. It should be set by the incoming packets
  
      def handle(self):    
          BUFFER_SIZE = ServerThreadHandler.bufferSize  # Normally 1024, but we want fast response
  
          # self.request is the TCP socket connected to the client
          data = self.request.recv(BUFFER_SIZE)
          addr = self.client_address[0]
  
          details = str(data).split()
          currentFileNum = int(details[0])
          totalFileNumber = int(details[1])
          print '\tReceive: Connection address:', addr,'Current File Number: ', currentFileNum, 'Total Number of splitted files: ', totalFileNumber
  
          f = open(ServerThreadHandler.fileOutputPrefix + '_Received.%s' % currentFileNum, 'wb')
          data = self.request.recv(BUFFER_SIZE)
          while (data and data != 'EOF'):
              f.write(data)
              data = self.request.recv(BUFFER_SIZE)
          f.close()
          print "Done Receiving." ," File Number: ", currentFileNum
          self.request.sendall('\tThank you for data. File Number: ' + str(currentFileNum))
  
  if __name__ == "__main__":
      HOST, PORT = ServerThreadHandler.nodesIpAddr[0], ServerThreadHandler.dataPort # HOST = "localhost"
      server = SocketServer.TCPServer((HOST, PORT), ServerThreadHandler)
      # Activate the server; this will keep running until you interrupt the program with Ctrl-C
      server.serve_forever()
  </code></pre>