Python socket.SHUT_RD Examples
The following are 30
code examples of socket.SHUT_RD().
You can vote up the ones you like or vote down the ones you don't like,
and go to the original project or source file by following the links above each example.
You may also want to check out all available functions/classes of the module
socket
, or try the search function
.
.
Example #1
| Source File: start.py From Starx_Pixiv_Collector with MIT License | 8 votes |
|
def ip_latency_test(ip, port=443):
tag = 'IP_Latency_TEST'
print_with_tag(tag, ['Prepare IP latency test for ip', ip, 'Port', str(port)])
s_test = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s_test.settimeout(10)
s_start = time.time()
try:
s_test.connect((ip, port))
s_test.shutdown(socket.SHUT_RD)
except Exception as e:
print_with_tag(tag, ['Error:', e])
return None
s_stop = time.time()
s_runtime = '%.2f' % (1000 * (s_stop - s_start))
print_with_tag(tag, [ip, 'Latency:', s_runtime])
return float(s_runtime)
Example #2
| Source File: netcat.py From nclib with MIT License | 6 votes |
|
def shutdown(self, how=socket.SHUT_RDWR):
"""
Send a shutdown signal for one or both of reading and writing. Valid
arguments are ``socket.SHUT_RDWR``, ``socket.SHUT_RD``, and
``socket.SHUT_WR``.
Shutdown differs from closing in that it explicitly changes the state of
the socket resource to closed, whereas closing will only decrement the
number of peers on this end of the socket, since sockets can be a
resource shared by multiple peers on a single OS. When the number of
peers reaches zero, the socket is closed, but not deallocated, so you
still need to call close. (except that this is python and close is
automatically called on the deletion of the socket)
http://stackoverflow.com/questions/409783/socket-shutdown-vs-socket-close
"""
return self.sock.shutdown(how)
Example #3
| Source File: common_func.py From passbytcp with MIT License | 6 votes |
|
def _rd_shutdown(self, conn, once=False):
"""action when connection should be read-shutdown
:type conn: socket.SocketType
"""
if conn in self.conn_rd:
self.conn_rd.remove(conn)
try:
conn.shutdown(socket.SHUT_RD)
except:
pass
if not once and conn in self.map: # use the `once` param to avoid infinite loop
# if a socket is rd_shutdowned, then it's
# pair should be wr_shutdown.
self._wr_shutdown(self.map[conn], True)
if self.map.get(conn) not in self.conn_rd:
# if both two connection pair was rd-shutdowned,
# this pair sockets are regarded to be completed
# so we gonna close them
self._terminate(conn)
Example #4
| Source File: common_func.py From passbytcp with MIT License | 6 votes |
|
def _rd_shutdown(self, conn, once=False):
"""action when connection should be read-shutdown
:type conn: socket.SocketType
"""
if conn in self.conn_rd:
self.conn_rd.remove(conn)
try:
conn.shutdown(socket.SHUT_RD)
except:
pass
if not once and conn in self.map: # use the `once` param to avoid infinite loop
# if a socket is rd_shutdowned, then it's
# pair should be wr_shutdown.
self._wr_shutdown(self.map[conn], True)
if self.map.get(conn) not in self.conn_rd:
# if both two connection pair was rd-shutdowned,
# this pair sockets are regarded to be completed
# so we gonna close them
self._terminate(conn)
Example #5
| Source File: ping.py From network-lib with MIT License | 6 votes |
|
def tcp(host, port=80, count=1, timeout=1):
result = []
for _ in range(count):
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.settimeout(timeout)
start_time = time.time()
try:
s.connect((host, port))
s.shutdown(socket.SHUT_RD)
stop_time = time.time()
result.append(round(1000 * (stop_time - start_time), 2))
except socket.timeout:
result.append(-1)
except OSError as e:
print("OS Error:", e)
result.append(-1)
finally:
s.close()
return result
Example #6
| Source File: socket.py From trinity with MIT License | 6 votes |
|
def _close_socket_on_stop(self, sock: socket.socket) -> None:
# This function runs in the background waiting for the `stop` Event to
# be set at which point it closes the socket, causing the server to
# shutdown. This allows the server threads to be cleanly closed on
# demand.
self.wait_stopped()
try:
sock.shutdown(socket.SHUT_RD)
except OSError as e:
# on mac OS this can result in the following error:
# OSError: [Errno 57] Socket is not connected
if e.errno != errno.ENOTCONN:
raise
sock.close()
Example #7
| Source File: wsgi_server_test.py From python-compat-runtime with Apache License 2.0 | 5 votes |
|
def test_shutdown_connection(self):
class DummyObect(object):
pass
connection = DummyObect()
connection.rfile = DummyObect()
connection.rfile.closed = False
connection.socket = self.mox.CreateMockAnything()
connection.socket.shutdown(socket.SHUT_RD)
self.mox.ReplayAll()
self.thread_pool._shutdown_connection(connection)
self.mox.VerifyAll()
Example #8
| Source File: simplesock.py From nclib with MIT License | 5 votes |
|
def shutdown(self, how):
if how == socket.SHUT_RDWR:
self.close()
elif how == socket.SHUT_RD:
if not self.can_send:
self.close()
elif how == socket.SHUT_WR:
if not self.can_recv:
self.close()
else:
raise ValueError("invalid shutdown `how`", how)
Example #9
| Source File: threadpool.py From cheroot with BSD 3-Clause "New" or "Revised" License | 5 votes |
|
def _force_close(conn):
if conn.rfile.closed:
return
try:
try:
conn.socket.shutdown(socket.SHUT_RD)
except TypeError:
# pyOpenSSL sockets don't take an arg
conn.socket.shutdown()
except OSError:
# shutdown sometimes fails (race with 'closed' check?)
# ref #238
pass
Example #10
| Source File: connection.py From puppeteer with GNU General Public License v3.0 | 5 votes |
|
def shutdown(self, what):
if self.s is not None:
self.s.shutdown(what)
elif self.p is not None:
if what == socket.SHUT_WR:
self.p.stdin.close()
if what == socket.SHUT_RD:
self.p.stdout.close()
Example #11
| Source File: common_func.py From shootback with MIT License | 5 votes |
|
def _rd_shutdown(self, conn, once=False):
"""action when connection should be read-shutdown
:type conn: socket.socket
"""
if conn in self.conn_rd:
self.conn_rd.remove(conn)
if self.sel:
self._sel_disable_event(conn, EVENT_READ)
# if conn in self.send_buff:
# del self.send_buff[conn]
try:
conn.shutdown(socket.SHUT_RD)
except:
pass
if not once and conn in self.map: # use the `once` param to avoid infinite loop
# if a socket is rd_shutdowned, then it's
# pair should be wr_shutdown.
self._wr_shutdown(self.map[conn], True)
if self.map.get(conn) not in self.conn_rd:
# if both two connection pair was rd-shutdowned,
# this pair sockets are regarded to be completed
# so we gonna close them
self._terminate(conn)
Example #12
| Source File: pydevd_comm.py From filmkodi with Apache License 2.0 | 5 votes |
|
def do_kill_pydev_thread(self):
#We must close the socket so that it doesn't stay halted there.
self.killReceived = True
try:
self.sock.shutdown(SHUT_RD) #shutdown the socket for read
except:
#just ignore that
pass
Example #13
| Source File: __init__.py From bokken with GNU General Public License v2.0 | 5 votes |
|
def stop(self, timeout=5):
# Must shut down threads here so the code that calls
# this method can know when all threads are stopped.
for worker in self._threads:
self._queue.put(_SHUTDOWNREQUEST)
# Don't join currentThread (when stop is called inside a request).
current = threading.currentThread()
if timeout and timeout >= 0:
endtime = time.time() + timeout
while self._threads:
worker = self._threads.pop()
if worker is not current and worker.isAlive():
try:
if timeout is None or timeout < 0:
worker.join()
else:
remaining_time = endtime - time.time()
if remaining_time > 0:
worker.join(remaining_time)
if worker.isAlive():
# We exhausted the timeout.
# Forcibly shut down the socket.
c = worker.conn
if c and not c.rfile.closed:
try:
c.socket.shutdown(socket.SHUT_RD)
except TypeError:
# pyOpenSSL sockets don't take an arg
c.socket.shutdown()
worker.join()
except (AssertionError,
# Ignore repeated Ctrl-C.
# See http://www.cherrypy.org/ticket/691.
KeyboardInterrupt), exc1:
pass
Example #14
| Source File: __init__.py From cosa-nostra with GNU General Public License v3.0 | 5 votes |
|
def stop(self, timeout=5):
# Must shut down threads here so the code that calls
# this method can know when all threads are stopped.
for worker in self._threads:
self._queue.put(_SHUTDOWNREQUEST)
# Don't join currentThread (when stop is called inside a request).
current = threading.currentThread()
if timeout and timeout >= 0:
endtime = time.time() + timeout
while self._threads:
worker = self._threads.pop()
if worker is not current and worker.isAlive():
try:
if timeout is None or timeout < 0:
worker.join()
else:
remaining_time = endtime - time.time()
if remaining_time > 0:
worker.join(remaining_time)
if worker.isAlive():
# We exhausted the timeout.
# Forcibly shut down the socket.
c = worker.conn
if c and not c.rfile.closed:
try:
c.socket.shutdown(socket.SHUT_RD)
except TypeError:
# pyOpenSSL sockets don't take an arg
c.socket.shutdown()
worker.join()
except (AssertionError,
# Ignore repeated Ctrl-C.
# See http://www.cherrypy.org/ticket/691.
KeyboardInterrupt), exc1:
pass
Example #15
| Source File: tcping.py From tcping with MIT License | 5 votes |
|
def shutdown(self):
self._s.shutdown(socket.SHUT_RD)
Example #16
| Source File: __init__.py From bazarr with GNU General Public License v3.0 | 5 votes |
|
def stop(self, timeout=5):
# Must shut down threads here so the code that calls
# this method can know when all threads are stopped.
for worker in self._threads:
self._queue.put(_SHUTDOWNREQUEST)
# Don't join currentThread (when stop is called inside a request).
current = threading.currentThread()
if timeout is not None and timeout >= 0:
endtime = time.time() + timeout
while self._threads:
worker = self._threads.pop()
if worker is not current and worker.isAlive():
try:
if timeout is None or timeout < 0:
worker.join()
else:
remaining_time = endtime - time.time()
if remaining_time > 0:
worker.join(remaining_time)
if worker.isAlive():
# We exhausted the timeout.
# Forcibly shut down the socket.
c = worker.conn
if c and not c.rfile.closed:
try:
c.socket.shutdown(socket.SHUT_RD)
except TypeError:
# pyOpenSSL sockets don't take an arg
c.socket.shutdown()
worker.join()
except (AssertionError,
# Ignore repeated Ctrl-C.
# See
# https://github.com/cherrypy/cherrypy/issues/691.
KeyboardInterrupt):
pass
Example #17
| Source File: threadpool.py From Tautulli with GNU General Public License v3.0 | 5 votes |
|
def _force_close(conn):
if conn.rfile.closed:
return
try:
try:
conn.socket.shutdown(socket.SHUT_RD)
except TypeError:
# pyOpenSSL sockets don't take an arg
conn.socket.shutdown()
except OSError:
# shutdown sometimes fails (race with 'closed' check?)
# ref #238
pass
Example #18
| Source File: wsgiserver2.py From moviegrabber with GNU General Public License v3.0 | 5 votes |
|
def stop(self, timeout=5):
# Must shut down threads here so the code that calls
# this method can know when all threads are stopped.
for worker in self._threads:
self._queue.put(_SHUTDOWNREQUEST)
# Don't join currentThread (when stop is called inside a request).
current = threading.currentThread()
if timeout and timeout >= 0:
endtime = time.time() + timeout
while self._threads:
worker = self._threads.pop()
if worker is not current and worker.isAlive():
try:
if timeout is None or timeout < 0:
worker.join()
else:
remaining_time = endtime - time.time()
if remaining_time > 0:
worker.join(remaining_time)
if worker.isAlive():
# We exhausted the timeout.
# Forcibly shut down the socket.
c = worker.conn
if c and not c.rfile.closed:
try:
c.socket.shutdown(socket.SHUT_RD)
except TypeError:
# pyOpenSSL sockets don't take an arg
c.socket.shutdown()
worker.join()
except (AssertionError,
# Ignore repeated Ctrl-C.
# See http://www.cherrypy.org/ticket/691.
KeyboardInterrupt):
pass
Example #19
| Source File: netcat.py From nclib with MIT License | 5 votes |
|
def shutdown_rd(self):
"""
Send a shutdown signal for reading - you may no longer read from this
socket.
"""
return self.shutdown(socket.SHUT_RD)
Example #20
| Source File: wsgi_server.py From python-compat-runtime with Apache License 2.0 | 5 votes |
|
def _shutdown_connection(connection):
if not connection.rfile.closed:
connection.socket.shutdown(socket.SHUT_RD)
Example #21
| Source File: wsgiserver2.py From opsbro with MIT License | 5 votes |
|
def stop(self, timeout=5):
# Must shut down threads here so the code that calls
# this method can know when all threads are stopped.
for worker in self._threads:
self._queue.put(_SHUTDOWNREQUEST)
# Don't join currentThread (when stop is called inside a request).
current = threading.currentThread()
if timeout and timeout >= 0:
endtime = time.time() + timeout
while self._threads:
worker = self._threads.pop()
if worker is not current and worker.isAlive():
try:
if timeout is None or timeout < 0:
worker.join()
else:
remaining_time = endtime - time.time()
if remaining_time > 0:
worker.join(remaining_time)
if worker.isAlive():
# We exhausted the timeout.
# Forcibly shut down the socket.
c = worker.conn
if c and not c.rfile.closed:
try:
c.socket.shutdown(socket.SHUT_RD)
except TypeError:
# pyOpenSSL sockets don't take an arg
c.socket.shutdown()
worker.join()
except (AssertionError,
# Ignore repeated Ctrl-C.
# See
# https://bitbucket.org/cherrypy/cherrypy/issue/691.
KeyboardInterrupt):
pass
Example #22
| Source File: wsgiserver3.py From opsbro with MIT License | 5 votes |
|
def stop(self, timeout=5):
# Must shut down threads here so the code that calls
# this method can know when all threads are stopped.
for worker in self._threads:
self._queue.put(_SHUTDOWNREQUEST)
# Don't join currentThread (when stop is called inside a request).
current = threading.currentThread()
if timeout and timeout >= 0:
endtime = time.time() + timeout
while self._threads:
worker = self._threads.pop()
if worker is not current and worker.isAlive():
try:
if timeout is None or timeout < 0:
worker.join()
else:
remaining_time = endtime - time.time()
if remaining_time > 0:
worker.join(remaining_time)
if worker.isAlive():
# We exhausted the timeout.
# Forcibly shut down the socket.
c = worker.conn
if c and not c.rfile.closed:
try:
c.socket.shutdown(socket.SHUT_RD)
except TypeError:
# pyOpenSSL sockets don't take an arg
c.socket.shutdown()
worker.join()
except (AssertionError,
# Ignore repeated Ctrl-C.
# See
# https://bitbucket.org/cherrypy/cherrypy/issue/691.
KeyboardInterrupt):
pass
Example #23
| Source File: tcpping.py From scylla with Apache License 2.0 | 5 votes |
|
def shutdown(self):
self._s.shutdown(socket.SHUT_RD)
Example #24
| Source File: ResultManager.py From Panda-Sandbox with MIT License | 5 votes |
|
def cancel(self):
"""Cancel this context; gevent might complain about this with an
exception later on."""
try:
self.sock.shutdown(socket.SHUT_RD)
except socket.error:
pass
Example #25
| Source File: redirect.py From pythem with GNU General Public License v3.0 | 5 votes |
|
def server(self):
print "[+] Redirect with script injection initialized."
self.dnsspoof.start(None, "Inject")
server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
server_address = (self.host, self.port)
print '[+] Injection URL - http://{}:{}'.format(self.host, self.port)
server.bind(server_address)
server.listen(1)
for i in range(0, 2):
if i >= 1:
domain = self.dnsspoof.getdomain()
domain = domain[:-1]
print "[+] Target was requesting: {}".format(domain)
self.dnsspoof.stop()
try:
connection, client_address = server.accept()
redirect = self.response + """<body> <meta http-equiv="refresh" content="0; URL='http://{}"/> </body>""".format(
domain)
connection.send("%s" % redirect)
print "[+] Script Injected on: ", client_address
connection.shutdown(socket.SHUT_WR | socket.SHUT_RD)
connection.close()
except KeyboardInterrupt:
server.close()
try:
connection, client_address = server.accept()
connection.send("%s" % self.response)
connection.shutdown(socket.SHUT_WR | socket.SHUT_RD)
connection.close()
except KeyboardInterrupt:
server.close()
Example #26
| Source File: wsgiserver2.py From Hatkey with GNU General Public License v3.0 | 5 votes |
|
def stop(self, timeout=5):
# Must shut down threads here so the code that calls
# this method can know when all threads are stopped.
for worker in self._threads:
self._queue.put(_SHUTDOWNREQUEST)
# Don't join currentThread (when stop is called inside a request).
current = threading.currentThread()
if timeout and timeout >= 0:
endtime = time.time() + timeout
while self._threads:
worker = self._threads.pop()
if worker is not current and worker.isAlive():
try:
if timeout is None or timeout < 0:
worker.join()
else:
remaining_time = endtime - time.time()
if remaining_time > 0:
worker.join(remaining_time)
if worker.isAlive():
# We exhausted the timeout.
# Forcibly shut down the socket.
c = worker.conn
if c and not c.rfile.closed:
try:
c.socket.shutdown(socket.SHUT_RD)
except TypeError:
# pyOpenSSL sockets don't take an arg
c.socket.shutdown()
worker.join()
except (AssertionError,
# Ignore repeated Ctrl-C.
# See
# https://github.com/cherrypy/cherrypy/issues/691.
KeyboardInterrupt):
pass
Example #27
| Source File: wsgiserver3.py From Hatkey with GNU General Public License v3.0 | 5 votes |
|
def stop(self, timeout=5):
# Must shut down threads here so the code that calls
# this method can know when all threads are stopped.
for worker in self._threads:
self._queue.put(_SHUTDOWNREQUEST)
# Don't join currentThread (when stop is called inside a request).
current = threading.currentThread()
if timeout and timeout >= 0:
endtime = time.time() + timeout
while self._threads:
worker = self._threads.pop()
if worker is not current and worker.isAlive():
try:
if timeout is None or timeout < 0:
worker.join()
else:
remaining_time = endtime - time.time()
if remaining_time > 0:
worker.join(remaining_time)
if worker.isAlive():
# We exhausted the timeout.
# Forcibly shut down the socket.
c = worker.conn
if c and not c.rfile.closed:
try:
c.socket.shutdown(socket.SHUT_RD)
except TypeError:
# pyOpenSSL sockets don't take an arg
c.socket.shutdown()
worker.join()
except (AssertionError,
# Ignore repeated Ctrl-C.
# See
# https://github.com/cherrypy/cherrypy/issues/691.
KeyboardInterrupt):
pass
Example #28
| Source File: worker.py From HTTPWookiee with GNU General Public License v3.0 | 5 votes |
|
def close_socket_for_read(self):
"""Close the server-client socket for reads incoming from client.
We do not completly close the socket right now to allow late reads
in the client side. But this socket will soon be closed.
"""
if self._sock is not None:
self.outmsg("Closing socket for reads")
try:
self._sock.shutdown(socket.SHUT_RD)
except Exception:
# already closed
pass
self._sock_accept_reads = False
Example #29
| Source File: api.py From qubes-core-admin with GNU Lesser General Public License v2.1 | 5 votes |
|
def test_005_event(self):
self.writer.write(b'mgmt.event+arg dom0 name dom0\0payload')
self.writer.write_eof()
with self.assertNotRaises(asyncio.TimeoutError):
response = self.loop.run_until_complete(
asyncio.wait_for(self.reader.readuntil(b'\0\0'), 1))
self.assertEqual(response, b"1\0subject\0event\0payload\0payload\0\0")
# this will trigger connection_lost, but only when next event is sent
self.sock_client.shutdown(socket.SHUT_RD)
# check if event-producing method is interrupted
with self.assertNotRaises(asyncio.TimeoutError):
self.loop.run_until_complete(
asyncio.wait_for(self.protocol.mgmt.task, 1))
Example #30
| Source File: __init__.py From nightmare with GNU General Public License v2.0 | 5 votes |
|
def stop(self, timeout=5):
# Must shut down threads here so the code that calls
# this method can know when all threads are stopped.
for worker in self._threads:
self._queue.put(_SHUTDOWNREQUEST)
# Don't join currentThread (when stop is called inside a request).
current = threading.currentThread()
if timeout and timeout >= 0:
endtime = time.time() + timeout
while self._threads:
worker = self._threads.pop()
if worker is not current and worker.isAlive():
try:
if timeout is None or timeout < 0:
worker.join()
else:
remaining_time = endtime - time.time()
if remaining_time > 0:
worker.join(remaining_time)
if worker.isAlive():
# We exhausted the timeout.
# Forcibly shut down the socket.
c = worker.conn
if c and not c.rfile.closed:
try:
c.socket.shutdown(socket.SHUT_RD)
except TypeError:
# pyOpenSSL sockets don't take an arg
c.socket.shutdown()
worker.join()
except (AssertionError,
# Ignore repeated Ctrl-C.
# See http://www.cherrypy.org/ticket/691.
KeyboardInterrupt), exc1:
pass
