Timed out.

Traceback

/usr/local/lib/python3.7/unittest/case.py in testPartExecutor (arguments ▶)
self : _Outcome
<unittest.case._Outcome object at 0x7fe3fd9f9450>
test_case : Volumes
test_resizing_instance_standard_system_stopped_bigsize (c2tests.ec2.volumes.Volumes)
isTest : bool
True
```
    @contextlib.contextmanager
    def testPartExecutor(self, test_case, isTest=False):
        old_success = self.success
        self.success = True
        try:
            yield
        except KeyboardInterrupt:
            raise
        except SkipTest as e:
            self.success = False
```
Locals ▶
exc_info : NoneType
None
old_success : bool
True
Globals ▶
__unittest : bool
True
_subtest_msg_sentinel : object
<object object at 0x7fe415310fc0>
DIFF_OMITTED : str
Diff is %s characters long. Set self.maxDiff to None to see it.
/usr/local/lib/python3.7/unittest/case.py in run (arguments ▶)
self : Volumes
test_resizing_instance_standard_system_stopped_bigsize (c2tests.ec2.volumes.Volumes)
result : DiagnosticsTestResult
<xmlrunner.extra.diagnosticstestrunner.DiagnosticsTestResult run=1 errors=0 failures=0>
```
            with outcome.testPartExecutor(self):
                self.setUp()
            if outcome.success:
                outcome.expecting_failure = expecting_failure
                with outcome.testPartExecutor(self, isTest=True):
                    testMethod()
                outcome.expecting_failure = False
                with outcome.testPartExecutor(self):
                    self.tearDown()
```
Locals ▶
expecting_failure : bool
False
expecting_failure_class : bool
False
expecting_failure_method : bool
False
orig_result : DiagnosticsTestResult
<xmlrunner.extra.diagnosticstestrunner.DiagnosticsTestResult run=1 errors=0 failures=0>
outcome : _Outcome
<unittest.case._Outcome object at 0x7fe3fd9f9450>
testMethod : method
<bound method Volumes.test_resizing_instance of <c2tests.ec2.volumes.Volumes testMethod=test_resizing_instance_standard_system_stopped_bigsize>>
Globals ▶
__unittest : bool
True
_subtest_msg_sentinel : object
<object object at 0x7fe415310fc0>
DIFF_OMITTED : str
Diff is %s characters long. Set self.maxDiff to None to see it.

/root/c2tests/.venv/lib/python3.7/site-packages/parameterized/parameterized.py in standalone_func (arguments ▶)

*a : tuple: (<c2tests.ec2.volumes.Volumes testMethod=test_resizing_instance_standard_system_stopped_bigsize>,)

    @classmethod
    def param_as_standalone_func(cls, p, func, name):
        @wraps(func)
        def standalone_func(*a):
            return func(*(a + p.args), **p.kwargs)
        standalone_func.__name__ = name
        # place_as is used by py.test to determine what source file should be
        # used for this test.

Locals ▶

p : param: param(*('standard', 'system', 'stopped', 'bigsize'), **{})

Globals ▶

PY2 : bool: False
PY3 : bool: True
string_types : tuple: (<class 'str'>,)

/root/c2tests/.venv/lib/python3.7/site-packages/c2tests/ec2/volumes.py in test_resizing_instance (arguments ▶)
self : Volumes
test_resizing_instance_standard_system_stopped_bigsize (c2tests.ec2.volumes.Volumes)
volume_type : str
standard
device : str
system
state : str
stopped
size : str
bigsize
```
        }
        driver = utils.VolumeDriverFactory.get_driver(volume_type)
        new_good_size = driver.max_size if size == "bigsize" else driver.next_size
        self._resizing_instance(volume_type, new_good_size, **kwargs)
    @common.parametrize_with_iops_provisioned_volume_types()
    def test_iops_changing(self, volume_type):
        volume = self.create_volume(volume_type=volume_type)
```
Locals ▶
driver : VolumeDriverStandard
<c2tests.utils.VolumeDriverStandard object at 0x7fe3fd558390>
kwargs : dict
{'system': True, 'stopped': True, 'deallocated': False}
new_good_size : int
101
Globals ▶
randint : method
<bound method Random.randint of <random.Random object at 0x10a09b0>>

