def renew_user_authorization_rbac(cls,
https_client=get_gremlin_httpclient(),
*args,
**kwargs):
method = 'GET'
email = cls._error_if_not_email(**kwargs)
company_id = kwargs.get('companyId', None)
team_id = cls._error_if_not_param('teamnId', **kwargs)
renew_token = kwargs.get('renewToken', None)
if not company_id:
error_msg = f'orgId required parameter not supplied: {kwargs}'
log.fatal(error_msg)
raise GremlinParameterError(error_msg)
if not renew_token:
error_msg = f'renewToken required parameter not supplied: {kwargs}'
log.fatal(error_msg)
raise GremlinParameterError(error_msg)
data = {
'email': email,
'companyId': company_id,
'teamId': team_id,
'renewToken': renew_token
}
endpoint = f'/users/renew/rbac'
payload = cls._payload(**{
'headers': https_client.header(),
'data': data
})
(resp, body) = https_client.api_call(method, endpoint, **payload)
return body
def _error_if_not_json_body(cls, **kwargs):
body = cls._warn_if_not_json_body(**kwargs)
if not body:
error_msg = f'JSON Body not supplied: {kwargs}'
log.fatal(error_msg)
raise GremlinParameterError(error_msg)
return body
def _error_if_not_param(cls, parameter_name, **kwargs):
param = cls._info_if_not_param(parameter_name, **kwargs)
if not param:
error_msg = f'{parameter_name} not supplied: {kwargs}'
log.fatal(error_msg)
raise GremlinParameterError(error_msg)
return param
def delay(self, _delay):
if isinstance(_delay, int) and _delay >= 1:
self._delay = _delay
else:
error_msg = f'delay expects a positive integer {type(int)}'
log.fatal(error_msg)
raise GremlinParameterError(error_msg)
def command(self, _command=None):
if _command and issubclass(type(_command), GremlinAttackCommandHelper):
self._command = _command
else:
error_msg = f'command expects a GremlinAttackCommandHelper {type(GremlinAttackCommandHelper)}'
log.fatal(error_msg)
raise GremlinParameterError(error_msg)
def target(self, _target=None):
if _target and issubclass(type(_target), GremlinAttackTargetHelper):
self._target = _target
else:
error_msg = f'target expects a GremlinAttackTargetHelper {type(GremlinAttackTargetHelper)}'
log.fatal(error_msg)
raise GremlinParameterError(error_msg)
def add_step(self, _step=None):
if not issubclass(type(_step), GremlinScenarioStep):
error_msg = f'The step must extend from {type(GremlinScenarioStep)}'
log.fatal(error_msg)
raise GremlinParameterError(error_msg)
_cur_step_obj = json.loads(str(_step))
if len(self._steps) > 0:
log.debug('checking last step')
_last_step_obj = self._steps[-1]
last_attack_type = _last_step_obj['attacks'][0]['attackType']
last_target_type = _last_step_obj['attacks'][0][
'targetDefinition']['targetType']
last_command_type = _last_step_obj['attacks'][0][
'impactDefinition']['commandType']
cur_attack_type = _cur_step_obj['attacks'][0]['attackType']
cur_target_type = _cur_step_obj['attacks'][0]['targetDefinition'][
'targetType']
cur_command_type = _cur_step_obj['attacks'][0]['impactDefinition'][
'commandType']
if not last_attack_type == cur_attack_type:
error_msg = f'Each step must target the same attackType'
log.fatal(error_msg)
raise GremlinCommandTargetError(error_msg)
if not last_target_type == cur_target_type:
error_msg = f'Each step must target the same primitive typeset'
log.fatal(error_msg)
raise GremlinCommandTargetError(error_msg)
if not last_command_type == cur_command_type:
error_msg = f'Each step must use the same command type'
log.fatal(error_msg)
raise GremlinCommandTargetError(error_msg)
self._steps.append(_cur_step_obj)
else:
log.debug('fist step, just adding')
self._steps.append(_cur_step_obj)
def name(self, _name=None):
if isinstance(_name, str):
self._name = _name
else:
error_msg = f'name expects type {type(str)}'
log.fatal(error_msg)
raise GremlinParameterError(error_msg)
def _error_if_not_valid_role_statement(cls, **kwargs):
role = kwargs.get('role', None)
if not role:
error_msg = f'Role object not passed to users endpoint: {kwargs}'
log.fatal(error_msg)
raise GremlinParameterError(error_msg)
return role
def evaluation_response_body_evaluation(
self, _evaluation_response_body_evaluation=None):
if not _evaluation_response_body_evaluation:
error_msg = f'evaluation_response_body_evaluation expects an argument, none provided'
log.fatal(error_msg)
raise GremlinParameterError(error_msg)
self._evaluation_response_body_evaluation = _evaluation_response_body_evaluation
def _validate_type(self, _node=None):
_caller = inspect.stack()[2][3]
if not issubclass(type(_node), GremlinScenarioNode):
error_msg = f'{_caller} expects node to be a subclass of GremlinScenarioNode, received {type(_node)}'
log.fatal(error_msg)
raise GremlinParameterError(error_msg)
return True
def _user_report_endpoint(cls, endpoint, **kwargs):
email = cls._error_if_not_param('teamId', **kwargs)
if not email:
error_msg = f'userEmail not supplied to reports.security endpoint: {kwargs}'
log.fatal(error_msg)
raise GremlinParameterError(error_msg)
endpoint += cls._report_endpoint(endpoint, **kwargs) + f'&userEmail={email}'
return endpoint
def _error_if_not_email(cls, **kwargs):
email = cls._info_if_not_param('email', **kwargs)
if not email:
error_msg = f'email address not passed: {kwargs}'
log.fatal(error_msg)
raise GremlinParameterError(error_msg)
# Do some email regex validation here...
return email
def get_node(self, _index=None):
if not isinstance(_index, int):
error_msg = f'get_node expects index as integer, received {type(_index)}'
log.fatal(error_msg)
raise GremlinParameterError(error_msg)
node = self.head
for idx in range(_index):
node = node.next
if node == self.head:
return None
return node
def _list_endpoint(cls, endpoint, *args, **kwargs):
if not endpoint:
error_msg = f'endpoint not passed correctly: {args} :: {kwargs}'
log.fatal(error_msg)
raise GremlinParameterError(error_msg)
source = cls._warn_if_not_param('source', **kwargs)
page_size = cls._warn_if_not_param('pageSize', **kwargs)
if source or page_size:
endpoint += '/?'
if source and (source.lower() == 'adhoc' or source.lower() == 'scenario'):
endpoint += f'source={source}&'
if page_size and isinstance(page_size, int):
endpoint += f'pageSize={page_size}&'
return cls._optional_team_endpoint(endpoint, **kwargs)
def _build_query_string_endpoint(cls, endpoint, params, **kwargs):
if not endpoint:
error_msg = 'expected endpoint, received nothing'
log.fatal(error_msg)
raise GremlinParameterError(error_msg)
if not params or type(params) != type(list()):
error_msg = f'Expected list of params, received {type(params)}'
log.fatal(error_msg)
raise (error_msg)
for param_name in params:
endpoint = cls._add_query_param(
endpoint, param_name,
cls._error_if_not_param(param_name, **kwargs))
return endpoint
def uuid(self):
if not self.name:
error_msg = f'Node Name is required to build a scenario node, please set a node name'
log.fatal(error_msg)
raise GremlinParameterError(error_msg)
return f'{self.name}-{self.id}'
def attack_type(self, _attack_type=None):
if not isinstance(_attack_type, str):
error_msg = f'attack_type expects string {type(str)}, received {type(_attack_type)}'
log.fatal(error_msg)
raise GremlinParameterError(error_msg)
self._attack_type = _attack_type
def command(self, _command=None):
if not issubclass(type(_command), GremlinAttackCommandHelper):
error_msg = f'impact_definition expects a GremlinAttackCommandHelper, received {type(_command)}'
log.fatal(error_msg)
raise GremlinParameterError(error_msg)
self._command = _command
def target(self, _target=None):
if not issubclass(type(_target), GremlinAttackTargetHelper):
error_msg = f'target_definition expects a GremlinAttackTargetHelper, received {type(_target)}'
log.fatal(error_msg)
raise GremlinParameterError(error_msg)
self._target = _target
def delay(self, _duration=None):
if not isinstance(_duration, int):
error_msg = f'delay expects int type {type(int)}, received {type(_duration)}'
log.fatal(error_msg)
raise GremlinParameterError(error_msg)
self._delay = _duration
def add_node(self, _node=None):
if not issubclass(type(_node), GremlinScenarioNode):
error_msg = f'add_node expects GremlinScenarioNode (or None), received {type(_node)}'
log.fatal(error_msg)
raise GremlinParameterError(error_msg)
self._nodes.append(_node)
def evaluation_ok_status_codes(self, _status_codes=None):
if not isinstance(_status_codes, list):
error_msg = f'evaluation_ok_status_codes expects a list of integers or strings, received {type(_status_codes)}'
log.fatal(error_msg)
raise GremlinParameterError(error_msg)
self._evaluation_ok_status_codes = _status_codes
def name(self, _name=None):
if not isinstance(_name, str):
error_msg = f'Name expects string {type(str())}, received {type(_name)}'
log.fatal(error_msg)
raise GremlinParameterError(error_msg)
self._name = _name
def hypothesis(self, _hypothesis=None):
if not isinstance(_hypothesis, str):
error_msg = f'Hypothesis expects string {type(str())}, received {type(_hypothesis)}'
log.fatal(error_msg)
raise GremlinParameterError(error_msg)
self._hypothesis = _hypothesis
def id(self, _id=None):
if not isinstance(_id, str):
error_msg = f'id expects a string {type(str)}, received {type(str)}'
log.fatal(error_msg)
raise GremlinParameterError(error_msg)
self._id = _id
def description(self, _description=None):
if not isinstance(_description, str):
error_msg = f'Description expects string {type(str())}, received {type(_description)}'
log.fatal(error_msg)
raise GremlinParameterError(error_msg)
self._description = _description
def previous(self, _node=None):
if not issubclass(type(_node), GremlinScenarioNode):
error_msg = f'previous expects a GremlinScenarioNode, received {type(_node)}'
log.fatal(error_msg)
raise GremlinParameterError(error_msg)
self._previous = _node
def endpoint_url(self, _url=None):
if not isinstance(_url, str):
error_msg = f'url expects a valid url string, received {type(_url)}'
log.fatal(error_msg)
raise GremlinParameterError(error_msg)
self._endpoint_url = _url
def evaluation_ok_latency_max(self, _latency=None):
if not isinstance(_latency, int):
error_msg = f'evaluation_ok_latency_max expects an int, received {type(_latency)}'
log.fatal(error_msg)
raise GremlinParameterError(error_msg)
self._evaluation_ok_latency_max = _latency
