def test_connect_ex_error(self):
with support.transient_internet(REMOTE_HOST):
s = ssl.wrap_socket(socket.socket(socket.AF_INET),
cert_reqs=ssl.CERT_REQUIRED,
ca_certs=REMOTE_ROOT_CERT)
try:
rc = s.connect_ex((REMOTE_HOST, 444))
# Issue #19919: Windows machines or VMs hosted on Windows
# machines sometimes return EWOULDBLOCK.
errors = (
errno.ECONNREFUSED, errno.EHOSTUNREACH, errno.ETIMEDOUT,
errno.EWOULDBLOCK,
)
self.assertIn(rc, errors)
finally:
s.close()
python类EHOSTUNREACH的实例源码
def test_connect_ex_error(self):
with support.transient_internet(REMOTE_HOST):
s = ssl.wrap_socket(socket.socket(socket.AF_INET),
cert_reqs=ssl.CERT_REQUIRED,
ca_certs=REMOTE_ROOT_CERT)
try:
rc = s.connect_ex((REMOTE_HOST, 444))
# Issue #19919: Windows machines or VMs hosted on Windows
# machines sometimes return EWOULDBLOCK.
errors = (
errno.ECONNREFUSED, errno.EHOSTUNREACH, errno.ETIMEDOUT,
errno.EWOULDBLOCK,
)
self.assertIn(rc, errors)
finally:
s.close()
def test_connect_ex_error(self):
with support.transient_internet(REMOTE_HOST):
s = ssl.wrap_socket(socket.socket(socket.AF_INET),
cert_reqs=ssl.CERT_REQUIRED,
ca_certs=REMOTE_ROOT_CERT)
try:
rc = s.connect_ex((REMOTE_HOST, 444))
# Issue #19919: Windows machines or VMs hosted on Windows
# machines sometimes return EWOULDBLOCK.
errors = (
errno.ECONNREFUSED, errno.EHOSTUNREACH, errno.ETIMEDOUT,
errno.EWOULDBLOCK,
)
self.assertIn(rc, errors)
finally:
s.close()
def __handle_socket_error(self, exception):
log.debug("Request failed with %s" % exception)
if exception.errno in (errno.ECONNREFUSED, errno.EHOSTUNREACH):
# if NN is down or machine is not available, pass it:
self.namenode.next() # Failover and retry until self.max_failovers was reached
elif isinstance(exception, socket.timeout):
self.namenode.next() # Failover and retry until self.max_failovers was reached
else:
raise
def test_connect_timeout(self):
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.settimeout(0.1)
gs = greenio.GreenSocket(s)
try:
expect_socket_timeout(gs.connect, ('192.0.2.1', 80))
except socket.error as e:
# unreachable is also a valid outcome
if not get_errno(e) in (errno.EHOSTUNREACH, errno.ENETUNREACH):
raise
def test_connect_ex_timeout(self):
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.settimeout(0.1)
gs = greenio.GreenSocket(s)
e = gs.connect_ex(('192.0.2.1', 80))
if e not in (errno.EHOSTUNREACH, errno.ENETUNREACH):
self.assertEqual(e, errno.EAGAIN)
def test__wait_for_port_with_unsupported_errors(self, time_sleep_mock, socket_mock):
# GIVEN
docker_container = DockerContainer(
image='alpine',
wait_for_port=1234,
)
docker_container._client = mock.MagicMock()
docker_container._client.containers.get.return_value.attrs = dict(
NetworkSettings=dict(IPAddress='172.10.0.2')
)
docker_container._container = mock.MagicMock(id='c5f0cad13259')
docker_container._container.logs.return_value = b'\n'.join([
b'some container error ...',
b'container failed to start'
])
socket_mock.return_value.connect_ex.side_effect = [1, 1, errno.EHOSTUNREACH]
# WHEN
with self.assertRaises(DockerContainerError) as cm:
docker_container._wait_for_port()
# THEN
expected_message = '\n'.join([
'[alpine] Host 172.10.0.2 cannot be reach. The container may exit abnormally. Container logs :',
'some container error ...',
'container failed to start'
])
self.assertEquals(str(cm.exception), expected_message, 'Message should be explicit: %s' % expected_message)
time_sleep_mock.assert_called()
socket_mock.assert_called_with(socket.AF_INET, socket.SOCK_STREAM)
connect_ex_mock = socket_mock.return_value.connect_ex
connect_ex_mock.assert_called_with(('172.10.0.2', 1234))
docker_container._container.logs.assert_called_once_with(stream=False)
self.assertEqual(connect_ex_mock.call_count, 3, 'Should have been called 3 times instead of {call_nb}'.format(
call_nb=connect_ex_mock.call_count
))
def _wait_for_port(self):
wait_port, image, res = self.p('wait_for_port'), self.p('image'), 1
if wait_port:
container_id = self._container.id
container_info = self._client.containers.get(container_id)
ip_address = container_info.attrs['NetworkSettings']['IPAddress']
unsupported_errors = [
(errno.EHOSTUNREACH,
'[{image}] Host {ip} cannot be reach. The container may exit abnormally. Container logs :\n{logs}')
]
with contextlib.closing(socket.socket(socket.AF_INET, socket.SOCK_STREAM)) as sock:
while res != 0:
res = sock.connect_ex((ip_address, wait_port))
logger.debug(
'[%s] Waiting for port %d to respond (code:%d => %s).',
image, wait_port, res, errorcode.get(res, '--')
)
unsupported_error = next((e[1] for e in unsupported_errors if e[0] == res), None)
if unsupported_error:
raise DockerContainerError(unsupported_error.format(
image=image,
port=wait_port,
signal=errorcode.get(res, '--'),
ip=ip_address,
logs=self._container.logs(stream=False).decode('utf-8')
))
time.sleep(0.1 if res != 0 else 0)
logger.debug('[%s] Port %d is now responding.', image, wait_port)
def GetVersion(x):
verLoc = 19
IP = "10.0.0." + str(x)
switch = Server( "https://" + ScriptUser + ":" + ScriptPass + "@" + IP + "/command-api" )
# Results in Host Unreach never happening, but [ . ] means same thing
# without waiting
socket.setdefaulttimeout(3)
try:
response = switch.runCmds( 1, [ "show version" ] )
except socket.error,ERR :
ErrorCode = ERR[0]
if ErrorCode == errno.ECONNREFUSED:
win.addstr(x, verLoc -6, " [ Err " + str(ErrorCode) + ": No eAPI ] ")
refresh()
elif ErrorCode == errno.EHOSTUNREACH:
# Never hit with lower socket timeout
win.addstr(x, verLoc, "Err " + str(ErrorCode) + ": Pwr off or Aboot ] ")
refresh()
elif ErrorCode == errno.ECONNRESET:
win.addstr(x, verLoc, "Err " + str(ErrorCode) + ": Con RST ] ")
refresh()
else:
win.addstr(x, verLoc, response[0]["version"] + " ]")
memTotal = response[0]["memTotal"]
memFree = response[0]["memFree"]
percentUsed = 100 - round((float(memFree) / float(memTotal)) * 100, 1)
win.addstr(x, verLoc+24, str(percentUsed) + "% ]" )
refresh()
def main():
global HOST, PORT, EOF, MAXTRIES
global s, tries, loops
try:
s.connect((HOST, PORT))
while True:
# Measure timing using GPIO4
risetime = RCtime(4)
# Send to the connected socket
# (as we're using UDP, we must
# send separate messages)
s.sendall('foo %s%s' % (loops, EOF))
s.sendall('bar %s%s' % (risetime, EOF))
# Advance counter
loops = loops + 1
except socket.error as err:
errcode = err[0]
if errcode==errno.ECONNREFUSED:
print 'Connection refused by host!'
elif errcode==errno.ENETDOWN:
print 'No network connection!'
elif errcode==errno.ENETUNREACH:
print 'Network unreachable!'
elif errcode==errno.ENETRESET:
print 'Network dropped connection!'
elif errcode==errno.ECONNRESET:
print 'Connection reset by peer!'
elif errcode==errno.EHOSTDOWN:
print 'Host is down!'
elif errcode==errno.EHOSTUNREACH:
print 'No route to host!'
else:
print 'Caught: %s!' % err
if tries >= MAXTRIES:
GPIO.cleanup()
s.close()
print 'No connection. Exiting.'
else:
print 'Tried %i of %i times.\nWaiting %is...' % (tries, MAXTRIES, tries/10)
time.sleep(tries/10)
tries = tries + 1
main()
except KeyboardInterrupt:
GPIO.cleanup()
s.close()
print '%i loops' % loops
def BaselineEOS(switchNumber):
location = 28
IP = "10.0.0." + str(switchNumber)
#print "Switch " + str(switchNumber).zfill(2) + ": ",
#Connect to Switch via eAPI
target = "https://" + ScriptUser + ":" + ScriptPass + "@" + IP + "/command-api"
switch = jsonrpclib.Server( target )
# capture Connection problem messages
# Map of erronos is here: http://www.python.org/doc//current/library/errno.html
try:
response = switch.runCmds( 1,
[ "enable" ,
"configure",
"delete EOS*.swi",
"copy " + FileServer + EOSVer + " flash:",
"boot system flash:" + EOSVer,
"write erase now",
"reload now"
], "text")
except KeyboardInterrupt:
print "Caught Keyboard Interrupt - Exiting"
sys.exit()
except socket.error,ERR :
# Socket Errors
ErrorCode = ERR[0]
if ErrorCode == errno.ECONNREFUSED:
win.addstr(switchNumber, location -15, " [ Err " + str(ErrorCode) + ": No eAPI ] ")
refresh()
elif ErrorCode == errno.EHOSTUNREACH:
# Never hit with lower socket timeout
win.addstr(switchNumber, location -15, " [ Err " + str(ErrorCode) + ": Pwr off | Aboot ] ")
refresh()
elif ErrorCode == errno.ECONNRESET:
win.addstr(switchNumber, location -15, " [ Err " + str(ErrorCode) + ": Con RST ] ")
refresh()
except jsonrpclib.ProtocolError:
# Capture eAPI errors
result = jsonrpclib.loads( jsonrpclib.history.response )
print result["error"]["message"]
for error in result["error"]["data"][-1]["errors"]:
print error
except (xmlrpclib.ProtocolError, xmlrpclib.ResponseError), errormsg:
# Capture XML Error (usually bad password)
message = str(errormsg)
message = message.replace(ScriptUser, "user")
message = message.replace(ScriptPass, "pass")
print message
else:
win.addstr(switchNumber, location, "[ Done ]")
refresh()
def _make_request( self, loc, headers, data = None, retry = True ):
last_e = None
utserver_retry = False
retries = 0
max_retries = self._retry_max if retry else 1
try:
while retries < max_retries or utserver_retry:
try:
self._request.data = data
self._connection.request( self._request.get_method( ), self._request.selector + loc, self._request.data, headers )
resp = self._connection.getresponse( )
if resp.status == 400:
last_e = utorrent.uTorrentError( resp.read( ).decode( "utf8" ).strip( ) )
# if uTorrent server alpha is bound to the same port as WebUI then it will respond with "invalid request" to the first request in the connection
# apparently this is no longer the case, TODO: remove this hack
if ( not self._utorrent or type( self._utorrent ) == utorrent.uTorrent.LinuxServer ) and not utserver_retry:
utserver_retry = True
continue
raise last_e
elif resp.status == 404 or resp.status == 401:
raise utorrent.uTorrentError( "Request {}: {}".format( loc, resp.reason ) )
elif resp.status != 200 and resp.status != 206:
raise utorrent.uTorrentError( "{}: {}".format( resp.reason, resp.status ) )
self._cookies.extract_cookies( resp, self._request )
if len( self._cookies ) > 0:
self._request.add_header( "Cookie", "; ".join(
["{}={}".format( utorrent._url_quote( c.name ), utorrent._url_quote( c.value ) ) for c in self._cookies] ) )
return resp
# retry when utorrent returns bad data
except ( http.client.CannotSendRequest, http.client.BadStatusLine ) as e:
last_e = e
self._connection.close( )
# name resolution failed
except socket.gaierror as e:
raise utorrent.uTorrentError( e.strerror )
# socket errors
except socket.error as e:
# retry on timeout
if str( e ) == "timed out": # some peculiar handling for timeout error
last_e = utorrent.uTorrentError( "Timeout after {} tries".format( max_retries ) )
self._connection.close( )
# retry after pause on specific windows errors
elif e.errno == 10053 or e.errno == 10054:
# Windows specific socket errors:
# 10053 - An established connection was aborted by the software in your host machine
# 10054 - An existing connection was forcibly closed by the remote host
last_e = e
self._connection.close( )
time.sleep( 2 )
elif e.errno == errno.ECONNREFUSED or e.errno == errno.ECONNRESET or errno == errno.EHOSTUNREACH:
raise utorrent.uTorrentError( e.strerror )
else:
raise e
retries += 1
if last_e:
raise last_e
except Exception as e:
self._connection.close( )
raise e
return None