/root/c2tests/.venv/lib/python3.7/site-packages/c2tests/ec2/volumes.py in _resizing_instance (arguments ▶)

self : Volumes: test_resizing_instance_standard_system_stopped_bigsize (c2tests.ec2.volumes.Volumes)
volume_type : str: standard
new_good_size : int: 101
system : bool: True
stopped : bool: True
deallocated : bool: False

    def _resizing_instance(self, volume_type, new_good_size, system=True,
                           stopped=False, deallocated=False):
        """Helper-proxy for resizing volume attached to instance"""
        instance, volume, key_path = self._operate_instance(
            volume_type, system=system, stopped=stopped, deallocated=deallocated)
        instance.update()
        ins_state_before_resize = instance.state
        self._resizing(volume, new_good_size)

Locals ▶

Globals ▶

randint : method: <bound method Random.randint of <random.Random object at 0x10a09b0>>

/root/c2tests/.venv/lib/python3.7/site-packages/c2tests/ec2/volumes.py in _operate_instance (arguments ▶)

self : Volumes: test_resizing_instance_standard_system_stopped_bigsize (c2tests.ec2.volumes.Volumes)
volume_type : str: standard
system : bool: True
stopped : bool: True
deallocated : bool: False

                          stopped=False, deallocated=False):
        """Create and prepare instance for testing its volume."""
        key_path, instance = self.run_instance_from_template(volume_type=volume_type)
        utils.wait_long(
            lambda: utils.ssh_test(instance.ip_address, key_path) == instance.id)
        if system:
            device = instance.block_device_mapping[constants.TYPE_DISK + "1"]
            volume = self.get_all_volumes(volume_ids=[device.volume_id])[0]

Locals ▶

instance : Instance: Instance:i-42B08DA0
key_path : str: /tmp/tmpc48km_ye.pub

Globals ▶

randint : method: <bound method Random.randint of <random.Random object at 0x10a09b0>>

/root/c2tests/.venv/lib/python3.7/site-packages/c2tests/utils.py in wait_long (arguments ▶)
func : function
<function Volumes._operate_instance.<locals>.<lambda> at 0x7fe3fd784290>
*args : tuple
()
**kwargs : dict
{}
```
def wait_long(func, *args, **kwargs):
    """Fail unless func return success within the long timeout"""
    return wait(5 * constants.MINUTE_SECONDS, func, *args, **kwargs)
def wait_long_enough(func, *args, **kwargs):
    """Fail unless func return success within the enough long timeout."""
```
Locals ▶
Globals ▶
_DD : str
/bin/dd
_QEMU_IMG : str
/usr/bin/qemu-img
LOG : RootLogger
<RootLogger root (DEBUG)>
md5 : builtin_function_or_method
<built-in function openssl_md5>
RULES : list
[{'cidr_ip': '0.0.0.0/0', 'ip_protocol': 'tcp', 'from_port': '22', 'to_port': '22'}, {'cidr_ip': '0.0.0.0/0', 'ip_protocol': 'icmp', 'from_port': '-1', 'to_port': '-1'}]
/root/c2tests/.venv/lib/python3.7/site-packages/c2tests/utils.py in wait (arguments ▶)
timeout : int
300
func : function
<function Volumes._operate_instance.<locals>.<lambda> at 0x7fe3fd784290>
*args : tuple
()
**kwargs : dict
{}
```
        result = func(*args, **kwargs)
        if result:
            return result
        time.sleep(min(timeout, 0.1))
    raise exceptions.TimeoutException()
def wait_short(func, *args, **kwargs):
    """Fail unless func return success within the timeout"""
```
Locals ▶
endtime : float
1708641174.0175774
result : bool
False
Globals ▶
_DD : str
/bin/dd
_QEMU_IMG : str
/usr/bin/qemu-img
LOG : RootLogger
<RootLogger root (DEBUG)>
md5 : builtin_function_or_method
<built-in function openssl_md5>
RULES : list
[{'cidr_ip': '0.0.0.0/0', 'ip_protocol': 'tcp', 'from_port': '22', 'to_port': '22'}, {'cidr_ip': '0.0.0.0/0', 'ip_protocol': 'icmp', 'from_port': '-1', 'to_port': '-1'}]

Traceback

Environment