def test_do_spawn_and_publish_publish_error(self, mc_spawn_instance,
mc_grc):
mc_spawn_instance.return_value = {"result": "foobar"}
mc_grc.side_effect = ConnectionError()
do_spawn_and_publish(self.opts, self.spawn_pb_path, self.group)
assert mc_grc.called
def get_connection(self, command_name, *keys, **options):
"""Get a connection, blocking for ``self.timeout`` until a connection
is available from the pool.
If the connection returned is ``None`` then creates a new connection.
Because we use a last-in first-out queue, the existing connections
(having been returned to the pool after the initial ``None`` values
were added) will be returned before ``None`` values. This means we only
create new connections when we need to, i.e.: the actual number of
connections will only increase in response to demand.
"""
self._checkpid()
# Try and get a connection from the pool. If one isn't available within
# self.timeout then raise a `ConnectionError`.
connection = None
try:
connection = self._master_pool.get(block=True,
timeout=self.timeout)
logging.debug("Using connection from pool: %r", connection)
except Empty:
if self._current_master:
raise ConnectionError("No connection available")
# If the ``connection`` is actually ``None`` then that's a cue to make
# a new connection to add to the pool.
if connection is None:
logging.debug("Create new connection")
connection = self.make_connection()
return connection
def make_connection(self):
"""Create a new connection"""
if self._created_connections[self._pattern_idx] >= self.max_connections_per_pattern:
raise ConnectionError("Too many connections")
self._created_connections[self._pattern_idx] += 1
conn = self.connection_class(**self.patterns[self._pattern_idx])
conn._pattern_idx = self._pattern_idx
return conn
def test_do_spawn_and_publish_error(self, mc_run_ans, mc_grc):
mc_grc.side_effect = ConnectionError()
terminate_vm(self.opts, self.terminate_pb_path, 0, self.vm_name, self.vm_ip)
assert mc_run_ans.called
expected_cmd = '-c ssh {} --extra-vars=\'{{"copr_task": {{"vm_name": "{}", "ip": "{}"}}}}\''.format(
self.terminate_pb_path, self.vm_name, self.vm_ip)
assert expected_cmd == mc_run_ans.call_args[:-1][0][0]
assert mc_grc.called
def test_check_health_pubsub_publish_error(self, mc_ans_runner, mc_grc):
mc_conn = MagicMock()
mc_ans_runner.return_value = mc_conn
mc_conn.run.return_value = {"contacted": [self.vm_ip]}
mc_grc.side_effect = ConnectionError()
# didn't raise exception
check_health(self.opts, self.vm_name, self.vm_ip)
assert mc_conn.run.called
assert mc_grc.called
def __init__(
self,
default_name: str,
cache_url: str,
**kwargs,
):
kwargs.setdefault('decode_responses', True)
super().__init__(
connection_pool=from_url(url=cache_url, **kwargs).connection_pool)
self.default_name = default_name
try:
self.ping()
except ConnectionError as exc:
raise ConnectionError(
f'Could not connect to Redis with URL: {cache_url}') from exc
def make_connection(self):
"Create a new connection"
if self._created_connections >= self.max_connections:
raise ConnectionError("Too many connections")
self._created_connections += 1
if self._current_master == None:
logger.debug("No master set - reconfiguratin")
self._configure()
host = self._current_master[0]
port = self._current_master[1]
logger.debug("Creating new connection to {}:{}".format(host, port))
return self.connection_class(host=host, port=port, **self.connection_kwargs)
def make_connection(self):
"""Create a new connection"""
if self._current_master is None:
logging.warning("No master set - reconfiguration")
self._reconfigure()
if not self._current_master:
raise ConnectionError("Can't connect to a master")
host = self._current_master[0]
port = self._current_master[1]
logging.info("Creating new connection to {0}:{1}".format(host, port))
connection = self.connection_class(host=host,
port=port,
**self.connection_kwargs)
self._connections.append(connection)
return connection
def get_redis_link(host, port, decode_responses=False):
if port == 7000:
raise ConnectionError('mock connection error for 7000')
return Redis(host=host, port=port, decode_responses=decode_responses)
def test_redis_connection_error(self, ping_error_mock):
""" Test a Bad Redis connection """
ping_error_mock.side_effect = ConnectionError()
self.assertRaises(ConnectionError, Pet.init_db)
self.assertIsNone(Pet.redis)
def get_redis_connection(self) -> Redis:
try:
self._conn = Redis(connection_pool=self.pool, socket_connect_timeout=1000)
except ConnectionError:
raise ConnectionError()