def get_security_group_rule(self,
security_group_rule_id,
resource_get_attempts=None,
raise_exception=False,
poll_interval=None):
"""
@summary: Shows information for a specified security group rule
@param security_group_rule_id: The UUID for the security group rule
@type security_group_rule_id: string
@param resource_get_attempts: number of API retries
@type resource_get_attempts: int
@param raise_exception: flag to raise an exception if the get
Security Group Rule was not as expected or to return None
@type raise_exception: bool
@param poll_interval: sleep time interval between API retries
@type poll_interval: int
@return: NetworkingResponse object with api response and failure list
@rtype: common.behaviors.NetworkingResponse
"""
poll_interval = poll_interval or self.config.api_poll_interval
resource_get_attempts = (resource_get_attempts
or self.config.api_retries)
result = NetworkingResponse()
err_msg = 'Security Group Rule Get failure'
for attempt in range(resource_get_attempts):
self._log.debug(
'Attempt {0} of {1} getting security group rule {2}'.format(
attempt + 1, resource_get_attempts,
security_group_rule_id))
resp = self.client.get_security_group_rule(
security_group_rule_id=security_group_rule_id)
resp_check = self.check_response(
resp=resp,
status_code=SecurityGroupsResponseCodes.
GET_SECURITY_GROUP_RULE,
label=security_group_rule_id,
message=err_msg)
result.response = resp
if not resp_check:
return result
# Failures will be an empty list if the get was successful the
# first time
result.failures.append(resp_check)
time.sleep(poll_interval)
else:
err_msg = (
'Unable to GET {0} security group rule after {1} attempts: '
'{2}').format(security_group_rule_id, resource_get_attempts,
result.failures)
self._log.error(err_msg)
if raise_exception:
raise ResourceGetException(err_msg)
return result
def get_network(self,
network_id,
resource_get_attempts=None,
raise_exception=False,
poll_interval=None):
"""
@summary: Shows and verifies a specified network
@param network_id: The UUID for the network
@type network_id: string
@param resource_get_attempts: number of API retries
@type resource_get_attempts: int
@param raise_exception: flag to raise an exception if the get
Network was not as expected or to return None
@type raise_exception: bool
@param poll_interval: sleep time interval between API retries
@type poll_interval: int
@return: NetworkingResponse object with api response and failure list
@rtype: common.behaviors.NetworkingResponse
"""
poll_interval = poll_interval or self.config.api_poll_interval
resource_get_attempts = (resource_get_attempts
or self.config.api_retries)
result = NetworkingResponse()
err_msg = 'Network Get failure'
for attempt in range(resource_get_attempts):
self._log.debug('Attempt {0} of {1} getting network {2}'.format(
attempt + 1, resource_get_attempts, network_id))
resp = self.client.get_network(network_id=network_id)
resp_check = self.check_response(
resp=resp,
status_code=NeutronResponseCodes.GET_NETWORK,
label=network_id,
message=err_msg)
result.response = resp
if not resp_check:
return result
# Failures will be an empty list if the get was successful the
# first time
result.failures.append(resp_check)
time.sleep(poll_interval)
else:
err_msg = ('Unable to GET {0} network after {1} attempts: '
'{2}').format(network_id, resource_get_attempts,
result.failures)
self._log.error(err_msg)
if raise_exception:
raise ResourceGetException(err_msg)
return result
def get_limits(self, page_reverse=None,
resource_get_attempts=None,
raise_exception=False, poll_interval=None):
"""
@summary: get rate limits
@param page_reverse: direction of the page
@type page_reverse: bool
@param resource_get_attempts: number of API retries
@type resource_get_attempts: int
@param raise_exception: flag to raise an exception if the get
limits call was not as expected or to return None
@type raise_exception: bool
@param poll_interval: sleep time interval between API retries
@type poll_interval: int
@return: NetworkingResponse object with api response and failure list
@rtype: common.behaviors.NetworkingResponse
"""
poll_interval = poll_interval or self.config.api_poll_interval
resource_get_attempts = (resource_get_attempts or
self.config.api_retries)
result = NetworkingResponse()
err_msg = 'Limits GET failure'
for attempt in range(resource_get_attempts):
self._log.debug(
'Attempt {0} of {1} with limits GET'.format(
attempt + 1,
resource_get_attempts))
resp = self.client.get_limits(page_reverse=page_reverse)
resp_check = self.check_response(
resp=resp,
status_code=LimitsResponseCodes.GET_LIMITS,
label='',
message=err_msg)
result.response = resp
# resp_check will have the response failure or None if no failure
if resp_check is None:
return result
# Failures will be an empty list if the list was successful the
# first time
result.failures.append(resp_check)
time.sleep(poll_interval)
else:
err_msg = (
'Unable to GET limits after {0} attempts: '
'{1}').format(resource_get_attempts, result.failures)
self._log.error(err_msg)
if raise_exception:
raise ResourceGetException(err_msg)
return result
def _get_resource(self,
resource,
resource_id,
resource_get_attempts=None,
raise_exception=False,
poll_interval=None,
timeout=None,
use_over_limit_retry=False,
fn_kwargs=None):
"""
@summary: Shows and verifies a specified resource
@param resource: type of resource for ex. network, subnet, port, etc.
See NeutronResource in the networks constants
@type resource: resource instance with singular and plural forms
@param resource_id: The UUID for the resource
@type resource_id: str
@param fn_kwargs: function client call params besides the ID
@type fn_kwargs: dict
@param resource_get_attempts: number of API retries
@type resource_get_attempts: int
@param raise_exception: flag to raise an exception if the get
resource was not as expected or to return None
@type raise_exception: bool
@param poll_interval: sleep time interval between API retries
@type poll_interval: int
@param timeout: resource get timeout for over limit retries
@type timeout: int
@param use_over_limit_retry: flag to enable/disable the get
over limits retries
@type use_over_limit_retry: bool
@return: NetworkingResponse object with api response and failure list
@rtype: common.behaviors.NetworkingResponse
"""
# Defining the resource type in singular form (for ex. network)
resource_type = resource.singular
poll_interval = poll_interval or self.config.api_poll_interval
resource_get_attempts = (resource_get_attempts
or self.config.api_retries)
use_over_limit_retry = (use_over_limit_retry
or self.config.use_over_limit_retry)
timeout = timeout or self.config.resource_get_timeout
result = NetworkingResponse()
err_msg = '{0} Get failure'.format(resource_type)
for attempt in range(resource_get_attempts):
self._log.debug(
'Attempt {attempt_n} of {attempts} getting {resource_type} '
'{resource_id}'.format(attempt_n=attempt + 1,
attempts=resource_get_attempts,
resource_type=resource_type,
resource_id=resource_id))
fn_kwargs = fn_kwargs or {}
# Adding the resource id to the function kwargs
resource_id_name = '{0}_id'.format(resource_type)
fn_kwargs[resource_id_name] = resource_id
# Method uses resource type in singular form (slicing the ending s)
get_fn_name = 'get_{0}'.format(resource_type)
resp = getattr(self.client, get_fn_name)(**fn_kwargs)
if use_over_limit_retry:
entity_too_large_status_code = (getattr(
self.response_codes, 'REQUEST_ENTITY_TOO_LARGE'))
if resp.status_code == entity_too_large_status_code:
resp = self.__over_limit_retry(
resource_type=resource_type,
timeout=timeout,
poll_interval=poll_interval,
status_code=entity_too_large_status_code,
resp=resp,
fn_name=get_fn_name,
fn_kwargs=fn_kwargs)
response_code = get_fn_name.upper()
status_code = getattr(self.response_codes, response_code)
resp_check = self.check_response(resp=resp,
status_code=status_code,
label=resource_id,
message=err_msg)
result.response = resp
if not resp_check:
return result
# Failures will be an empty list if the get was successful the
# first time
result.failures.append(resp_check)
time.sleep(poll_interval)
else:
err_msg = (
'Unable to GET {resource_id} {resource_type} after {attempts} '
'attempts: {failures}').format(resource_id=resource_id,
resource_type=resource_type,
attempts=resource_get_attempts,
failures=result.failures)
self._log.error(err_msg)
if raise_exception:
raise ResourceGetException(err_msg)
return result
def get_port(self, port_id, resource_get_attempts=None,
raise_exception=False, poll_interval=None,
timeout=None, use_over_limit_retry=None):
"""
@summary: Shows and verifies a specified port
@param port_id: The UUID for the port
@type port_id: string
@param resource_get_attempts: number of API retries
@type resource_get_attempts: int
@param raise_exception: flag to raise an exception if the get
Port was not as expected or to return None
@type raise_exception: bool
@param poll_interval: sleep time interval between API retries
@type poll_interval: int
@param timeout: port get timeout for over limit retries
@type timeout: int
@param use_over_limit_retry: flag to enable/disable the port update
over limits retries
@type use_over_limit_retry: bool
@return: NetworkingResponse object with api response and failure list
@rtype: common.behaviors.NetworkingResponse
"""
poll_interval = poll_interval or self.config.api_poll_interval
resource_get_attempts = (resource_get_attempts or
self.config.api_retries)
poll_interval = poll_interval or self.config.api_poll_interval
use_over_limit_retry = (use_over_limit_retry or
self.config.use_over_limit_retry)
timeout = timeout or self.config.resource_get_timeout
result = NetworkingResponse()
err_msg = 'Port Get failure'
for attempt in range(resource_get_attempts):
self._log.debug('Attempt {0} of {1} getting network {2}'.format(
attempt + 1, resource_get_attempts, port_id))
resp = self.client.get_port(port_id=port_id)
if use_over_limit_retry:
endtime = time.time() + int(timeout)
retry_msg = ('OverLimit retry with a {0}s timeout getting '
'port {1}').format(timeout, port_id)
self._log.info(retry_msg)
while (resp.status_code ==
NeutronResponseCodes.REQUEST_ENTITY_TOO_LARGE and
time.time() < endtime):
resp = self.client.get_port(port_id=port_id)
time.sleep(poll_interval)
resp_check = self.check_response(resp=resp,
status_code=NeutronResponseCodes.GET_PORT,
label=port_id, message=err_msg)
result.response = resp
if not resp_check:
return result
# Failures will be an empty list if the get was successful the
# first time
result.failures.append(resp_check)
time.sleep(poll_interval)
else:
err_msg = (
'Unable to GET {0} port after {1} attempts: '
'{2}').format(port_id, resource_get_attempts, result.failures)
self._log.error(err_msg)
if raise_exception:
raise ResourceGetException(err_msg)
return result