socket | Package socket provides a low-level network connection type | Socket library

TCP/IP connections are designed to be long-lived streaming connections (built on top of the out-of-order, no-guarantee, packet-based IP protocol).

That means that is.read(bytes) does exactly what the spec says it will: It will wait until at least 1 byte is available, OR the 'end of stream' signal comes in. As long as neither occurs (no bytes arrive, but the stream isn't closed), it will dutifully block. Forever if it has to.

The solution is to either [A] pre-send the size of the file, and then adjust the loop to just exit once you've received that amount of bytes, or [B] to close the stream.

To close the stream, close the socket. It kinda sounds like you don't wanna do that (that you are multiplexing multiple things over the stream, i.e. that after transfering a file, you may then send other commands).

So, option A, that sounds better. However, option A has as a prerequisite that you know how many bytes are going to come out of inputStream. If it's a file, that's easy, just ask for its size. If it's streamed data, that would require that, on the 'upload code side', you first stream the whole thing into a file and only then stream it over the network which is unwieldy and potentially inefficient.

If you DO know the size, it would look something like (and I'm going to use newer APIs here, you're using some obsolete, 20 year old outdated stuff):

Use HTTPS secured connection.

This is one of the features of HTTPS (SSL/TLS) - it can prevent a MITM attack and prevent the destination server from being impersonated.

https://stackoverflow.com/a/24586398/12595469

Yes, the exception occurred due to firewall. The ping test is successful from local machine to VM but not from VM to local. I contacted the organization network administrator to confirmed this.

Pythons multiprocessing package is limited to shared memory parallelization. It spawns new processes that all have access to the main memory of a single machine.

You cannot simply scale out such a software onto multiple nodes. As the different machines do not have a shared memory that they can access.

To run your program on multiple nodes at once, you should have a look into MPI (Message Passing Interface). There is also a python package for that.

Depending on your task, it may also be suitable to run the program 4 times (so one job per node) and have it work on a subset of the data. It is often the simpler approach, but not always possible.

I was able to fix this by removing sub_filter directive from nginx conf and updating url_prefixes in flask app. The steps I took are posted on this dash forum

I ended implementing the TLS handshake timeout this way:

Here I'm wondering about the line [in s_client]
New, TLSv1/SSLv3, Cipher is ECDHE-RSA-AES256-GCM-SHA384

You're apparently using OpenSSL 1.0.2, where that's a basically useless relic. Back in the days when OpenSSL supported SSLv2 (mostly until 2010, although almost no one used it much after 2000), the ciphersuite values used for SSLv3 and up (including all TLS, but before 2014 OpenSSL didn't implement higher than TLS1.0) were structured differently than those used for SSLv2, so it was important to qualify the ciphersuite by the 'universe' it existed in. It has almost nothing to do with the protocol version actually used, which appears later in the session-param decode:

Change

Presumably, libevent is relying on the buffering semantics of the underlying socket implementation.

For TCP/IP, this involves sending any buffered data either when the send buffer is full or a short while after no new data has been added (Nagle's algorithm), whichever happens first. Since this delay is typically only a few hundred milliseconds, you may not have noticed it.

There is a call to setsockopt to disable this delay (TCP_NODELAY) and it's possible that libevent is using that, in which case any data passed to send is transmitted immediately. You'd probably have to inspect the source to see if that's what they're actually doing (it would be unusual).