code stringlengths 114 1.05M | path stringlengths 3 312 | quality_prob float64 0.5 0.99 | learning_prob float64 0.2 1 | filename stringlengths 3 168 | kind stringclasses 1
value |
|---|---|---|---|---|---|
from rope.base import (change, taskhandle, evaluate,
exceptions, pyobjects, pynames, ast)
from rope.base import libutils
from rope.refactor import restructure, sourceutils, similarfinder
class UseFunction(object):
"""Try to use a function wherever possible"""
def __init__(self, project, resource, offset):
self.project = project
self.offset = offset
this_pymodule = project.get_pymodule(resource)
pyname = evaluate.eval_location(this_pymodule, offset)
if pyname is None:
raise exceptions.RefactoringError('Unresolvable name selected')
self.pyfunction = pyname.get_object()
if not isinstance(self.pyfunction, pyobjects.PyFunction) or \
not isinstance(self.pyfunction.parent, pyobjects.PyModule):
raise exceptions.RefactoringError(
'Use function works for global functions, only.')
self.resource = self.pyfunction.get_module().get_resource()
self._check_returns()
def _check_returns(self):
node = self.pyfunction.get_ast()
if _yield_count(node):
raise exceptions.RefactoringError('Use function should not '
'be used on generators.')
returns = _return_count(node)
if returns > 1:
raise exceptions.RefactoringError('usefunction: Function has more '
'than one return statement.')
if returns == 1 and not _returns_last(node):
raise exceptions.RefactoringError('usefunction: return should '
'be the last statement.')
def get_changes(self, resources=None,
task_handle=taskhandle.NullTaskHandle()):
if resources is None:
resources = self.project.get_python_files()
changes = change.ChangeSet('Using function <%s>' %
self.pyfunction.get_name())
if self.resource in resources:
newresources = list(resources)
newresources.remove(self.resource)
for c in self._restructure(newresources, task_handle).changes:
changes.add_change(c)
if self.resource in resources:
for c in self._restructure([self.resource], task_handle,
others=False).changes:
changes.add_change(c)
return changes
def get_function_name(self):
return self.pyfunction.get_name()
def _restructure(self, resources, task_handle, others=True):
pattern = self._make_pattern()
goal = self._make_goal(import_=others)
imports = None
if others:
imports = ['import %s' % self._module_name()]
body_region = sourceutils.get_body_region(self.pyfunction)
args_value = {'skip': (self.resource, body_region)}
args = {'': args_value}
restructuring = restructure.Restructure(
self.project, pattern, goal, args=args, imports=imports)
return restructuring.get_changes(resources=resources,
task_handle=task_handle)
def _find_temps(self):
return find_temps(self.project, self._get_body())
def _module_name(self):
return libutils.modname(self.resource)
def _make_pattern(self):
params = self.pyfunction.get_param_names()
body = self._get_body()
body = restructure.replace(body, 'return', 'pass')
wildcards = list(params)
wildcards.extend(self._find_temps())
if self._does_return():
if self._is_expression():
replacement = '${%s}' % self._rope_returned
else:
replacement = '%s = ${%s}' % (self._rope_result,
self._rope_returned)
body = restructure.replace(
body, 'return ${%s}' % self._rope_returned,
replacement)
wildcards.append(self._rope_result)
return similarfinder.make_pattern(body, wildcards)
def _get_body(self):
return sourceutils.get_body(self.pyfunction)
def _make_goal(self, import_=False):
params = self.pyfunction.get_param_names()
function_name = self.pyfunction.get_name()
if import_:
function_name = self._module_name() + '.' + function_name
goal = '%s(%s)' % (function_name,
', ' .join(('${%s}' % p) for p in params))
if self._does_return() and not self._is_expression():
goal = '${%s} = %s' % (self._rope_result, goal)
return goal
def _does_return(self):
body = self._get_body()
removed_return = restructure.replace(body, 'return ${result}', '')
return removed_return != body
def _is_expression(self):
return len(self.pyfunction.get_ast().body) == 1
_rope_result = '_rope__result'
_rope_returned = '_rope__returned'
def find_temps(project, code):
code = 'def f():\n' + sourceutils.indent_lines(code, 4)
pymodule = libutils.get_string_module(project, code)
result = []
function_scope = pymodule.get_scope().get_scopes()[0]
for name, pyname in function_scope.get_names().items():
if isinstance(pyname, pynames.AssignedName):
result.append(name)
return result
def _returns_last(node):
return node.body and isinstance(node.body[-1], ast.Return)
def _yield_count(node):
visitor = _ReturnOrYieldFinder()
visitor.start_walking(node)
return visitor.yields
def _return_count(node):
visitor = _ReturnOrYieldFinder()
visitor.start_walking(node)
return visitor.returns
class _ReturnOrYieldFinder(object):
def __init__(self):
self.returns = 0
self.yields = 0
def _Return(self, node):
self.returns += 1
def _Yield(self, node):
self.yields += 1
def _FunctionDef(self, node):
pass
def _ClassDef(self, node):
pass
def start_walking(self, node):
nodes = [node]
if isinstance(node, ast.FunctionDef):
nodes = ast.get_child_nodes(node)
for child in nodes:
ast.walk(child, self) | /ropee-0.13.3.tar.gz/ropee-0.13.3/rope/refactor/usefunction.py | 0.725649 | 0.187281 | usefunction.py | pypi |
import collections
import re
import warnings
from rope.base import ast, codeanalyze, exceptions
from rope.base.utils import pycompat
try:
basestring
except NameError:
basestring = (str, bytes)
def get_patched_ast(source, sorted_children=False):
"""Adds ``region`` and ``sorted_children`` fields to nodes
Adds ``sorted_children`` field only if `sorted_children` is True.
"""
return patch_ast(ast.parse(source), source, sorted_children)
def patch_ast(node, source, sorted_children=False):
"""Patches the given node
After calling, each node in `node` will have a new field named
`region` that is a tuple containing the start and end offsets
of the code that generated it.
If `sorted_children` is true, a `sorted_children` field will
be created for each node, too. It is a list containing child
nodes as well as whitespaces and comments that occur between
them.
"""
if hasattr(node, 'region'):
return node
walker = _PatchingASTWalker(source, children=sorted_children)
ast.call_for_nodes(node, walker)
return node
def node_region(patched_ast_node):
"""Get the region of a patched ast node"""
return patched_ast_node.region
def write_ast(patched_ast_node):
"""Extract source form a patched AST node with `sorted_children` field
If the node is patched with sorted_children turned off you can use
`node_region` function for obtaining code using module source code.
"""
result = []
for child in patched_ast_node.sorted_children:
if isinstance(child, ast.AST):
result.append(write_ast(child))
else:
result.append(child)
return ''.join(result)
class MismatchedTokenError(exceptions.RopeError):
pass
class _PatchingASTWalker(object):
def __init__(self, source, children=False):
self.source = _Source(source)
self.children = children
self.lines = codeanalyze.SourceLinesAdapter(source)
self.children_stack = []
Number = object()
String = object()
semicolon_or_as_in_except = object()
def __call__(self, node):
method = getattr(self, '_' + node.__class__.__name__, None)
if method is not None:
return method(node)
# ???: Unknown node; what should we do here?
warnings.warn('Unknown node type <%s>; please report!'
% node.__class__.__name__, RuntimeWarning)
node.region = (self.source.offset, self.source.offset)
if self.children:
node.sorted_children = ast.get_children(node)
def _handle(self, node, base_children, eat_parens=False, eat_spaces=False):
if hasattr(node, 'region'):
# ???: The same node was seen twice; what should we do?
warnings.warn(
'Node <%s> has been already patched; please report!' %
node.__class__.__name__, RuntimeWarning)
return
base_children = collections.deque(base_children)
self.children_stack.append(base_children)
children = collections.deque()
formats = []
suspected_start = self.source.offset
start = suspected_start
first_token = True
while base_children:
child = base_children.popleft()
if child is None:
continue
offset = self.source.offset
if isinstance(child, ast.AST):
ast.call_for_nodes(child, self)
token_start = child.region[0]
else:
if child is self.String:
region = self.source.consume_string(
end=self._find_next_statement_start())
elif child is self.Number:
region = self.source.consume_number()
elif child == '!=':
# INFO: This has been added to handle deprecated ``<>``
region = self.source.consume_not_equal()
elif child == self.semicolon_or_as_in_except:
# INFO: This has been added to handle deprecated
# semicolon in except
region = self.source.consume_except_as_or_semicolon()
else:
region = self.source.consume(child)
child = self.source[region[0]:region[1]]
token_start = region[0]
if not first_token:
formats.append(self.source[offset:token_start])
if self.children:
children.append(self.source[offset:token_start])
else:
first_token = False
start = token_start
if self.children:
children.append(child)
start = self._handle_parens(children, start, formats)
if eat_parens:
start = self._eat_surrounding_parens(
children, suspected_start, start)
if eat_spaces:
if self.children:
children.appendleft(self.source[0:start])
end_spaces = self.source[self.source.offset:]
self.source.consume(end_spaces)
if self.children:
children.append(end_spaces)
start = 0
if self.children:
node.sorted_children = children
node.region = (start, self.source.offset)
self.children_stack.pop()
def _handle_parens(self, children, start, formats):
"""Changes `children` and returns new start"""
opens, closes = self._count_needed_parens(formats)
old_end = self.source.offset
new_end = None
for i in range(closes):
new_end = self.source.consume(')')[1]
if new_end is not None:
if self.children:
children.append(self.source[old_end:new_end])
new_start = start
for i in range(opens):
new_start = self.source.rfind_token('(', 0, new_start)
if new_start != start:
if self.children:
children.appendleft(self.source[new_start:start])
start = new_start
return start
def _eat_surrounding_parens(self, children, suspected_start, start):
index = self.source.rfind_token('(', suspected_start, start)
if index is not None:
old_start = start
old_offset = self.source.offset
start = index
if self.children:
children.appendleft(self.source[start + 1:old_start])
children.appendleft('(')
token_start, token_end = self.source.consume(')')
if self.children:
children.append(self.source[old_offset:token_start])
children.append(')')
return start
def _count_needed_parens(self, children):
start = 0
opens = 0
for child in children:
if not isinstance(child, basestring):
continue
if child == '' or child[0] in '\'"':
continue
index = 0
while index < len(child):
if child[index] == ')':
if opens > 0:
opens -= 1
else:
start += 1
if child[index] == '(':
opens += 1
if child[index] == '#':
try:
index = child.index('\n', index)
except ValueError:
break
index += 1
return start, opens
def _find_next_statement_start(self):
for children in reversed(self.children_stack):
for child in children:
if isinstance(child, ast.stmt):
return child.col_offset \
+ self.lines.get_line_start(child.lineno)
return len(self.source.source)
_operators = {'And': 'and', 'Or': 'or', 'Add': '+', 'Sub': '-',
'Mult': '*', 'Div': '/', 'Mod': '%', 'Pow': '**',
'LShift': '<<', 'RShift': '>>', 'BitOr': '|', 'BitAnd': '&',
'BitXor': '^', 'FloorDiv': '//', 'Invert': '~',
'Not': 'not', 'UAdd': '+', 'USub': '-', 'Eq': '==',
'NotEq': '!=', 'Lt': '<', 'LtE': '<=', 'Gt': '>',
'GtE': '>=', 'Is': 'is', 'IsNot': 'is not', 'In': 'in',
'NotIn': 'not in'}
def _get_op(self, node):
return self._operators[node.__class__.__name__].split(' ')
def _Attribute(self, node):
self._handle(node, [node.value, '.', node.attr])
def _Assert(self, node):
children = ['assert', node.test]
if node.msg:
children.append(',')
children.append(node.msg)
self._handle(node, children)
def _Assign(self, node):
children = self._child_nodes(node.targets, '=')
children.append('=')
children.append(node.value)
self._handle(node, children)
def _AugAssign(self, node):
children = [node.target]
children.extend(self._get_op(node.op))
children.extend(['=', node.value])
self._handle(node, children)
def _Repr(self, node):
self._handle(node, ['`', node.value, '`'])
def _BinOp(self, node):
children = [node.left] + self._get_op(node.op) + [node.right]
self._handle(node, children)
def _BoolOp(self, node):
self._handle(node, self._child_nodes(node.values,
self._get_op(node.op)[0]))
def _Break(self, node):
self._handle(node, ['break'])
def _Call(self, node):
def _arg_sort_key(node):
if isinstance(node, ast.keyword):
return (node.value.lineno, node.value.col_offset)
return (node.lineno, node.col_offset)
children = [node.func, '(']
unstarred_args = []
starred_and_keywords = list(node.keywords)
for i, arg in enumerate(node.args):
if hasattr(ast, 'Starred') and isinstance(arg, ast.Starred):
starred_and_keywords.append(arg)
else:
unstarred_args.append(arg)
if getattr(node, 'starargs', None):
starred_and_keywords.append(node.starargs)
starred_and_keywords.sort(key=_arg_sort_key)
children.extend(self._child_nodes(unstarred_args, ','))
# positional args come before keywords, *args comes after all
# positional args, and **kwargs comes last
if starred_and_keywords:
if len(children) > 2:
children.append(',')
for i, arg in enumerate(starred_and_keywords):
if arg == getattr(node, 'starargs', None):
children.append('*')
children.append(arg)
if i + 1 < len(starred_and_keywords):
children.append(',')
if getattr(node, 'kwargs', None):
if len(children) > 2:
children.append(',')
children.extend(['**', node.kwargs])
children.append(')')
self._handle(node, children)
def _ClassDef(self, node):
children = []
if getattr(node, 'decorator_list', None):
for decorator in node.decorator_list:
children.append('@')
children.append(decorator)
children.extend(['class', node.name])
if node.bases:
children.append('(')
children.extend(self._child_nodes(node.bases, ','))
children.append(')')
children.append(':')
children.extend(node.body)
self._handle(node, children)
def _Compare(self, node):
children = []
children.append(node.left)
for op, expr in zip(node.ops, node.comparators):
children.extend(self._get_op(op))
children.append(expr)
self._handle(node, children)
def _Delete(self, node):
self._handle(node, ['del'] + self._child_nodes(node.targets, ','))
def _Num(self, node):
self._handle(node, [self.Number])
def _Str(self, node):
self._handle(node, [self.String])
def _Continue(self, node):
self._handle(node, ['continue'])
def _Dict(self, node):
children = []
children.append('{')
if node.keys:
for index, (key, value) in enumerate(zip(node.keys, node.values)):
children.extend([key, ':', value])
if index < len(node.keys) - 1:
children.append(',')
children.append('}')
self._handle(node, children)
def _Ellipsis(self, node):
self._handle(node, ['...'])
def _Expr(self, node):
self._handle(node, [node.value])
def _Exec(self, node):
children = []
children.extend(['exec', node.body])
if node.globals:
children.extend(['in', node.globals])
if node.locals:
children.extend([',', node.locals])
self._handle(node, children)
def _ExtSlice(self, node):
children = []
for index, dim in enumerate(node.dims):
if index > 0:
children.append(',')
children.append(dim)
self._handle(node, children)
def _For(self, node):
children = ['for', node.target, 'in', node.iter, ':']
children.extend(node.body)
if node.orelse:
children.extend(['else', ':'])
children.extend(node.orelse)
self._handle(node, children)
def _ImportFrom(self, node):
children = ['from']
if node.level:
children.append('.' * node.level)
# see comment at rope.base.ast.walk
children.extend([node.module or '',
'import'])
children.extend(self._child_nodes(node.names, ','))
self._handle(node, children)
def _alias(self, node):
children = [node.name]
if node.asname:
children.extend(['as', node.asname])
self._handle(node, children)
def _FunctionDef(self, node):
children = []
try:
decorators = getattr(node, 'decorator_list')
except AttributeError:
decorators = getattr(node, 'decorators', None)
if decorators:
for decorator in decorators:
children.append('@')
children.append(decorator)
children.extend(['def', node.name, '(', node.args])
children.extend([')', ':'])
children.extend(node.body)
self._handle(node, children)
def _arguments(self, node):
children = []
args = list(node.args)
defaults = [None] * (len(args) - len(node.defaults)) + \
list(node.defaults)
for index, (arg, default) in enumerate(zip(args, defaults)):
if index > 0:
children.append(',')
self._add_args_to_children(children, arg, default)
if node.vararg is not None:
if args:
children.append(',')
children.extend(['*', pycompat.get_ast_arg_arg(node.vararg)])
if node.kwarg is not None:
if args or node.vararg is not None:
children.append(',')
children.extend(['**', pycompat.get_ast_arg_arg(node.kwarg)])
self._handle(node, children)
def _add_args_to_children(self, children, arg, default):
if isinstance(arg, (list, tuple)):
self._add_tuple_parameter(children, arg)
else:
children.append(arg)
if default is not None:
children.append('=')
children.append(default)
def _add_tuple_parameter(self, children, arg):
children.append('(')
for index, token in enumerate(arg):
if index > 0:
children.append(',')
if isinstance(token, (list, tuple)):
self._add_tuple_parameter(children, token)
else:
children.append(token)
children.append(')')
def _GeneratorExp(self, node):
children = [node.elt]
children.extend(node.generators)
self._handle(node, children, eat_parens=True)
def _comprehension(self, node):
children = ['for', node.target, 'in', node.iter]
if node.ifs:
for if_ in node.ifs:
children.append('if')
children.append(if_)
self._handle(node, children)
def _Global(self, node):
children = self._child_nodes(node.names, ',')
children.insert(0, 'global')
self._handle(node, children)
def _If(self, node):
if self._is_elif(node):
children = ['elif']
else:
children = ['if']
children.extend([node.test, ':'])
children.extend(node.body)
if node.orelse:
if len(node.orelse) == 1 and self._is_elif(node.orelse[0]):
pass
else:
children.extend(['else', ':'])
children.extend(node.orelse)
self._handle(node, children)
def _is_elif(self, node):
if not isinstance(node, ast.If):
return False
offset = self.lines.get_line_start(node.lineno) + node.col_offset
word = self.source[offset:offset + 4]
# XXX: This is a bug; the offset does not point to the first
alt_word = self.source[offset - 5:offset - 1]
return 'elif' in (word, alt_word)
def _IfExp(self, node):
return self._handle(node, [node.body, 'if', node.test,
'else', node.orelse])
def _Import(self, node):
children = ['import']
children.extend(self._child_nodes(node.names, ','))
self._handle(node, children)
def _keyword(self, node):
children = []
if node.arg is None:
children.append(node.value)
else:
children.extend([node.arg, '=', node.value])
self._handle(node, children)
def _Lambda(self, node):
self._handle(node, ['lambda', node.args, ':', node.body])
def _List(self, node):
self._handle(node, ['['] + self._child_nodes(node.elts, ',') + [']'])
def _ListComp(self, node):
children = ['[', node.elt]
children.extend(node.generators)
children.append(']')
self._handle(node, children)
def _Set(self, node):
if node.elts:
self._handle(node,
['{'] + self._child_nodes(node.elts, ',') + ['}'])
return
# Python doesn't have empty set literals
warnings.warn('Tried to handle empty <Set> literal; please report!',
RuntimeWarning)
self._handle(node, ['set(', ')'])
def _SetComp(self, node):
children = ['{', node.elt]
children.extend(node.generators)
children.append('}')
self._handle(node, children)
def _DictComp(self, node):
children = ['{']
children.extend([node.key, ':', node.value])
children.extend(node.generators)
children.append('}')
self._handle(node, children)
def _Module(self, node):
self._handle(node, list(node.body), eat_spaces=True)
def _Name(self, node):
self._handle(node, [node.id])
def _NameConstant(self, node):
self._handle(node, [str(node.value)])
def _arg(self, node):
self._handle(node, [node.arg])
def _Pass(self, node):
self._handle(node, ['pass'])
def _Print(self, node):
children = ['print']
if node.dest:
children.extend(['>>', node.dest])
if node.values:
children.append(',')
children.extend(self._child_nodes(node.values, ','))
if not node.nl:
children.append(',')
self._handle(node, children)
def _Raise(self, node):
def get_python3_raise_children(node):
children = ['raise']
if node.exc:
children.append(node.exc)
if node.cause:
children.append(node.cause)
return children
def get_python2_raise_children(node):
children = ['raise']
if node.type:
children.append(node.type)
if node.inst:
children.append(',')
children.append(node.inst)
if node.tback:
children.append(',')
children.append(node.tback)
return children
if pycompat.PY2:
children = get_python2_raise_children(node)
else:
children = get_python3_raise_children(node)
self._handle(node, children)
def _Return(self, node):
children = ['return']
if node.value:
children.append(node.value)
self._handle(node, children)
def _Sliceobj(self, node):
children = []
for index, slice in enumerate(node.nodes):
if index > 0:
children.append(':')
if slice:
children.append(slice)
self._handle(node, children)
def _Index(self, node):
self._handle(node, [node.value])
def _Subscript(self, node):
self._handle(node, [node.value, '[', node.slice, ']'])
def _Slice(self, node):
children = []
if node.lower:
children.append(node.lower)
children.append(':')
if node.upper:
children.append(node.upper)
if node.step:
children.append(':')
children.append(node.step)
self._handle(node, children)
def _TryFinally(self, node):
# @todo fixme
is_there_except_handler = False
not_empty_body = True
if len(node.finalbody) == 1:
if pycompat.PY2:
is_there_except_handler = isinstance(node.body[0], ast.TryExcept)
not_empty_body = not bool(len(node.body))
elif pycompat.PY3:
try:
is_there_except_handler = isinstance(node.handlers[0], ast.ExceptHandler)
not_empty_body = True
except IndexError:
pass
children = []
if not_empty_body or not is_there_except_handler:
children.extend(['try', ':'])
children.extend(node.body)
if pycompat.PY3:
children.extend(node.handlers)
children.extend(['finally', ':'])
children.extend(node.finalbody)
self._handle(node, children)
def _TryExcept(self, node):
children = ['try', ':']
children.extend(node.body)
children.extend(node.handlers)
if node.orelse:
children.extend(['else', ':'])
children.extend(node.orelse)
self._handle(node, children)
def _Try(self, node):
if len(node.finalbody):
self._TryFinally(node)
else:
self._TryExcept(node)
def _ExceptHandler(self, node):
self._excepthandler(node)
def _excepthandler(self, node):
# self._handle(node, [self.semicolon_or_as_in_except])
children = ['except']
if node.type:
children.append(node.type)
if node.name:
children.append(self.semicolon_or_as_in_except)
children.append(node.name)
children.append(':')
children.extend(node.body)
self._handle(node, children)
def _Tuple(self, node):
if node.elts:
self._handle(node, self._child_nodes(node.elts, ','),
eat_parens=True)
else:
self._handle(node, ['(', ')'])
def _UnaryOp(self, node):
children = self._get_op(node.op)
children.append(node.operand)
self._handle(node, children)
def _Yield(self, node):
children = ['yield']
if node.value:
children.append(node.value)
self._handle(node, children)
def _While(self, node):
children = ['while', node.test, ':']
children.extend(node.body)
if node.orelse:
children.extend(['else', ':'])
children.extend(node.orelse)
self._handle(node, children)
def _With(self, node):
children = []
for item in pycompat.get_ast_with_items(node):
children.extend(['with', item.context_expr])
if item.optional_vars:
children.extend(['as', item.optional_vars])
children.append(':')
children.extend(node.body)
self._handle(node, children)
def _child_nodes(self, nodes, separator):
children = []
for index, child in enumerate(nodes):
children.append(child)
if index < len(nodes) - 1:
children.append(separator)
return children
def _Starred(self, node):
self._handle(node, [node.value])
class _Source(object):
def __init__(self, source):
self.source = source
self.offset = 0
def consume(self, token):
try:
while True:
new_offset = self.source.index(token, self.offset)
if self._good_token(token, new_offset):
break
else:
self._skip_comment()
except (ValueError, TypeError):
raise MismatchedTokenError(
'Token <%s> at %s cannot be matched' %
(token, self._get_location()))
self.offset = new_offset + len(token)
return (new_offset, self.offset)
def consume_string(self, end=None):
if _Source._string_pattern is None:
original = codeanalyze.get_string_pattern()
pattern = r'(%s)((\s|\\\n|#[^\n]*\n)*(%s))*' % \
(original, original)
_Source._string_pattern = re.compile(pattern)
repattern = _Source._string_pattern
return self._consume_pattern(repattern, end)
def consume_number(self):
if _Source._number_pattern is None:
_Source._number_pattern = re.compile(
self._get_number_pattern())
repattern = _Source._number_pattern
return self._consume_pattern(repattern)
def consume_not_equal(self):
if _Source._not_equals_pattern is None:
_Source._not_equals_pattern = re.compile(r'<>|!=')
repattern = _Source._not_equals_pattern
return self._consume_pattern(repattern)
def consume_except_as_or_semicolon(self):
repattern = re.compile(r'as|,')
return self._consume_pattern(repattern)
def _good_token(self, token, offset, start=None):
"""Checks whether consumed token is in comments"""
if start is None:
start = self.offset
try:
comment_index = self.source.rindex('#', start, offset)
except ValueError:
return True
try:
new_line_index = self.source.rindex('\n', start, offset)
except ValueError:
return False
return comment_index < new_line_index
def _skip_comment(self):
self.offset = self.source.index('\n', self.offset + 1)
def _get_location(self):
lines = self.source[:self.offset].split('\n')
return (len(lines), len(lines[-1]))
def _consume_pattern(self, repattern, end=None):
while True:
if end is None:
end = len(self.source)
match = repattern.search(self.source, self.offset, end)
if self._good_token(match.group(), match.start()):
break
else:
self._skip_comment()
self.offset = match.end()
return match.start(), match.end()
def till_token(self, token):
new_offset = self.source.index(token, self.offset)
return self[self.offset:new_offset]
def rfind_token(self, token, start, end):
index = start
while True:
try:
index = self.source.rindex(token, start, end)
if self._good_token(token, index, start=start):
return index
else:
end = index
except ValueError:
return None
def from_offset(self, offset):
return self[offset:self.offset]
def find_backwards(self, pattern, offset):
return self.source.rindex(pattern, 0, offset)
def __getitem__(self, index):
return self.source[index]
def __getslice__(self, i, j):
return self.source[i:j]
def _get_number_pattern(self):
# HACK: It is merely an approaximation and does the job
integer = r'\-?(0x[\da-fA-F]+|\d+)[lL]?'
return r'(%s(\.\d*)?|(\.\d+))([eE][-+]?\d+)?[jJ]?' % integer
_string_pattern = None
_number_pattern = None
_not_equals_pattern = None | /ropee-0.13.3.tar.gz/ropee-0.13.3/rope/refactor/patchedast.py | 0.524151 | 0.261525 | patchedast.py | pypi |
from rope.base import (pyobjects, codeanalyze, exceptions, pynames,
taskhandle, evaluate, worder, libutils)
from rope.base.change import ChangeSet, ChangeContents, MoveResource
from rope.refactor import importutils, rename, occurrences, sourceutils, \
functionutils
def create_move(project, resource, offset=None):
"""A factory for creating Move objects
Based on `resource` and `offset`, return one of `MoveModule`,
`MoveGlobal` or `MoveMethod` for performing move refactoring.
"""
if offset is None:
return MoveModule(project, resource)
this_pymodule = project.get_pymodule(resource)
pyname = evaluate.eval_location(this_pymodule, offset)
if pyname is not None:
pyobject = pyname.get_object()
if isinstance(pyobject, pyobjects.PyModule) or \
isinstance(pyobject, pyobjects.PyPackage):
return MoveModule(project, pyobject.get_resource())
if isinstance(pyobject, pyobjects.PyFunction) and \
isinstance(pyobject.parent, pyobjects.PyClass):
return MoveMethod(project, resource, offset)
if isinstance(pyobject, pyobjects.PyDefinedObject) and \
isinstance(pyobject.parent, pyobjects.PyModule) or \
isinstance(pyname, pynames.AssignedName):
return MoveGlobal(project, resource, offset)
raise exceptions.RefactoringError(
'Move only works on global classes/functions/variables, modules and '
'methods.')
class MoveMethod(object):
"""For moving methods
It makes a new method in the destination class and changes
the body of the old method to call the new method. You can
inline the old method to change all of its occurrences.
"""
def __init__(self, project, resource, offset):
self.project = project
this_pymodule = self.project.get_pymodule(resource)
pyname = evaluate.eval_location(this_pymodule, offset)
self.method_name = worder.get_name_at(resource, offset)
self.pyfunction = pyname.get_object()
if self.pyfunction.get_kind() != 'method':
raise exceptions.RefactoringError('Only normal methods'
' can be moved.')
def get_changes(self, dest_attr, new_name=None, resources=None,
task_handle=taskhandle.NullTaskHandle()):
"""Return the changes needed for this refactoring
Parameters:
- `dest_attr`: the name of the destination attribute
- `new_name`: the name of the new method; if `None` uses
the old name
- `resources` can be a list of `rope.base.resources.File`\s to
apply this refactoring on. If `None`, the restructuring
will be applied to all python files.
"""
changes = ChangeSet('Moving method <%s>' % self.method_name)
if resources is None:
resources = self.project.get_python_files()
if new_name is None:
new_name = self.get_method_name()
resource1, start1, end1, new_content1 = \
self._get_changes_made_by_old_class(dest_attr, new_name)
collector1 = codeanalyze.ChangeCollector(resource1.read())
collector1.add_change(start1, end1, new_content1)
resource2, start2, end2, new_content2 = \
self._get_changes_made_by_new_class(dest_attr, new_name)
if resource1 == resource2:
collector1.add_change(start2, end2, new_content2)
else:
collector2 = codeanalyze.ChangeCollector(resource2.read())
collector2.add_change(start2, end2, new_content2)
result = collector2.get_changed()
import_tools = importutils.ImportTools(self.project)
new_imports = self._get_used_imports(import_tools)
if new_imports:
goal_pymodule = libutils.get_string_module(
self.project, result, resource2)
result = _add_imports_to_module(
import_tools, goal_pymodule, new_imports)
if resource2 in resources:
changes.add_change(ChangeContents(resource2, result))
if resource1 in resources:
changes.add_change(ChangeContents(resource1,
collector1.get_changed()))
return changes
def get_method_name(self):
return self.method_name
def _get_used_imports(self, import_tools):
return importutils.get_imports(self.project, self.pyfunction)
def _get_changes_made_by_old_class(self, dest_attr, new_name):
pymodule = self.pyfunction.get_module()
indents = self._get_scope_indents(self.pyfunction)
body = 'return self.%s.%s(%s)\n' % (
dest_attr, new_name, self._get_passed_arguments_string())
region = sourceutils.get_body_region(self.pyfunction)
return (pymodule.get_resource(), region[0], region[1],
sourceutils.fix_indentation(body, indents))
def _get_scope_indents(self, pyobject):
pymodule = pyobject.get_module()
return sourceutils.get_indents(
pymodule.lines, pyobject.get_scope().get_start()) + \
sourceutils.get_indent(self.project)
def _get_changes_made_by_new_class(self, dest_attr, new_name):
old_pyclass = self.pyfunction.parent
if dest_attr not in old_pyclass:
raise exceptions.RefactoringError(
'Destination attribute <%s> not found' % dest_attr)
pyclass = old_pyclass[dest_attr].get_object().get_type()
if not isinstance(pyclass, pyobjects.PyClass):
raise exceptions.RefactoringError(
'Unknown class type for attribute <%s>' % dest_attr)
pymodule = pyclass.get_module()
resource = pyclass.get_module().get_resource()
start, end = sourceutils.get_body_region(pyclass)
pre_blanks = '\n'
if pymodule.source_code[start:end].strip() != 'pass':
pre_blanks = '\n\n'
start = end
indents = self._get_scope_indents(pyclass)
body = pre_blanks + sourceutils.fix_indentation(
self.get_new_method(new_name), indents)
return resource, start, end, body
def get_new_method(self, name):
return '%s\n%s' % (
self._get_new_header(name),
sourceutils.fix_indentation(self._get_body(),
sourceutils.get_indent(self.project)))
def _get_unchanged_body(self):
return sourceutils.get_body(self.pyfunction)
def _get_body(self, host='host'):
self_name = self._get_self_name()
body = self_name + ' = None\n' + self._get_unchanged_body()
pymodule = libutils.get_string_module(self.project, body)
finder = occurrences.create_finder(
self.project, self_name, pymodule[self_name])
result = rename.rename_in_module(finder, host, pymodule=pymodule)
if result is None:
result = body
return result[result.index('\n') + 1:]
def _get_self_name(self):
return self.pyfunction.get_param_names()[0]
def _get_new_header(self, name):
header = 'def %s(self' % name
if self._is_host_used():
header += ', host'
definition_info = functionutils.DefinitionInfo.read(self.pyfunction)
others = definition_info.arguments_to_string(1)
if others:
header += ', ' + others
return header + '):'
def _get_passed_arguments_string(self):
result = ''
if self._is_host_used():
result = 'self'
definition_info = functionutils.DefinitionInfo.read(self.pyfunction)
others = definition_info.arguments_to_string(1)
if others:
if result:
result += ', '
result += others
return result
def _is_host_used(self):
return self._get_body('__old_self') != self._get_unchanged_body()
class MoveGlobal(object):
"""For moving global function and classes"""
def __init__(self, project, resource, offset):
self.project = project
this_pymodule = self.project.get_pymodule(resource)
self.old_pyname = evaluate.eval_location(this_pymodule, offset)
if self.old_pyname is None:
raise exceptions.RefactoringError(
'Move refactoring should be performed on a '
'class/function/variable.')
if self._is_variable(self.old_pyname):
self.old_name = worder.get_name_at(resource, offset)
pymodule = this_pymodule
else:
self.old_name = self.old_pyname.get_object().get_name()
pymodule = self.old_pyname.get_object().get_module()
self._check_exceptional_conditions()
self.source = pymodule.get_resource()
self.tools = _MoveTools(self.project, self.source,
self.old_pyname, self.old_name)
self.import_tools = self.tools.import_tools
def _import_filter(self, stmt):
module_name = libutils.modname(self.source)
if isinstance(stmt.import_info, importutils.NormalImport):
# Affect any statement that imports the source module
return any(module_name == name
for name, alias in stmt.import_info.names_and_aliases)
elif isinstance(stmt.import_info, importutils.FromImport):
# Affect statements importing from the source package
if '.' in module_name:
package_name, basename = module_name.rsplit('.', 1)
if (stmt.import_info.module_name == package_name and
any(basename == name
for name, alias in stmt.import_info.names_and_aliases)):
return True
return stmt.import_info.module_name == module_name
return False
def _check_exceptional_conditions(self):
if self._is_variable(self.old_pyname):
pymodule = self.old_pyname.get_definition_location()[0]
try:
pymodule.get_scope().get_name(self.old_name)
except exceptions.NameNotFoundError:
self._raise_refactoring_error()
elif not (isinstance(self.old_pyname.get_object(),
pyobjects.PyDefinedObject) and
self._is_global(self.old_pyname.get_object())):
self._raise_refactoring_error()
def _raise_refactoring_error(self):
raise exceptions.RefactoringError(
'Move refactoring should be performed on a global class, function '
'or variable.')
def _is_global(self, pyobject):
return pyobject.get_scope().parent == pyobject.get_module().get_scope()
def _is_variable(self, pyname):
return isinstance(pyname, pynames.AssignedName)
def get_changes(self, dest, resources=None,
task_handle=taskhandle.NullTaskHandle()):
if resources is None:
resources = self.project.get_python_files()
if dest is None or not dest.exists():
raise exceptions.RefactoringError(
'Move destination does not exist.')
if dest.is_folder() and dest.has_child('__init__.py'):
dest = dest.get_child('__init__.py')
if dest.is_folder():
raise exceptions.RefactoringError(
'Move destination for non-modules should not be folders.')
if self.source == dest:
raise exceptions.RefactoringError(
'Moving global elements to the same module.')
return self._calculate_changes(dest, resources, task_handle)
def _calculate_changes(self, dest, resources, task_handle):
changes = ChangeSet('Moving global <%s>' % self.old_name)
job_set = task_handle.create_jobset('Collecting Changes',
len(resources))
for file_ in resources:
job_set.started_job(file_.path)
if file_ == self.source:
changes.add_change(self._source_module_changes(dest))
elif file_ == dest:
changes.add_change(self._dest_module_changes(dest))
elif self.tools.occurs_in_module(resource=file_):
pymodule = self.project.get_pymodule(file_)
# Changing occurrences
placeholder = '__rope_renaming_%s_' % self.old_name
source = self.tools.rename_in_module(placeholder,
resource=file_)
should_import = source is not None
# Removing out of date imports
pymodule = self.tools.new_pymodule(pymodule, source)
source = self.import_tools.organize_imports(
pymodule, sort=False, import_filter=self._import_filter)
# Adding new import
if should_import:
pymodule = self.tools.new_pymodule(pymodule, source)
source, imported = importutils.add_import(
self.project, pymodule, self._new_modname(dest),
self.old_name)
source = source.replace(placeholder, imported)
source = self.tools.new_source(pymodule, source)
if source != file_.read():
changes.add_change(ChangeContents(file_, source))
job_set.finished_job()
return changes
def _source_module_changes(self, dest):
placeholder = '__rope_moving_%s_' % self.old_name
handle = _ChangeMoveOccurrencesHandle(placeholder)
occurrence_finder = occurrences.create_finder(
self.project, self.old_name, self.old_pyname)
start, end = self._get_moving_region()
renamer = ModuleSkipRenamer(occurrence_finder, self.source,
handle, start, end)
source = renamer.get_changed_module()
pymodule = libutils.get_string_module(self.project, source, self.source)
source = self.import_tools.organize_imports(pymodule, sort=False)
if handle.occurred:
pymodule = libutils.get_string_module(
self.project, source, self.source)
# Adding new import
source, imported = importutils.add_import(
self.project, pymodule, self._new_modname(dest), self.old_name)
source = source.replace(placeholder, imported)
return ChangeContents(self.source, source)
def _new_modname(self, dest):
return libutils.modname(dest)
def _dest_module_changes(self, dest):
# Changing occurrences
pymodule = self.project.get_pymodule(dest)
source = self.tools.rename_in_module(self.old_name, pymodule)
pymodule = self.tools.new_pymodule(pymodule, source)
moving, imports = self._get_moving_element_with_imports()
pymodule, has_changed = self._add_imports2(pymodule, imports)
module_with_imports = self.import_tools.module_imports(pymodule)
source = pymodule.source_code
lineno = 0
if module_with_imports.imports:
lineno = module_with_imports.imports[-1].end_line - 1
else:
while lineno < pymodule.lines.length() and \
pymodule.lines.get_line(lineno + 1).\
lstrip().startswith('#'):
lineno += 1
if lineno > 0:
cut = pymodule.lines.get_line_end(lineno) + 1
result = source[:cut] + '\n\n' + moving + source[cut:]
else:
result = moving + source
# Organizing imports
source = result
pymodule = libutils.get_string_module(self.project, source, dest)
source = self.import_tools.organize_imports(pymodule, sort=False,
unused=False)
# Remove unused imports of the old module
pymodule = libutils.get_string_module(self.project, source, dest)
source = self.import_tools.organize_imports(
pymodule, sort=False, selfs=False, unused=True,
import_filter=self._import_filter)
return ChangeContents(dest, source)
def _get_moving_element_with_imports(self):
return moving_code_with_imports(
self.project, self.source, self._get_moving_element())
def _get_module_with_imports(self, source_code, resource):
pymodule = libutils.get_string_module(
self.project, source_code, resource)
return self.import_tools.module_imports(pymodule)
def _get_moving_element(self):
start, end = self._get_moving_region()
moving = self.source.read()[start:end]
return moving.rstrip() + '\n'
def _get_moving_region(self):
pymodule = self.project.get_pymodule(self.source)
lines = pymodule.lines
if self._is_variable(self.old_pyname):
logical_lines = pymodule.logical_lines
lineno = logical_lines.logical_line_in(
self.old_pyname.get_definition_location()[1])[0]
start = lines.get_line_start(lineno)
end_line = logical_lines.logical_line_in(lineno)[1]
else:
scope = self.old_pyname.get_object().get_scope()
start = lines.get_line_start(scope.get_start())
end_line = scope.get_end()
# Include comment lines before the definition
start_line = lines.get_line_number(start)
while start_line > 1 and lines.get_line(start_line - 1).startswith('#'):
start_line -= 1
start = lines.get_line_start(start_line)
while end_line < lines.length() and \
lines.get_line(end_line + 1).strip() == '':
end_line += 1
end = min(lines.get_line_end(end_line) + 1, len(pymodule.source_code))
return start, end
def _add_imports2(self, pymodule, new_imports):
source = self.tools.add_imports(pymodule, new_imports)
if source is None:
return pymodule, False
else:
resource = pymodule.get_resource()
pymodule = libutils.get_string_module(
self.project, source, resource)
return pymodule, True
class MoveModule(object):
"""For moving modules and packages"""
def __init__(self, project, resource):
self.project = project
if not resource.is_folder() and resource.name == '__init__.py':
resource = resource.parent
if resource.is_folder() and not resource.has_child('__init__.py'):
raise exceptions.RefactoringError(
'Cannot move non-package folder.')
dummy_pymodule = libutils.get_string_module(self.project, '')
self.old_pyname = pynames.ImportedModule(dummy_pymodule,
resource=resource)
self.source = self.old_pyname.get_object().get_resource()
if self.source.is_folder():
self.old_name = self.source.name
else:
self.old_name = self.source.name[:-3]
self.tools = _MoveTools(self.project, self.source,
self.old_pyname, self.old_name)
self.import_tools = self.tools.import_tools
def get_changes(self, dest, resources=None,
task_handle=taskhandle.NullTaskHandle()):
if resources is None:
resources = self.project.get_python_files()
if dest is None or not dest.is_folder():
raise exceptions.RefactoringError(
'Move destination for modules should be packages.')
return self._calculate_changes(dest, resources, task_handle)
def _calculate_changes(self, dest, resources, task_handle):
changes = ChangeSet('Moving module <%s>' % self.old_name)
job_set = task_handle.create_jobset('Collecting changes',
len(resources))
for module in resources:
job_set.started_job(module.path)
if module == self.source:
self._change_moving_module(changes, dest)
else:
source = self._change_occurrences_in_module(dest,
resource=module)
if source is not None:
changes.add_change(ChangeContents(module, source))
job_set.finished_job()
if self.project == self.source.project:
changes.add_change(MoveResource(self.source, dest.path))
return changes
def _new_modname(self, dest):
destname = libutils.modname(dest)
if destname:
return destname + '.' + self.old_name
return self.old_name
def _new_import(self, dest):
return importutils.NormalImport([(self._new_modname(dest), None)])
def _change_moving_module(self, changes, dest):
if not self.source.is_folder():
pymodule = self.project.get_pymodule(self.source)
source = self.import_tools.relatives_to_absolutes(pymodule)
pymodule = self.tools.new_pymodule(pymodule, source)
source = self._change_occurrences_in_module(dest, pymodule)
source = self.tools.new_source(pymodule, source)
if source != self.source.read():
changes.add_change(ChangeContents(self.source, source))
def _change_occurrences_in_module(self, dest, pymodule=None,
resource=None):
if not self.tools.occurs_in_module(pymodule=pymodule,
resource=resource):
return
if pymodule is None:
pymodule = self.project.get_pymodule(resource)
new_name = self._new_modname(dest)
module_imports = importutils.get_module_imports(self.project, pymodule)
changed = False
source = None
if libutils.modname(dest):
changed = self._change_import_statements(dest, new_name,
module_imports)
if changed:
source = module_imports.get_changed_source()
source = self.tools.new_source(pymodule, source)
pymodule = self.tools.new_pymodule(pymodule, source)
new_import = self._new_import(dest)
source = self.tools.rename_in_module(
new_name, imports=True, pymodule=pymodule,
resource=resource if not changed else None)
should_import = self.tools.occurs_in_module(
pymodule=pymodule, resource=resource, imports=False)
pymodule = self.tools.new_pymodule(pymodule, source)
source = self.tools.remove_old_imports(pymodule)
if should_import:
pymodule = self.tools.new_pymodule(pymodule, source)
source = self.tools.add_imports(pymodule, [new_import])
source = self.tools.new_source(pymodule, source)
if source is not None and source != pymodule.resource.read():
return source
return None
def _change_import_statements(self, dest, new_name, module_imports):
moving_module = self.source
parent_module = moving_module.parent
changed = False
for import_stmt in module_imports.imports:
if not any(name_and_alias[0] == self.old_name
for name_and_alias in
import_stmt.import_info.names_and_aliases) and \
not any(name_and_alias[0] == libutils.modname(self.source)
for name_and_alias in
import_stmt.import_info.names_and_aliases):
continue
# Case 1: Look for normal imports of the moving module.
if isinstance(import_stmt.import_info, importutils.NormalImport):
continue
# Case 2: The moving module is from-imported.
changed = self._handle_moving_in_from_import_stmt(
dest, import_stmt, module_imports, parent_module) or changed
# Case 3: Names are imported from the moving module.
context = importutils.importinfo.ImportContext(self.project, None)
if not import_stmt.import_info.is_empty() and \
import_stmt.import_info.get_imported_resource(context) == \
moving_module:
import_stmt.import_info = importutils.FromImport(
new_name, import_stmt.import_info.level,
import_stmt.import_info.names_and_aliases)
changed = True
return changed
def _handle_moving_in_from_import_stmt(self, dest, import_stmt,
module_imports, parent_module):
changed = False
context = importutils.importinfo.ImportContext(self.project, None)
if import_stmt.import_info.get_imported_resource(context) == \
parent_module:
imports = import_stmt.import_info.names_and_aliases
new_imports = []
for name, alias in imports:
# The moving module was imported.
if name == self.old_name:
changed = True
new_import = importutils.FromImport(
libutils.modname(dest), 0,
[(self.old_name, alias)])
module_imports.add_import(new_import)
else:
new_imports.append((name, alias))
# Update the imports if the imported names were changed.
if new_imports != imports:
changed = True
if new_imports:
import_stmt.import_info = importutils.FromImport(
import_stmt.import_info.module_name,
import_stmt.import_info.level,
new_imports)
else:
import_stmt.empty_import()
return changed
class _ChangeMoveOccurrencesHandle(object):
def __init__(self, new_name):
self.new_name = new_name
self.occurred = False
def occurred_inside_skip(self, change_collector, occurrence):
pass
def occurred_outside_skip(self, change_collector, occurrence):
start, end = occurrence.get_primary_range()
change_collector.add_change(start, end, self.new_name)
self.occurred = True
class _MoveTools(object):
def __init__(self, project, source, pyname, old_name):
self.project = project
self.source = source
self.old_pyname = pyname
self.old_name = old_name
self.import_tools = importutils.ImportTools(self.project)
def remove_old_imports(self, pymodule):
old_source = pymodule.source_code
module_with_imports = self.import_tools.module_imports(pymodule)
class CanSelect(object):
changed = False
old_name = self.old_name
old_pyname = self.old_pyname
def __call__(self, name):
try:
if name == self.old_name and \
pymodule[name].get_object() == \
self.old_pyname.get_object():
self.changed = True
return False
except exceptions.AttributeNotFoundError:
pass
return True
can_select = CanSelect()
module_with_imports.filter_names(can_select)
new_source = module_with_imports.get_changed_source()
if old_source != new_source:
return new_source
def rename_in_module(self, new_name, pymodule=None,
imports=False, resource=None):
occurrence_finder = self._create_finder(imports)
source = rename.rename_in_module(
occurrence_finder, new_name, replace_primary=True,
pymodule=pymodule, resource=resource)
return source
def occurs_in_module(self, pymodule=None, resource=None, imports=True):
finder = self._create_finder(imports)
for occurrence in finder.find_occurrences(pymodule=pymodule,
resource=resource):
return True
return False
def _create_finder(self, imports):
return occurrences.create_finder(self.project, self.old_name,
self.old_pyname, imports=imports,
keywords=False)
def new_pymodule(self, pymodule, source):
if source is not None:
return libutils.get_string_module(
self.project, source, pymodule.get_resource())
return pymodule
def new_source(self, pymodule, source):
if source is None:
return pymodule.source_code
return source
def add_imports(self, pymodule, new_imports):
return _add_imports_to_module(self.import_tools, pymodule, new_imports)
def _add_imports_to_module(import_tools, pymodule, new_imports):
module_with_imports = import_tools.module_imports(pymodule)
for new_import in new_imports:
module_with_imports.add_import(new_import)
return module_with_imports.get_changed_source()
def moving_code_with_imports(project, resource, source):
import_tools = importutils.ImportTools(project)
pymodule = libutils.get_string_module(project, source, resource)
# Strip comment prefix, if any. These need to stay before the moving
# section, but imports would be added between them.
lines = codeanalyze.SourceLinesAdapter(source)
start = 1
while start < lines.length() and lines.get_line(start).startswith('#'):
start += 1
moving_prefix = source[:lines.get_line_start(start)]
pymodule = libutils.get_string_module(
project, source[lines.get_line_start(start):], resource)
origin = project.get_pymodule(resource)
imports = []
for stmt in import_tools.module_imports(origin).imports:
imports.append(stmt.import_info)
back_names = []
for name in origin:
if name not in pymodule:
back_names.append(name)
imports.append(import_tools.get_from_import(resource, back_names))
source = _add_imports_to_module(import_tools, pymodule, imports)
pymodule = libutils.get_string_module(project, source, resource)
source = import_tools.relatives_to_absolutes(pymodule)
pymodule = libutils.get_string_module(project, source, resource)
source = import_tools.organize_imports(pymodule, selfs=False)
pymodule = libutils.get_string_module(project, source, resource)
# extracting imports after changes
module_imports = import_tools.module_imports(pymodule)
imports = [import_stmt.import_info
for import_stmt in module_imports.imports]
start = 1
if module_imports.imports:
start = module_imports.imports[-1].end_line
lines = codeanalyze.SourceLinesAdapter(source)
while start < lines.length() and not lines.get_line(start).strip():
start += 1
# Reinsert the prefix which was removed at the beginning
moving = moving_prefix + source[lines.get_line_start(start):]
return moving, imports
class ModuleSkipRenamerHandle(object):
def occurred_outside_skip(self, change_collector, occurrence):
pass
def occurred_inside_skip(self, change_collector, occurrence):
pass
class ModuleSkipRenamer(object):
"""Rename occurrences in a module
This class can be used when you want to treat a region in a file
separately from other parts when renaming.
"""
def __init__(self, occurrence_finder, resource, handle=None,
skip_start=0, skip_end=0, replacement=''):
"""Constructor
if replacement is `None` the region is not changed. Otherwise
it is replaced with `replacement`.
"""
self.occurrence_finder = occurrence_finder
self.resource = resource
self.skip_start = skip_start
self.skip_end = skip_end
self.replacement = replacement
self.handle = handle
if self.handle is None:
self.handle = ModuleSkipRenamerHandle()
def get_changed_module(self):
source = self.resource.read()
change_collector = codeanalyze.ChangeCollector(source)
if self.replacement is not None:
change_collector.add_change(self.skip_start, self.skip_end,
self.replacement)
for occurrence in self.occurrence_finder.find_occurrences(
self.resource):
start, end = occurrence.get_primary_range()
if self.skip_start <= start < self.skip_end:
self.handle.occurred_inside_skip(change_collector, occurrence)
else:
self.handle.occurred_outside_skip(change_collector, occurrence)
result = change_collector.get_changed()
if result is not None and result != source:
return result | /ropee-0.13.3.tar.gz/ropee-0.13.3/rope/refactor/move.py | 0.716516 | 0.225672 | move.py | pypi |
import warnings
from rope.base import change, taskhandle, builtins, ast, codeanalyze
from rope.base import libutils
from rope.refactor import patchedast, similarfinder, sourceutils
from rope.refactor.importutils import module_imports
class Restructure(object):
"""A class to perform python restructurings
A restructuring transforms pieces of code matching `pattern` to
`goal`. In the `pattern` wildcards can appear. Wildcards match
some piece of code based on their kind and arguments that are
passed to them through `args`.
`args` is a dictionary of wildcard names to wildcard arguments.
If the argument is a tuple, the first item of the tuple is
considered to be the name of the wildcard to use; otherwise the
"default" wildcard is used. For getting the list arguments a
wildcard supports, see the pydoc of the wildcard. (see
`rope.refactor.wildcard.DefaultWildcard` for the default
wildcard.)
`wildcards` is the list of wildcard types that can appear in
`pattern`. See `rope.refactor.wildcards`. If a wildcard does not
specify its kind (by using a tuple in args), the wildcard named
"default" is used. So there should be a wildcard with "default"
name in `wildcards`.
`imports` is the list of imports that changed modules should
import. Note that rope handles duplicate imports and does not add
the import if it already appears.
Example #1::
pattern ${pyobject}.get_attribute(${name})
goal ${pyobject}[${name}]
args pyobject: instance=rope.base.pyobjects.PyObject
Example #2::
pattern ${name} in ${pyobject}.get_attributes()
goal ${name} in {pyobject}
args pyobject: instance=rope.base.pyobjects.PyObject
Example #3::
pattern ${pycore}.create_module(${project}.root, ${name})
goal generate.create_module(${project}, ${name})
imports
from rope.contrib import generate
args
project: type=rope.base.project.Project
Example #4::
pattern ${pow}(${param1}, ${param2})
goal ${param1} ** ${param2}
args pow: name=mod.pow, exact
Example #5::
pattern ${inst}.longtask(${p1}, ${p2})
goal
${inst}.subtask1(${p1})
${inst}.subtask2(${p2})
args
inst: type=mod.A,unsure
"""
def __init__(self, project, pattern, goal, args=None,
imports=None, wildcards=None):
"""Construct a restructuring
See class pydoc for more info about the arguments.
"""
self.project = project
self.pattern = pattern
self.goal = goal
self.args = args
if self.args is None:
self.args = {}
self.imports = imports
if self.imports is None:
self.imports = []
self.wildcards = wildcards
self.template = similarfinder.CodeTemplate(self.goal)
def get_changes(self, checks=None, imports=None, resources=None,
task_handle=taskhandle.NullTaskHandle()):
"""Get the changes needed by this restructuring
`resources` can be a list of `rope.base.resources.File`\s to
apply the restructuring on. If `None`, the restructuring will
be applied to all python files.
`checks` argument has been deprecated. Use the `args` argument
of the constructor. The usage of::
strchecks = {'obj1.type': 'mod.A', 'obj2': 'mod.B',
'obj3.object': 'mod.C'}
checks = restructuring.make_checks(strchecks)
can be replaced with::
args = {'obj1': 'type=mod.A', 'obj2': 'name=mod.B',
'obj3': 'object=mod.C'}
where obj1, obj2 and obj3 are wildcard names that appear
in restructuring pattern.
"""
if checks is not None:
warnings.warn(
'The use of checks parameter is deprecated; '
'use the args parameter of the constructor instead.',
DeprecationWarning, stacklevel=2)
for name, value in checks.items():
self.args[name] = similarfinder._pydefined_to_str(value)
if imports is not None:
warnings.warn(
'The use of imports parameter is deprecated; '
'use imports parameter of the constructor, instead.',
DeprecationWarning, stacklevel=2)
self.imports = imports
changes = change.ChangeSet('Restructuring <%s> to <%s>' %
(self.pattern, self.goal))
if resources is not None:
files = [resource for resource in resources
if libutils.is_python_file(self.project, resource)]
else:
files = self.project.get_python_files()
job_set = task_handle.create_jobset('Collecting Changes', len(files))
for resource in files:
job_set.started_job(resource.path)
pymodule = self.project.get_pymodule(resource)
finder = similarfinder.SimilarFinder(pymodule,
wildcards=self.wildcards)
matches = list(finder.get_matches(self.pattern, self.args))
computer = self._compute_changes(matches, pymodule)
result = computer.get_changed()
if result is not None:
imported_source = self._add_imports(resource, result,
self.imports)
changes.add_change(change.ChangeContents(resource,
imported_source))
job_set.finished_job()
return changes
def _compute_changes(self, matches, pymodule):
return _ChangeComputer(
pymodule.source_code, pymodule.get_ast(),
pymodule.lines, self.template, matches)
def _add_imports(self, resource, source, imports):
if not imports:
return source
import_infos = self._get_import_infos(resource, imports)
pymodule = libutils.get_string_module(self.project, source, resource)
imports = module_imports.ModuleImports(self.project, pymodule)
for import_info in import_infos:
imports.add_import(import_info)
return imports.get_changed_source()
def _get_import_infos(self, resource, imports):
pymodule = libutils.get_string_module(
self.project, '\n'.join(imports), resource)
imports = module_imports.ModuleImports(self.project, pymodule)
return [imports.import_info
for imports in imports.imports]
def make_checks(self, string_checks):
"""Convert str to str dicts to str to PyObject dicts
This function is here to ease writing a UI.
"""
checks = {}
for key, value in string_checks.items():
is_pyname = not key.endswith('.object') and \
not key.endswith('.type')
evaluated = self._evaluate(value, is_pyname=is_pyname)
if evaluated is not None:
checks[key] = evaluated
return checks
def _evaluate(self, code, is_pyname=True):
attributes = code.split('.')
pyname = None
if attributes[0] in ('__builtin__', '__builtins__'):
class _BuiltinsStub(object):
def get_attribute(self, name):
return builtins.builtins[name]
pyobject = _BuiltinsStub()
else:
pyobject = self.project.get_module(attributes[0])
for attribute in attributes[1:]:
pyname = pyobject[attribute]
if pyname is None:
return None
pyobject = pyname.get_object()
return pyname if is_pyname else pyobject
def replace(code, pattern, goal):
"""used by other refactorings"""
finder = similarfinder.RawSimilarFinder(code)
matches = list(finder.get_matches(pattern))
ast = patchedast.get_patched_ast(code)
lines = codeanalyze.SourceLinesAdapter(code)
template = similarfinder.CodeTemplate(goal)
computer = _ChangeComputer(code, ast, lines, template, matches)
result = computer.get_changed()
if result is None:
return code
return result
class _ChangeComputer(object):
def __init__(self, code, ast, lines, goal, matches):
self.source = code
self.goal = goal
self.matches = matches
self.ast = ast
self.lines = lines
self.matched_asts = {}
self._nearest_roots = {}
if self._is_expression():
for match in self.matches:
self.matched_asts[match.ast] = match
def get_changed(self):
if self._is_expression():
result = self._get_node_text(self.ast)
if result == self.source:
return None
return result
else:
collector = codeanalyze.ChangeCollector(self.source)
last_end = -1
for match in self.matches:
start, end = match.get_region()
if start < last_end:
if not self._is_expression():
continue
last_end = end
replacement = self._get_matched_text(match)
collector.add_change(start, end, replacement)
return collector.get_changed()
def _is_expression(self):
return self.matches and isinstance(self.matches[0],
similarfinder.ExpressionMatch)
def _get_matched_text(self, match):
mapping = {}
for name in self.goal.get_names():
node = match.get_ast(name)
if node is None:
raise similarfinder.BadNameInCheckError(
'Unknown name <%s>' % name)
force = self._is_expression() and match.ast == node
mapping[name] = self._get_node_text(node, force)
unindented = self.goal.substitute(mapping)
return self._auto_indent(match.get_region()[0], unindented)
def _get_node_text(self, node, force=False):
if not force and node in self.matched_asts:
return self._get_matched_text(self.matched_asts[node])
start, end = patchedast.node_region(node)
main_text = self.source[start:end]
collector = codeanalyze.ChangeCollector(main_text)
for node in self._get_nearest_roots(node):
sub_start, sub_end = patchedast.node_region(node)
collector.add_change(sub_start - start, sub_end - start,
self._get_node_text(node))
result = collector.get_changed()
if result is None:
return main_text
return result
def _auto_indent(self, offset, text):
lineno = self.lines.get_line_number(offset)
indents = sourceutils.get_indents(self.lines, lineno)
result = []
for index, line in enumerate(text.splitlines(True)):
if index != 0 and line.strip():
result.append(' ' * indents)
result.append(line)
return ''.join(result)
def _get_nearest_roots(self, node):
if node not in self._nearest_roots:
result = []
for child in ast.get_child_nodes(node):
if child in self.matched_asts:
result.append(child)
else:
result.extend(self._get_nearest_roots(child))
self._nearest_roots[node] = result
return self._nearest_roots[node] | /ropee-0.13.3.tar.gz/ropee-0.13.3/rope/refactor/restructure.py | 0.705481 | 0.227985 | restructure.py | pypi |
import re
from rope.base import codeanalyze
from rope.base import evaluate
from rope.base import exceptions
from rope.base import pynames
from rope.base import pyobjects
from rope.base import utils
from rope.base import worder
class Finder(object):
"""For finding occurrences of a name
The constructor takes a `filters` argument. It should be a list
of functions that take a single argument. For each possible
occurrence, these functions are called in order with the an
instance of `Occurrence`:
* If it returns `None` other filters are tried.
* If it returns `True`, the occurrence will be a match.
* If it returns `False`, the occurrence will be skipped.
* If all of the filters return `None`, it is skipped also.
"""
def __init__(self, project, name, filters=[lambda o: True], docs=False):
self.project = project
self.name = name
self.docs = docs
self.filters = filters
self._textual_finder = _TextualFinder(name, docs=docs)
def find_occurrences(self, resource=None, pymodule=None):
"""Generate `Occurrence` instances"""
tools = _OccurrenceToolsCreator(self.project, resource=resource,
pymodule=pymodule, docs=self.docs)
for offset in self._textual_finder.find_offsets(tools.source_code):
occurrence = Occurrence(tools, offset)
for filter in self.filters:
result = filter(occurrence)
if result is None:
continue
if result:
yield occurrence
break
def create_finder(project, name, pyname, only_calls=False, imports=True,
unsure=None, docs=False, instance=None, in_hierarchy=False,
keywords=True):
"""A factory for `Finder`
Based on the arguments it creates a list of filters. `instance`
argument is needed only when you want implicit interfaces to be
considered.
"""
pynames_ = set([pyname])
filters = []
if only_calls:
filters.append(CallsFilter())
if not imports:
filters.append(NoImportsFilter())
if not keywords:
filters.append(NoKeywordsFilter())
if isinstance(instance, pynames.ParameterName):
for pyobject in instance.get_objects():
try:
pynames_.add(pyobject[name])
except exceptions.AttributeNotFoundError:
pass
for pyname in pynames_:
filters.append(PyNameFilter(pyname))
if in_hierarchy:
filters.append(InHierarchyFilter(pyname))
if unsure:
filters.append(UnsureFilter(unsure))
return Finder(project, name, filters=filters, docs=docs)
class Occurrence(object):
def __init__(self, tools, offset):
self.tools = tools
self.offset = offset
self.resource = tools.resource
@utils.saveit
def get_word_range(self):
return self.tools.word_finder.get_word_range(self.offset)
@utils.saveit
def get_primary_range(self):
return self.tools.word_finder.get_primary_range(self.offset)
@utils.saveit
def get_pyname(self):
try:
return self.tools.name_finder.get_pyname_at(self.offset)
except exceptions.BadIdentifierError:
pass
@utils.saveit
def get_primary_and_pyname(self):
try:
return self.tools.name_finder.get_primary_and_pyname_at(
self.offset)
except exceptions.BadIdentifierError:
pass
@utils.saveit
def is_in_import_statement(self):
return (self.tools.word_finder.is_from_statement(self.offset) or
self.tools.word_finder.is_import_statement(self.offset))
def is_called(self):
return self.tools.word_finder.is_a_function_being_called(self.offset)
def is_defined(self):
return self.tools.word_finder.is_a_class_or_function_name_in_header(
self.offset)
def is_a_fixed_primary(self):
return self.tools.word_finder.is_a_class_or_function_name_in_header(
self.offset) or \
self.tools.word_finder.is_a_name_after_from_import(self.offset)
def is_written(self):
return self.tools.word_finder.is_assigned_here(self.offset)
def is_unsure(self):
return unsure_pyname(self.get_pyname())
def is_function_keyword_parameter(self):
return self.tools.word_finder.is_function_keyword_parameter(
self.offset)
@property
@utils.saveit
def lineno(self):
offset = self.get_word_range()[0]
return self.tools.pymodule.lines.get_line_number(offset)
def same_pyname(expected, pyname):
"""Check whether `expected` and `pyname` are the same"""
if expected is None or pyname is None:
return False
if expected == pyname:
return True
if type(expected) not in (pynames.ImportedModule, pynames.ImportedName) \
and type(pyname) not in \
(pynames.ImportedModule, pynames.ImportedName):
return False
return expected.get_definition_location() == \
pyname.get_definition_location() and \
expected.get_object() == pyname.get_object()
def unsure_pyname(pyname, unbound=True):
"""Return `True` if we don't know what this name references"""
if pyname is None:
return True
if unbound and not isinstance(pyname, pynames.UnboundName):
return False
if pyname.get_object() == pyobjects.get_unknown():
return True
class PyNameFilter(object):
"""For finding occurrences of a name."""
def __init__(self, pyname):
self.pyname = pyname
def __call__(self, occurrence):
if same_pyname(self.pyname, occurrence.get_pyname()):
return True
class InHierarchyFilter(object):
"""Finds the occurrence if the name is in the class's hierarchy."""
def __init__(self, pyname, implementations_only=False):
self.pyname = pyname
self.impl_only = implementations_only
self.pyclass = self._get_containing_class(pyname)
if self.pyclass is not None:
self.name = pyname.get_object().get_name()
self.roots = self._get_root_classes(self.pyclass, self.name)
else:
self.roots = None
def __call__(self, occurrence):
if self.roots is None:
return
pyclass = self._get_containing_class(occurrence.get_pyname())
if pyclass is not None:
roots = self._get_root_classes(pyclass, self.name)
if self.roots.intersection(roots):
return True
def _get_containing_class(self, pyname):
if isinstance(pyname, pynames.DefinedName):
scope = pyname.get_object().get_scope()
parent = scope.parent
if parent is not None and parent.get_kind() == 'Class':
return parent.pyobject
def _get_root_classes(self, pyclass, name):
if self.impl_only and pyclass == self.pyclass:
return set([pyclass])
result = set()
for superclass in pyclass.get_superclasses():
if name in superclass:
result.update(self._get_root_classes(superclass, name))
if not result:
return set([pyclass])
return result
class UnsureFilter(object):
"""Occurrences where we don't knoow what the name references."""
def __init__(self, unsure):
self.unsure = unsure
def __call__(self, occurrence):
if occurrence.is_unsure() and self.unsure(occurrence):
return True
class NoImportsFilter(object):
"""Don't include import statements as occurrences."""
def __call__(self, occurrence):
if occurrence.is_in_import_statement():
return False
class CallsFilter(object):
"""Filter out non-call occurrences."""
def __call__(self, occurrence):
if not occurrence.is_called():
return False
class NoKeywordsFilter(object):
"""Filter out keyword parameters."""
def __call__(self, occurrence):
if occurrence.is_function_keyword_parameter():
return False
class _TextualFinder(object):
def __init__(self, name, docs=False):
self.name = name
self.docs = docs
self.comment_pattern = _TextualFinder.any('comment', [r'#[^\n]*'])
self.string_pattern = _TextualFinder.any(
'string', [codeanalyze.get_string_pattern()])
self.pattern = self._get_occurrence_pattern(self.name)
def find_offsets(self, source):
if not self._fast_file_query(source):
return
if self.docs:
searcher = self._normal_search
else:
searcher = self._re_search
for matched in searcher(source):
yield matched
def _re_search(self, source):
for match in self.pattern.finditer(source):
for key, value in match.groupdict().items():
if value and key == 'occurrence':
yield match.start(key)
def _normal_search(self, source):
current = 0
while True:
try:
found = source.index(self.name, current)
current = found + len(self.name)
if (found == 0 or
not self._is_id_char(source[found - 1])) and \
(current == len(source) or
not self._is_id_char(source[current])):
yield found
except ValueError:
break
def _is_id_char(self, c):
return c.isalnum() or c == '_'
def _fast_file_query(self, source):
try:
source.index(self.name)
return True
except ValueError:
return False
def _get_source(self, resource, pymodule):
if resource is not None:
return resource.read()
else:
return pymodule.source_code
def _get_occurrence_pattern(self, name):
occurrence_pattern = _TextualFinder.any('occurrence',
['\\b' + name + '\\b'])
pattern = re.compile(occurrence_pattern + '|' + self.comment_pattern +
'|' + self.string_pattern)
return pattern
@staticmethod
def any(name, list_):
return '(?P<%s>' % name + '|'.join(list_) + ')'
class _OccurrenceToolsCreator(object):
def __init__(self, project, resource=None, pymodule=None, docs=False):
self.project = project
self.__resource = resource
self.__pymodule = pymodule
self.docs = docs
@property
@utils.saveit
def name_finder(self):
return evaluate.ScopeNameFinder(self.pymodule)
@property
@utils.saveit
def source_code(self):
if self.__resource is not None:
return self.resource.read()
else:
return self.pymodule.source_code
@property
@utils.saveit
def word_finder(self):
return worder.Worder(self.source_code, self.docs)
@property
@utils.saveit
def resource(self):
if self.__resource is not None:
return self.__resource
if self.__pymodule is not None:
return self.__pymodule.resource
@property
@utils.saveit
def pymodule(self):
if self.__pymodule is not None:
return self.__pymodule
return self.project.get_pymodule(self.resource) | /ropee-0.13.3.tar.gz/ropee-0.13.3/rope/refactor/occurrences.py | 0.732496 | 0.366817 | occurrences.py | pypi |
import warnings
from rope.base import (exceptions, pyobjects, pynames, taskhandle,
evaluate, worder, codeanalyze, libutils)
from rope.base.change import ChangeSet, ChangeContents, MoveResource
from rope.refactor import occurrences
class Rename(object):
"""A class for performing rename refactoring
It can rename everything: classes, functions, modules, packages,
methods, variables and keyword arguments.
"""
def __init__(self, project, resource, offset=None):
"""If `offset` is None, the `resource` itself will be renamed"""
self.project = project
self.resource = resource
if offset is not None:
self.old_name = worder.get_name_at(self.resource, offset)
this_pymodule = self.project.get_pymodule(self.resource)
self.old_instance, self.old_pyname = \
evaluate.eval_location2(this_pymodule, offset)
if self.old_pyname is None:
raise exceptions.RefactoringError(
'Rename refactoring should be performed'
' on resolvable python identifiers.')
else:
if not resource.is_folder() and resource.name == '__init__.py':
resource = resource.parent
dummy_pymodule = libutils.get_string_module(self.project, '')
self.old_instance = None
self.old_pyname = pynames.ImportedModule(dummy_pymodule,
resource=resource)
if resource.is_folder():
self.old_name = resource.name
else:
self.old_name = resource.name[:-3]
def get_old_name(self):
return self.old_name
def get_changes(self, new_name, in_file=None, in_hierarchy=False,
unsure=None, docs=False, resources=None,
task_handle=taskhandle.NullTaskHandle()):
"""Get the changes needed for this refactoring
Parameters:
- `in_hierarchy`: when renaming a method this keyword forces
to rename all matching methods in the hierarchy
- `docs`: when `True` rename refactoring will rename
occurrences in comments and strings where the name is
visible. Setting it will make renames faster, too.
- `unsure`: decides what to do about unsure occurrences.
If `None`, they are ignored. Otherwise `unsure` is
called with an instance of `occurrence.Occurrence` as
parameter. If it returns `True`, the occurrence is
considered to be a match.
- `resources` can be a list of `rope.base.resources.File`\s to
apply this refactoring on. If `None`, the restructuring
will be applied to all python files.
- `in_file`: this argument has been deprecated; use
`resources` instead.
"""
if unsure in (True, False):
warnings.warn(
'unsure parameter should be a function that returns '
'True or False', DeprecationWarning, stacklevel=2)
def unsure_func(value=unsure):
return value
unsure = unsure_func
if in_file is not None:
warnings.warn(
'`in_file` argument has been deprecated; use `resources` '
'instead. ', DeprecationWarning, stacklevel=2)
if in_file:
resources = [self.resource]
if _is_local(self.old_pyname):
resources = [self.resource]
if resources is None:
resources = self.project.get_python_files()
changes = ChangeSet('Renaming <%s> to <%s>' %
(self.old_name, new_name))
finder = occurrences.create_finder(
self.project, self.old_name, self.old_pyname, unsure=unsure,
docs=docs, instance=self.old_instance,
in_hierarchy=in_hierarchy and self.is_method())
job_set = task_handle.create_jobset('Collecting Changes',
len(resources))
for file_ in resources:
job_set.started_job(file_.path)
new_content = rename_in_module(finder, new_name, resource=file_)
if new_content is not None:
changes.add_change(ChangeContents(file_, new_content))
job_set.finished_job()
if self._is_renaming_a_module():
resource = self.old_pyname.get_object().get_resource()
if self._is_allowed_to_move(resources, resource):
self._rename_module(resource, new_name, changes)
return changes
def _is_allowed_to_move(self, resources, resource):
if resource.is_folder():
try:
return resource.get_child('__init__.py') in resources
except exceptions.ResourceNotFoundError:
return False
else:
return resource in resources
def _is_renaming_a_module(self):
if isinstance(self.old_pyname.get_object(), pyobjects.AbstractModule):
return True
return False
def is_method(self):
pyname = self.old_pyname
return isinstance(pyname, pynames.DefinedName) and \
isinstance(pyname.get_object(), pyobjects.PyFunction) and \
isinstance(pyname.get_object().parent, pyobjects.PyClass)
def _rename_module(self, resource, new_name, changes):
if not resource.is_folder():
new_name = new_name + '.py'
parent_path = resource.parent.path
if parent_path == '':
new_location = new_name
else:
new_location = parent_path + '/' + new_name
changes.add_change(MoveResource(resource, new_location))
class ChangeOccurrences(object):
"""A class for changing the occurrences of a name in a scope
This class replaces the occurrences of a name. Note that it only
changes the scope containing the offset passed to the constructor.
What's more it does not have any side-effects. That is for
example changing occurrences of a module does not rename the
module; it merely replaces the occurrences of that module in a
scope with the given expression. This class is useful for
performing many custom refactorings.
"""
def __init__(self, project, resource, offset):
self.project = project
self.resource = resource
self.offset = offset
self.old_name = worder.get_name_at(resource, offset)
self.pymodule = project.get_pymodule(self.resource)
self.old_pyname = evaluate.eval_location(self.pymodule, offset)
def get_old_name(self):
word_finder = worder.Worder(self.resource.read())
return word_finder.get_primary_at(self.offset)
def _get_scope_offset(self):
lines = self.pymodule.lines
scope = self.pymodule.get_scope().\
get_inner_scope_for_line(lines.get_line_number(self.offset))
start = lines.get_line_start(scope.get_start())
end = lines.get_line_end(scope.get_end())
return start, end
def get_changes(self, new_name, only_calls=False, reads=True, writes=True):
changes = ChangeSet('Changing <%s> occurrences to <%s>' %
(self.old_name, new_name))
scope_start, scope_end = self._get_scope_offset()
finder = occurrences.create_finder(
self.project, self.old_name, self.old_pyname,
imports=False, only_calls=only_calls)
new_contents = rename_in_module(
finder, new_name, pymodule=self.pymodule, replace_primary=True,
region=(scope_start, scope_end), reads=reads, writes=writes)
if new_contents is not None:
changes.add_change(ChangeContents(self.resource, new_contents))
return changes
def rename_in_module(occurrences_finder, new_name, resource=None,
pymodule=None, replace_primary=False, region=None,
reads=True, writes=True):
"""Returns the changed source or `None` if there is no changes"""
if resource is not None:
source_code = resource.read()
else:
source_code = pymodule.source_code
change_collector = codeanalyze.ChangeCollector(source_code)
for occurrence in occurrences_finder.find_occurrences(resource, pymodule):
if replace_primary and occurrence.is_a_fixed_primary():
continue
if replace_primary:
start, end = occurrence.get_primary_range()
else:
start, end = occurrence.get_word_range()
if (not reads and not occurrence.is_written()) or \
(not writes and occurrence.is_written()):
continue
if region is None or region[0] <= start < region[1]:
change_collector.add_change(start, end, new_name)
return change_collector.get_changed()
def _is_local(pyname):
module, lineno = pyname.get_definition_location()
if lineno is None:
return False
scope = module.get_scope().get_inner_scope_for_line(lineno)
if isinstance(pyname, pynames.DefinedName) and \
scope.get_kind() in ('Function', 'Class'):
scope = scope.parent
return scope.get_kind() == 'Function' and \
pyname in scope.get_names().values() and \
isinstance(pyname, pynames.AssignedName) | /ropee-0.13.3.tar.gz/ropee-0.13.3/rope/refactor/rename.py | 0.644449 | 0.181444 | rename.py | pypi |
import rope.base.change
from rope.base import exceptions, evaluate, worder, codeanalyze
from rope.refactor import functionutils, sourceutils, occurrences
class IntroduceParameter(object):
"""Introduce parameter refactoring
This refactoring adds a new parameter to a function and replaces
references to an expression in it with the new parameter.
The parameter finding part is different from finding similar
pieces in extract refactorings. In this refactoring parameters
are found based on the object they reference to. For instance
in::
class A(object):
var = None
class B(object):
a = A()
b = B()
a = b.a
def f(a):
x = b.a.var + a.var
using this refactoring on ``a.var`` with ``p`` as the new
parameter name, will result in::
def f(p=a.var):
x = p + p
"""
def __init__(self, project, resource, offset):
self.project = project
self.resource = resource
self.offset = offset
self.pymodule = self.project.get_pymodule(self.resource)
scope = self.pymodule.get_scope().get_inner_scope_for_offset(offset)
if scope.get_kind() != 'Function':
raise exceptions.RefactoringError(
'Introduce parameter should be performed inside functions')
self.pyfunction = scope.pyobject
self.name, self.pyname = self._get_name_and_pyname()
if self.pyname is None:
raise exceptions.RefactoringError(
'Cannot find the definition of <%s>' % self.name)
def _get_primary(self):
word_finder = worder.Worder(self.resource.read())
return word_finder.get_primary_at(self.offset)
def _get_name_and_pyname(self):
return (worder.get_name_at(self.resource, self.offset),
evaluate.eval_location(self.pymodule, self.offset))
def get_changes(self, new_parameter):
definition_info = functionutils.DefinitionInfo.read(self.pyfunction)
definition_info.args_with_defaults.append((new_parameter,
self._get_primary()))
collector = codeanalyze.ChangeCollector(self.resource.read())
header_start, header_end = self._get_header_offsets()
body_start, body_end = sourceutils.get_body_region(self.pyfunction)
collector.add_change(header_start, header_end,
definition_info.to_string())
self._change_function_occurances(collector, body_start,
body_end, new_parameter)
changes = rope.base.change.ChangeSet('Introduce parameter <%s>' %
new_parameter)
change = rope.base.change.ChangeContents(self.resource,
collector.get_changed())
changes.add_change(change)
return changes
def _get_header_offsets(self):
lines = self.pymodule.lines
start_line = self.pyfunction.get_scope().get_start()
end_line = self.pymodule.logical_lines.\
logical_line_in(start_line)[1]
start = lines.get_line_start(start_line)
end = lines.get_line_end(end_line)
start = self.pymodule.source_code.find('def', start) + 4
end = self.pymodule.source_code.rfind(':', start, end)
return start, end
def _change_function_occurances(self, collector, function_start,
function_end, new_name):
finder = occurrences.create_finder(self.project, self.name,
self.pyname)
for occurrence in finder.find_occurrences(resource=self.resource):
start, end = occurrence.get_primary_range()
if function_start <= start < function_end:
collector.add_change(start, end, new_name) | /ropee-0.13.3.tar.gz/ropee-0.13.3/rope/refactor/introduce_parameter.py | 0.655005 | 0.374934 | introduce_parameter.py | pypi |
from rope.base import ast
from rope.base.utils import pycompat
def find_visible(node, lines):
"""Return the line which is visible from all `lines`"""
root = ast_suite_tree(node)
return find_visible_for_suite(root, lines)
def find_visible_for_suite(root, lines):
if len(lines) == 1:
return lines[0]
line1 = lines[0]
line2 = find_visible_for_suite(root, lines[1:])
suite1 = root.find_suite(line1)
suite2 = root.find_suite(line2)
def valid(suite):
return suite is not None and not suite.ignored
if valid(suite1) and not valid(suite2):
return line1
if not valid(suite1) and valid(suite2):
return line2
if not valid(suite1) and not valid(suite2):
return None
while suite1 != suite2 and suite1.parent != suite2.parent:
if suite1._get_level() < suite2._get_level():
line2 = suite2.get_start()
suite2 = suite2.parent
elif suite1._get_level() > suite2._get_level():
line1 = suite1.get_start()
suite1 = suite1.parent
else:
line1 = suite1.get_start()
line2 = suite2.get_start()
suite1 = suite1.parent
suite2 = suite2.parent
if suite1 == suite2:
return min(line1, line2)
return min(suite1.get_start(), suite2.get_start())
def ast_suite_tree(node):
if hasattr(node, 'lineno'):
lineno = node.lineno
else:
lineno = 1
return Suite(node.body, lineno)
class Suite(object):
def __init__(self, child_nodes, lineno, parent=None, ignored=False):
self.parent = parent
self.lineno = lineno
self.child_nodes = child_nodes
self._children = None
self.ignored = ignored
def get_start(self):
if self.parent is None:
if self.child_nodes:
return self.local_start()
else:
return 1
return self.lineno
def get_children(self):
if self._children is None:
walker = _SuiteWalker(self)
for child in self.child_nodes:
ast.walk(child, walker)
self._children = walker.suites
return self._children
def local_start(self):
return self.child_nodes[0].lineno
def local_end(self):
end = self.child_nodes[-1].lineno
if self.get_children():
end = max(end, self.get_children()[-1].local_end())
return end
def find_suite(self, line):
if line is None:
return None
for child in self.get_children():
if child.local_start() <= line <= child.local_end():
return child.find_suite(line)
return self
def _get_level(self):
if self.parent is None:
return 0
return self.parent._get_level() + 1
class _SuiteWalker(object):
def __init__(self, suite):
self.suite = suite
self.suites = []
def _If(self, node):
self._add_if_like_node(node)
def _For(self, node):
self._add_if_like_node(node)
def _While(self, node):
self._add_if_like_node(node)
def _With(self, node):
self.suites.append(Suite(node.body, node.lineno, self.suite))
def _TryFinally(self, node):
proceed_to_except_handler = False
if len(node.finalbody) == 1:
if pycompat.PY2:
proceed_to_except_handler = isinstance(node.body[0], ast.TryExcept)
elif pycompat.PY3:
try:
proceed_to_except_handler = isinstance(node.handlers[0], ast.ExceptHandler)
except IndexError:
pass
if proceed_to_except_handler:
self._TryExcept(node if pycompat.PY3 else node.body[0])
else:
self.suites.append(Suite(node.body, node.lineno, self.suite))
self.suites.append(Suite(node.finalbody, node.lineno, self.suite))
def _Try(self, node):
if len(node.finalbody) == 1:
self._TryFinally(node)
else:
self._TryExcept(node)
def _TryExcept(self, node):
self.suites.append(Suite(node.body, node.lineno, self.suite))
for handler in node.handlers:
self.suites.append(Suite(handler.body, node.lineno, self.suite))
if node.orelse:
self.suites.append(Suite(node.orelse, node.lineno, self.suite))
def _add_if_like_node(self, node):
self.suites.append(Suite(node.body, node.lineno, self.suite))
if node.orelse:
self.suites.append(Suite(node.orelse, node.lineno, self.suite))
def _FunctionDef(self, node):
self.suites.append(Suite(node.body, node.lineno,
self.suite, ignored=True))
def _ClassDef(self, node):
self.suites.append(Suite(node.body, node.lineno,
self.suite, ignored=True)) | /ropee-0.13.3.tar.gz/ropee-0.13.3/rope/refactor/suites.py | 0.612773 | 0.209611 | suites.py | pypi |
import re
import rope.refactor.wildcards
from rope.base import libutils
from rope.base import codeanalyze, exceptions, ast, builtins
from rope.refactor import (patchedast, wildcards)
from rope.refactor.patchedast import MismatchedTokenError
class BadNameInCheckError(exceptions.RefactoringError):
pass
class SimilarFinder(object):
"""`SimilarFinder` can be used to find similar pieces of code
See the notes in the `rope.refactor.restructure` module for more
info.
"""
def __init__(self, pymodule, wildcards=None):
"""Construct a SimilarFinder"""
self.source = pymodule.source_code
try:
self.raw_finder = RawSimilarFinder(
pymodule.source_code, pymodule.get_ast(), self._does_match)
except MismatchedTokenError:
print("in file %s" % pymodule.resource.path)
raise
self.pymodule = pymodule
if wildcards is None:
self.wildcards = {}
for wildcard in [rope.refactor.wildcards.
DefaultWildcard(pymodule.pycore.project)]:
self.wildcards[wildcard.get_name()] = wildcard
else:
self.wildcards = wildcards
def get_matches(self, code, args={}, start=0, end=None):
self.args = args
if end is None:
end = len(self.source)
skip_region = None
if 'skip' in args.get('', {}):
resource, region = args['']['skip']
if resource == self.pymodule.get_resource():
skip_region = region
return self.raw_finder.get_matches(code, start=start, end=end,
skip=skip_region)
def get_match_regions(self, *args, **kwds):
for match in self.get_matches(*args, **kwds):
yield match.get_region()
def _does_match(self, node, name):
arg = self.args.get(name, '')
kind = 'default'
if isinstance(arg, (tuple, list)):
kind = arg[0]
arg = arg[1]
suspect = wildcards.Suspect(self.pymodule, node, name)
return self.wildcards[kind].matches(suspect, arg)
class RawSimilarFinder(object):
"""A class for finding similar expressions and statements"""
def __init__(self, source, node=None, does_match=None):
if node is None:
node = ast.parse(source)
if does_match is None:
self.does_match = self._simple_does_match
else:
self.does_match = does_match
self._init_using_ast(node, source)
def _simple_does_match(self, node, name):
return isinstance(node, (ast.expr, ast.Name))
def _init_using_ast(self, node, source):
self.source = source
self._matched_asts = {}
if not hasattr(node, 'region'):
patchedast.patch_ast(node, source)
self.ast = node
def get_matches(self, code, start=0, end=None, skip=None):
"""Search for `code` in source and return a list of `Match`\es
`code` can contain wildcards. ``${name}`` matches normal
names and ``${?name} can match any expression. You can use
`Match.get_ast()` for getting the node that has matched a
given pattern.
"""
if end is None:
end = len(self.source)
for match in self._get_matched_asts(code):
match_start, match_end = match.get_region()
if start <= match_start and match_end <= end:
if skip is not None and (skip[0] < match_end and
skip[1] > match_start):
continue
yield match
def _get_matched_asts(self, code):
if code not in self._matched_asts:
wanted = self._create_pattern(code)
matches = _ASTMatcher(self.ast, wanted,
self.does_match).find_matches()
self._matched_asts[code] = matches
return self._matched_asts[code]
def _create_pattern(self, expression):
expression = self._replace_wildcards(expression)
node = ast.parse(expression)
# Getting Module.Stmt.nodes
nodes = node.body
if len(nodes) == 1 and isinstance(nodes[0], ast.Expr):
# Getting Discard.expr
wanted = nodes[0].value
else:
wanted = nodes
return wanted
def _replace_wildcards(self, expression):
ropevar = _RopeVariable()
template = CodeTemplate(expression)
mapping = {}
for name in template.get_names():
mapping[name] = ropevar.get_var(name)
return template.substitute(mapping)
class _ASTMatcher(object):
def __init__(self, body, pattern, does_match):
"""Searches the given pattern in the body AST.
body is an AST node and pattern can be either an AST node or
a list of ASTs nodes
"""
self.body = body
self.pattern = pattern
self.matches = None
self.ropevar = _RopeVariable()
self.matches_callback = does_match
def find_matches(self):
if self.matches is None:
self.matches = []
ast.call_for_nodes(self.body, self._check_node, recursive=True)
return self.matches
def _check_node(self, node):
if isinstance(self.pattern, list):
self._check_statements(node)
else:
self._check_expression(node)
def _check_expression(self, node):
mapping = {}
if self._match_nodes(self.pattern, node, mapping):
self.matches.append(ExpressionMatch(node, mapping))
def _check_statements(self, node):
for child in ast.get_children(node):
if isinstance(child, (list, tuple)):
self.__check_stmt_list(child)
def __check_stmt_list(self, nodes):
for index in range(len(nodes)):
if len(nodes) - index >= len(self.pattern):
current_stmts = nodes[index:index + len(self.pattern)]
mapping = {}
if self._match_stmts(current_stmts, mapping):
self.matches.append(StatementMatch(current_stmts, mapping))
def _match_nodes(self, expected, node, mapping):
if isinstance(expected, ast.Name):
if self.ropevar.is_var(expected.id):
return self._match_wildcard(expected, node, mapping)
if not isinstance(expected, ast.AST):
return expected == node
if expected.__class__ != node.__class__:
return False
children1 = self._get_children(expected)
children2 = self._get_children(node)
if len(children1) != len(children2):
return False
for child1, child2 in zip(children1, children2):
if isinstance(child1, ast.AST):
if not self._match_nodes(child1, child2, mapping):
return False
elif isinstance(child1, (list, tuple)):
if not isinstance(child2, (list, tuple)) or \
len(child1) != len(child2):
return False
for c1, c2 in zip(child1, child2):
if not self._match_nodes(c1, c2, mapping):
return False
else:
if child1 != child2:
return False
return True
def _get_children(self, node):
"""Return not `ast.expr_context` children of `node`"""
children = ast.get_children(node)
return [child for child in children
if not isinstance(child, ast.expr_context)]
def _match_stmts(self, current_stmts, mapping):
if len(current_stmts) != len(self.pattern):
return False
for stmt, expected in zip(current_stmts, self.pattern):
if not self._match_nodes(expected, stmt, mapping):
return False
return True
def _match_wildcard(self, node1, node2, mapping):
name = self.ropevar.get_base(node1.id)
if name not in mapping:
if self.matches_callback(node2, name):
mapping[name] = node2
return True
return False
else:
return self._match_nodes(mapping[name], node2, {})
class Match(object):
def __init__(self, mapping):
self.mapping = mapping
def get_region(self):
"""Returns match region"""
def get_ast(self, name):
"""Return the ast node that has matched rope variables"""
return self.mapping.get(name, None)
class ExpressionMatch(Match):
def __init__(self, ast, mapping):
super(ExpressionMatch, self).__init__(mapping)
self.ast = ast
def get_region(self):
return self.ast.region
class StatementMatch(Match):
def __init__(self, ast_list, mapping):
super(StatementMatch, self).__init__(mapping)
self.ast_list = ast_list
def get_region(self):
return self.ast_list[0].region[0], self.ast_list[-1].region[1]
class CodeTemplate(object):
def __init__(self, template):
self.template = template
self._find_names()
def _find_names(self):
self.names = {}
for match in CodeTemplate._get_pattern().finditer(self.template):
if 'name' in match.groupdict() and \
match.group('name') is not None:
start, end = match.span('name')
name = self.template[start + 2:end - 1]
if name not in self.names:
self.names[name] = []
self.names[name].append((start, end))
def get_names(self):
return self.names.keys()
def substitute(self, mapping):
collector = codeanalyze.ChangeCollector(self.template)
for name, occurrences in self.names.items():
for region in occurrences:
collector.add_change(region[0], region[1], mapping[name])
result = collector.get_changed()
if result is None:
return self.template
return result
_match_pattern = None
@classmethod
def _get_pattern(cls):
if cls._match_pattern is None:
pattern = codeanalyze.get_comment_pattern() + '|' + \
codeanalyze.get_string_pattern() + '|' + \
r'(?P<name>\$\{[^\s\$\}]*\})'
cls._match_pattern = re.compile(pattern)
return cls._match_pattern
class _RopeVariable(object):
"""Transform and identify rope inserted wildcards"""
_normal_prefix = '__rope__variable_normal_'
_any_prefix = '__rope__variable_any_'
def get_var(self, name):
if name.startswith('?'):
return self._get_any(name)
else:
return self._get_normal(name)
def is_var(self, name):
return self._is_normal(name) or self._is_var(name)
def get_base(self, name):
if self._is_normal(name):
return name[len(self._normal_prefix):]
if self._is_var(name):
return '?' + name[len(self._any_prefix):]
def _get_normal(self, name):
return self._normal_prefix + name
def _get_any(self, name):
return self._any_prefix + name[1:]
def _is_normal(self, name):
return name.startswith(self._normal_prefix)
def _is_var(self, name):
return name.startswith(self._any_prefix)
def make_pattern(code, variables):
variables = set(variables)
collector = codeanalyze.ChangeCollector(code)
def does_match(node, name):
return isinstance(node, ast.Name) and node.id == name
finder = RawSimilarFinder(code, does_match=does_match)
for variable in variables:
for match in finder.get_matches('${%s}' % variable):
start, end = match.get_region()
collector.add_change(start, end, '${%s}' % variable)
result = collector.get_changed()
return result if result is not None else code
def _pydefined_to_str(pydefined):
address = []
if isinstance(pydefined,
(builtins.BuiltinClass, builtins.BuiltinFunction)):
return '__builtins__.' + pydefined.get_name()
else:
while pydefined.parent is not None:
address.insert(0, pydefined.get_name())
pydefined = pydefined.parent
module_name = libutils.modname(pydefined.resource)
return '.'.join(module_name.split('.') + address) | /ropee-0.13.3.tar.gz/ropee-0.13.3/rope/refactor/similarfinder.py | 0.639961 | 0.187839 | similarfinder.py | pypi |
from rope.base import ast, evaluate, builtins, pyobjects
from rope.refactor import patchedast, occurrences
class Wildcard(object):
def get_name(self):
"""Return the name of this wildcard"""
def matches(self, suspect, arg):
"""Return `True` if `suspect` matches this wildcard"""
class Suspect(object):
def __init__(self, pymodule, node, name):
self.name = name
self.pymodule = pymodule
self.node = node
class DefaultWildcard(object):
"""The default restructuring wildcard
The argument passed to this wildcard is in the
``key1=value1,key2=value2,...`` format. Possible keys are:
* name - for checking the reference
* type - for checking the type
* object - for checking the object
* instance - for checking types but similar to builtin isinstance
* exact - matching only occurrences with the same name as the wildcard
* unsure - matching unsure occurrences
"""
def __init__(self, project):
self.project = project
def get_name(self):
return 'default'
def matches(self, suspect, arg=''):
args = parse_arg(arg)
if not self._check_exact(args, suspect):
return False
if not self._check_object(args, suspect):
return False
return True
def _check_object(self, args, suspect):
kind = None
expected = None
unsure = args.get('unsure', False)
for check in ['name', 'object', 'type', 'instance']:
if check in args:
kind = check
expected = args[check]
if expected is not None:
checker = _CheckObject(self.project, expected,
kind, unsure=unsure)
return checker(suspect.pymodule, suspect.node)
return True
def _check_exact(self, args, suspect):
node = suspect.node
if args.get('exact'):
if not isinstance(node, ast.Name) or not node.id == suspect.name:
return False
else:
if not isinstance(node, ast.expr):
return False
return True
def parse_arg(arg):
if isinstance(arg, dict):
return arg
result = {}
tokens = arg.split(',')
for token in tokens:
if '=' in token:
parts = token.split('=', 1)
result[parts[0].strip()] = parts[1].strip()
else:
result[token.strip()] = True
return result
class _CheckObject(object):
def __init__(self, project, expected, kind='object', unsure=False):
self.project = project
self.kind = kind
self.unsure = unsure
self.expected = self._evaluate(expected)
def __call__(self, pymodule, node):
pyname = self._evaluate_node(pymodule, node)
if pyname is None or self.expected is None:
return self.unsure
if self._unsure_pyname(pyname, unbound=self.kind == 'name'):
return True
if self.kind == 'name':
return self._same_pyname(self.expected, pyname)
else:
pyobject = pyname.get_object()
if self.kind == 'object':
objects = [pyobject]
if self.kind == 'type':
objects = [pyobject.get_type()]
if self.kind == 'instance':
objects = [pyobject]
objects.extend(self._get_super_classes(pyobject))
objects.extend(self._get_super_classes(pyobject.get_type()))
for pyobject in objects:
if self._same_pyobject(self.expected.get_object(), pyobject):
return True
return False
def _get_super_classes(self, pyobject):
result = []
if isinstance(pyobject, pyobjects.AbstractClass):
for superclass in pyobject.get_superclasses():
result.append(superclass)
result.extend(self._get_super_classes(superclass))
return result
def _same_pyobject(self, expected, pyobject):
return expected == pyobject
def _same_pyname(self, expected, pyname):
return occurrences.same_pyname(expected, pyname)
def _unsure_pyname(self, pyname, unbound=True):
return self.unsure and occurrences.unsure_pyname(pyname, unbound)
def _split_name(self, name):
parts = name.split('.')
expression, kind = parts[0], parts[-1]
if len(parts) == 1:
kind = 'name'
return expression, kind
def _evaluate_node(self, pymodule, node):
scope = pymodule.get_scope().get_inner_scope_for_line(node.lineno)
expression = node
if isinstance(expression, ast.Name) and \
isinstance(expression.ctx, ast.Store):
start, end = patchedast.node_region(expression)
text = pymodule.source_code[start:end]
return evaluate.eval_str(scope, text)
else:
return evaluate.eval_node(scope, expression)
def _evaluate(self, code):
attributes = code.split('.')
pyname = None
if attributes[0] in ('__builtin__', '__builtins__'):
class _BuiltinsStub(object):
def get_attribute(self, name):
return builtins.builtins[name]
def __getitem__(self, name):
return builtins.builtins[name]
def __contains__(self, name):
return name in builtins.builtins
pyobject = _BuiltinsStub()
else:
pyobject = self.project.get_module(attributes[0])
for attribute in attributes[1:]:
pyname = pyobject[attribute]
if pyname is None:
return None
pyobject = pyname.get_object()
return pyname | /ropee-0.13.3.tar.gz/ropee-0.13.3/rope/refactor/wildcards.py | 0.827236 | 0.366788 | wildcards.py | pypi |
class ImportStatement(object):
"""Represent an import in a module
`readonly` attribute controls whether this import can be changed
by import actions or not.
"""
def __init__(self, import_info, start_line, end_line,
main_statement=None, blank_lines=0):
self.start_line = start_line
self.end_line = end_line
self.readonly = False
self.main_statement = main_statement
self._import_info = None
self.import_info = import_info
self._is_changed = False
self.new_start = None
self.blank_lines = blank_lines
def _get_import_info(self):
return self._import_info
def _set_import_info(self, new_import):
if not self.readonly and \
new_import is not None and not new_import == self._import_info:
self._is_changed = True
self._import_info = new_import
import_info = property(_get_import_info, _set_import_info)
def get_import_statement(self):
if self._is_changed or self.main_statement is None:
return self.import_info.get_import_statement()
else:
return self.main_statement
def empty_import(self):
self.import_info = ImportInfo.get_empty_import()
def move(self, lineno, blank_lines=0):
self.new_start = lineno
self.blank_lines = blank_lines
def get_old_location(self):
return self.start_line, self.end_line
def get_new_start(self):
return self.new_start
def is_changed(self):
return self._is_changed or (self.new_start is not None or
self.new_start != self.start_line)
def accept(self, visitor):
return visitor.dispatch(self)
class ImportInfo(object):
def get_imported_primaries(self, context):
pass
def get_imported_names(self, context):
return [primary.split('.')[0]
for primary in self.get_imported_primaries(context)]
def get_import_statement(self):
pass
def is_empty(self):
pass
def __hash__(self):
return hash(self.get_import_statement())
def _are_name_and_alias_lists_equal(self, list1, list2):
if len(list1) != len(list2):
return False
for pair1, pair2 in zip(list1, list2):
if pair1 != pair2:
return False
return True
def __eq__(self, obj):
return isinstance(obj, self.__class__) and \
self.get_import_statement() == obj.get_import_statement()
def __ne__(self, obj):
return not self.__eq__(obj)
@staticmethod
def get_empty_import():
return EmptyImport()
class NormalImport(ImportInfo):
def __init__(self, names_and_aliases):
self.names_and_aliases = names_and_aliases
def get_imported_primaries(self, context):
result = []
for name, alias in self.names_and_aliases:
if alias:
result.append(alias)
else:
result.append(name)
return result
def get_import_statement(self):
result = 'import '
for name, alias in self.names_and_aliases:
result += name
if alias:
result += ' as ' + alias
result += ', '
return result[:-2]
def is_empty(self):
return len(self.names_and_aliases) == 0
class FromImport(ImportInfo):
def __init__(self, module_name, level, names_and_aliases):
self.module_name = module_name
self.level = level
self.names_and_aliases = names_and_aliases
def get_imported_primaries(self, context):
if self.names_and_aliases[0][0] == '*':
module = self.get_imported_module(context)
return [name for name in module
if not name.startswith('_')]
result = []
for name, alias in self.names_and_aliases:
if alias:
result.append(alias)
else:
result.append(name)
return result
def get_imported_resource(self, context):
"""Get the imported resource
Returns `None` if module was not found.
"""
if self.level == 0:
return context.project.find_module(
self.module_name, folder=context.folder)
else:
return context.project.find_relative_module(
self.module_name, context.folder, self.level)
def get_imported_module(self, context):
"""Get the imported `PyModule`
Raises `rope.base.exceptions.ModuleNotFoundError` if module
could not be found.
"""
if self.level == 0:
return context.project.get_module(
self.module_name, context.folder)
else:
return context.project.get_relative_module(
self.module_name, context.folder, self.level)
def get_import_statement(self):
result = 'from ' + '.' * self.level + self.module_name + ' import '
for name, alias in self.names_and_aliases:
result += name
if alias:
result += ' as ' + alias
result += ', '
return result[:-2]
def is_empty(self):
return len(self.names_and_aliases) == 0
def is_star_import(self):
return len(self.names_and_aliases) > 0 and \
self.names_and_aliases[0][0] == '*'
class EmptyImport(ImportInfo):
names_and_aliases = []
def is_empty(self):
return True
def get_imported_primaries(self, context):
return []
class ImportContext(object):
def __init__(self, project, folder):
self.project = project
self.folder = folder | /ropee-0.13.3.tar.gz/ropee-0.13.3/rope/refactor/importutils/importinfo.py | 0.610453 | 0.150934 | importinfo.py | pypi |
class Data(object):
def __init__(self, prompt=None, default=None, values=None,
kind=None, decode=None):
self.prompt = prompt
self.default = default
self.values = values
self.kind = kind
self._decode = decode
def decode(self, value):
if self._decode:
return self._decode(value)
return value
class Boolean(Data):
def __init__(self, prompt=None, default=False):
Data.__init__(self, prompt, self._encode(default),
[self._encode(True), self._encode(False)])
def _encode(self, value):
if value:
return 'yes'
return 'no'
def decode(self, value):
if value.lower() in ('yes', '1', 'true'):
return True
return False
def show_dialog(askdata, actions, confs={}, optionals={}, initial_asking=True):
result = {}
if initial_asking:
for name, conf in list(confs.items()):
result[name] = askdata(conf)
actions.append('batchset')
names = list(actions)
names.extend(list(optionals.keys()))
names.extend(list(confs.keys()))
base_question = Data('Choose what to do: ',
default=actions[0], values=names)
batchset_question = Data('Batch sets: ')
while True:
response = askdata(base_question)
if response == '':
response = base_question.default
elif response == 'batchset':
sets = askdata(batchset_question)
for key, value in list(_parse_batchset(sets).items()):
if key.endswith(':'):
key = key[:-1]
if key in names:
conf = confs.get(key, optionals.get(key))
result[key] = value
elif response in actions:
break
else:
if response in confs:
conf = confs[response]
else:
conf = optionals[response]
oldvalue = result.get(response, None)
result[response] = askdata(conf, starting=oldvalue)
decoded = {}
all_confs = dict(confs)
all_confs.update(optionals)
for key in all_confs:
conf = all_confs.get(key)
if key in result:
decoded[key] = conf.decode(result[key])
else:
decoded[key] = conf.decode(conf.default)
return response, decoded
def _parse_batchset(sets):
result = []
multiline = False
for line in sets.splitlines(True):
if line[0].isspace():
if multiline:
result[-1][1] += line[1:]
else:
if not line.strip():
continue
multiline= False
tokens = line.split(None, 1)
value = ''
if len(tokens) > 1:
result.append([tokens[0], tokens[1].rstrip('\r\n')])
else:
multiline = True
result.append([tokens[0], ''])
return dict(result) | /ropemode_py3k-0.2.tar.gz/ropemode_py3k-0.2/ropemode/dialog.py | 0.517083 | 0.243811 | dialog.py | pypi |
__version__ = '0.1'
class Rope(object):
# NOTE: self.left and self.right should either both point to subnodes or
# both set to `None`, so checking both should not be necessary.
def __init__(self, data=''):
if isinstance(data, list):
if len(data) == 0:
self.__init__()
elif len(data) == 1:
self.__init__(data[0])
else:
# Round-up division (to match rope arithmetic associativity)
idiv = len(data) // 2 + (len(data) % 2 > 0)
self.left = Rope(data[:idiv])
self.right = Rope(data[idiv:])
self.data = ''
self.length = self.left.length + self.right.length
elif isinstance(data, str):
self.left = None
self.right = None
self.data = data
self.length = len(data)
else:
raise TypeError('Only strings are currently supported')
# Word iteration
self.current = self
def __eq__(self, other):
if (self.left and self.right) and (other.left and other.right):
return self.left == other.left and self.right == other.right
elif (self.left and self.right) or (other.left and other.right):
return False
else:
return self.data == other.data
def __add__(self, other):
# TODO: Automatically collapse empty ropes
if isinstance(other, str):
other = Rope(other)
r = Rope()
r.left = self
r.right = other
r.length = self.length + other.length
r.current = self
return r
def __len__(self):
if self.left and self.right:
return len(self.left.data) + len(self.right.data)
else:
return(len(self.data))
def __getitem__(self, index):
if isinstance(index, int):
if self.left and self.right:
if index < -self.right.length:
subindex = index + self.right.length
elif index >= self.left.length:
subindex = index - self.left.length
else:
subindex = index
if index < -self.right.length or 0 <= index < self.left.length:
return self.left[subindex]
else:
return self.right[subindex]
else:
return Rope(self.data[index])
elif isinstance(index, slice):
if self.left and self.right:
start = index.start
if index.start is None:
if index.step is None or index.step > 0:
head = self.left
else:
head = self.right
elif (index.start < -self.right.length or
0 <= index.start < self.left.length):
head = self.left
if index.start and index.start < -self.right.length:
start += self.right.length
else:
head = self.right
if index.start and index.start >= self.left.length:
start -= self.left.length
# TODO: stop = -right.length could be on either subrope.
# There are two options:
# 1. tail = left and stop = None (or left.length)
# 2. tail = right as a '' string, which is removed
# Currently doing method 2, but I'm on the fence here.
stop = index.stop
if index.step is None or index.step > 0:
if (index.stop is None or
-self.right.length <= index.stop < 0 or
index.stop > self.left.length):
tail = self.right
if index.stop and index.stop > self.left.length:
stop -= self.left.length
else:
if head == self.right:
tail = self.right
stop = 0
else:
tail = self.left
if index.stop < -self.right.length:
stop += self.right.length
else:
if (index.stop is None or
index.stop < (-self.right.length - 1) or
0 <= index.stop < self.left.length):
tail = self.left
if index.stop and index.stop < (-self.right.length - 1):
stop += self.right.length
else:
if head == self.left:
tail = self.left
stop = -1 # Or self.left.length - 1 ?
else:
tail = self.right
if index.stop >= self.left.length:
stop -= self.left.length
# Construct the rope
if head == tail:
return head[start:stop:index.step]
else:
if not index.step:
offset = None
elif index.step > 0:
if start is None:
delta = -head.length
elif start >= 0:
delta = start - head.length
else:
delta = max(index.start, -self.length) + tail.length
offset = delta % index.step
if offset == 0:
offset = None
else:
if start is None:
offset = index.step + (head.length - 1) % (-index.step)
elif start >= 0:
offset = index.step + min(start, head.length - 1) % (-index.step)
else:
offset = index.step + (start + head.length) % (-index.step)
if not tail[offset:stop:index.step]:
return head[start::index.step]
else:
return head[start::index.step] + tail[offset:stop:index.step]
else:
return Rope(self.data[index])
#----------------------------------------------------
# Old explicit implementation
# Slice logic taken from CPython's sliceobject.c
# It may be possible to streamline this in Python
if self.left and self.right:
# Step initialization
if index.step is None:
step = 1
else:
if index.step == 0:
raise ValueError('slice step cannot be zero')
else:
step = index.step
# Default start/stop indices
if step < 0:
default_start = self.length - 1
default_stop = -1
else:
default_start = 0
default_stop = self.length
# Start index
if index.start is None:
start = default_start
else:
start = index.start
if start < 0:
start += self.length
if start < 0:
start = 0 if step > 0 else -1
if start >= self.length:
start = self.length if step > 0 else (self.length - 1)
# Stop index
if index.stop is None:
stop = default_stop
else:
stop = index.stop
if stop < 0:
stop += self.length
if stop < 0:
stop = 0 if step > 0 else -1
if stop >= self.length:
stop = self.length if step > 0 else (self.length - 1)
# Apply slice
print('index', index.start, index.stop, index.step)
print('slice', start, stop, step)
if start < self.left.length:
if stop <= self.left.length:
print('LEFT')
return self.left[start:stop:step]
else:
print('MIXED')
return (self.left[start::step]
+ self.right[(start + step - self.left.length) % step
:(stop - self.left.length):step])
else:
print('RIGHT')
return self.right[(start - self.left.length)
:max(stop - self.left.length, 0)
:step]
else:
return Rope(self.data[index])
else:
raise TypeError('rope indices must be integers or slices, not {}'
''.format(type(index).__name__))
def __repr__(self):
# TODO: Parentheses are too conservative, need to clean this up
if self.left and self.right:
return '{}{} + {}{}'.format('(' if self.left else '',
self.left.__repr__(),
self.right.__repr__(),
')' if self.right else '')
else:
return "Rope('{}')".format(self.data)
def __str__(self):
if self.left and self.right:
return self.left.__str__() + self.right.__str__()
else:
return self.data
def __iter__(self):
return self
def __next__(self):
if self.current:
if self.left and self.right:
try:
return next(self.left)
except StopIteration:
self.current = self.right
return next(self.right)
else:
self.current = None
return self.data
else:
raise StopIteration
def next(self):
return self.__next__()
# API
def reduce(self):
"""Search the tree and remove any redundant nodes."""
raise NotImplementedError
def insert(self, index, s):
"""Insert string s at index i."""
raise NotImplementedError | /ropes-0.1.tar.gz/ropes-0.1/ropes.py | 0.525125 | 0.355327 | ropes.py | pypi |
import re
from ropper.common.error import RopperError
class ConstraintCompiler(object):
"""
Compile a user given constraints to z3 expressions
constraint := assignment | pop_reg
assignment := reg, adjust, reg | number
pop_reg := "pop", reg
adjust := "==" | "+=" | "-=" | "*=" | "/="
reg := a register of the current architecture
number := int
"""
NUMBER_REGEX = '(-?[0-9]+)'
REG_REGEX = '(?P<{}>[a-zA-Z0-9]+)'
ADJUST_REGEX = '([\\+\-\*/=]=)'
ASSIGNMENT_REGEX = '('+REG_REGEX.format('reg_dst_1') + ' *' + ADJUST_REGEX + ' *('+NUMBER_REGEX+'|'+REG_REGEX.format('reg_src_1')+'|(\[)'+REG_REGEX.format('reg_src_2')+'(\])))'
POP_REGEX = '((pop) +'+REG_REGEX.format('reg_dst_2')+')'
CONSTRAINT_REGEX = '(' + ASSIGNMENT_REGEX + '|' + POP_REGEX + ')'
def __init__(self, architecture, semantic_info):
self.__architecture = architecture
self.__semantic_info = semantic_info
def getSymbols(self, constraints):
symbols = []
for constraint in constraints:
match = re.match(ConstraintCompiler.CONSTRAINT_REGEX, constraint)
if match is None:
raise Exception('Invalid syntax: %s' % constraint)
reg_dst = match.group('reg_dst_1')
if reg_dst is not None:
reg_src = match.group('reg_src_1')
reg_src = match.group('reg_src_2') if reg_src is None else reg_src
symbols.append((reg_dst, reg_src))
else:
symbols.append((match.group('reg_dst_2'), None))
return symbols
def compile(self, constraints):
"""
compile a line of semantic expressions
"""
tokens = self._tokenize(constraints)[::-1]
to_return = None
constraint = None
while True:
if not tokens:
break
token = tokens.pop()
if token in self.__architecture.info.registers:
constraint = self._assignment(token, tokens)
elif token == 'pop':
constraint = self._popReg(token, tokens)
elif token == ';':
if to_return is None:
to_return = constraint
else:
to_return = 'And(%s, %s)' % (to_return, constraint)
else:
raise ConstraintError('Invalid token: %s' % token)
return to_return
def _tokenize(self, constraints):
"""
return a list of tokens
"""
tokens = []
for constraint in constraints.split(';'):
constraint = constraint.strip()
if not constraint:
continue
match = re.match(ConstraintCompiler.CONSTRAINT_REGEX, constraint)
if match is None:
raise ConstraintError('Invalid Syntax: %s' % constraint)
last_valid_index = -1
for index in range(1, len(match.regs)):
start = match.regs[index][0]
if start == -1:
continue
if last_valid_index == -1:
last_valid_index = index
continue
if match.regs[last_valid_index][0] != start:
tokens.append(match.group(last_valid_index))
last_valid_index = index
tokens.append(match.group(last_valid_index))
tokens.append(';')
return tokens
def _assignment(self, register, tokens):
register = self.__architecture.getRegisterName(register)
reg1_last = self.__semantic_info.regs[register][-1]
reg1_init = self.__semantic_info.regs[register][0]
op = tokens.pop()
if not re.match(ConstraintCompiler.ADJUST_REGEX, op):
raise ConstraintError('Invalid syntax: %s' % op)
value = tokens.pop()
if value == '[':
r1 = register
register = tokens.pop()
register_name = self.__architecture.getRegisterName(register)
if not register_name:
raise ConstraintError('Invalid register: %s' & register)
value = self._readMemory(register_name)
tokens.pop()
elif re.match(ConstraintCompiler.NUMBER_REGEX, value):
value = create_number_expression(int(value), int(reg1_last.split('_')[-1]))
elif value in self.__architecture.info.registers:
value = self.__architecture.getRegisterName(value)
value = self.__semantic_info.regs[value][0]
value = create_register_expression(value, int(value.split('_')[-1]))
else:
print(re.match(ConstraintCompiler.NUMBER_REGEX, value))
raise ConstraintError('Invalid Assignment: %s%s%s' % (register, op, value))
reg1_last = create_register_expression(reg1_last, int(reg1_last.split('_')[-1]))
reg1_init = create_register_expression(reg1_init, int(reg1_init.split('_')[-1]))
return self._create(reg1_last, reg1_init, value, op[0])
def _create(self, left_last, left_init, right, adjust):
if adjust != '=':
return '%s == %s %s %s' % (left_last, left_init, adjust, right)
else:
return '%s == %s' % (left_last, right)
def _readMemory(self, register):
register_init = self.__semantic_info.regs[register][0]
if self.__semantic_info.mems:
memory = self.__semantic_info.mems[-1]
else:
memory = 'memory%d_%d_%d' % (0, self.__architecture.info.bits, 8)
self.__semantic_info.mems.append(memory)
size = int(register_init.split('_')[-1])
register_expr = create_register_expression(register_init, size)
mem_expr = create_read_memory_expression(memory, register_expr, size)
return mem_expr
def _popReg(self, pop, tokens):
reg_name = tokens.pop()
self.symbols.append((reg_name,None))
reg = self.__semantic_info.regs[reg_name][-1]
if self.__semantic_info.mems:
memory = self.__semantic_info.mems[0]
else:
memory = 'memory%d_%d_%d' % (0, self.__architecture.info.bits, 8)
self.__semantic_info.mems.append(memory)
size = int(reg.split('_')[-1])
register_expr = create_register_expression(reg, size)
mem_expr = create_read_memory_expression(memory, register_expr, size)
return mem_expr
class ConstraintError(RopperError):
"""
ConstraintError
"""
pass
def create_register_expression(register_accessor, size, high=False):
register_size = int(register_accessor.split('_')[2])
if size < register_size:
if high:
return 'Extract(%d, 8, %s)' % (size+8-1, register_accessor)
else:
return 'Extract(%d, 0, %s)' % (size-1, register_accessor)
else:
return '%s' % register_accessor
def create_number_expression(number, size):
return "BitVecVal(%d, %d)" % (number, size)
def create_read_memory_expression(memory, addr, size):
to_return = '%s[%s]' % (memory, addr)
for i in range(1, int(size/8)):
value = '%s[%s]' % (memory, '%s + %d' % (addr, i))
to_return = 'Concat(%s, %s)' % (value, to_return)
return to_return | /ropper2-2.0.10-py3-none-any.whl/ropper/z3helper.py | 0.488039 | 0.254625 | z3helper.py | pypi |
from ctypes import *
from ropper.loaders.loader import *
from ropper.common.error import LoaderError
from ropper.common.error import RopperError
from ropper.arch import Endianess
import filebytes.elf as elf
import os
class ELF(Loader):
def __init__(self, filename, bytes=None, arch=None):
self.__execSections = None
self.__dataSections = None
super(ELF, self).__init__(filename, bytes, arch)
@property
def entryPoint(self):
return self._binary.entryPoint
def _getImageBase(self):
return self._binary.imageBase
def _loadDefaultArch(self):
try:
machine = elf.EM[self._binary.elfHeader.header.e_machine]
cls = elf.ELFCLASS[self._binary.elfHeader.header.e_ident[elf.EI.CLASS]]
end = self._binary._bytes[elf.EI.DATA]
return getArch( (machine,cls, end ),self._binary.elfHeader.header.e_entry)
except BaseException as e:
raise RopperError(e)
@property
def executableSections(self):
if not self.__execSections:
self.__execSections = []
if self._binary.segments:
for phdr in self._binary.segments:
if phdr.header.p_flags & elf.PF.EXEC > 0:
self.__execSections.append(Section(name=str(elf.PT[phdr.header.p_type]), sectionbytes=phdr.raw, virtualAddress=phdr.header.p_vaddr, offset=phdr.header.p_offset))
elif self._binary.sections:
for shdr in self._binary.sections:
print(shdr.header.sh_flags)
if shdr.header.sh_flags & elf.SHF.EXECINSTR:
self.__execSections.append(Section(name=shdr.name, sectionbytes=shdr.raw, virtualAddress=shdr.header.sh_addr, offset=shdr.header.sh_offset))
return self.__execSections
@property
def dataSections(self):
if not self.__dataSections:
self.__dataSections = []
for shdr in self._binary.sections:
if shdr.header.sh_flags & elf.SHF.ALLOC and not (shdr.header.sh_flags & elf.SHF.EXECINSTR) and not(shdr.header.sh_type & elf.SHT.NOBITS):
self.__dataSections.append(Section(shdr.name, shdr.raw, shdr.header.sh_addr, shdr.header.sh_offset, shdr.header))
return self.__dataSections
@property
def codeVA(self):
for phdr in self.phdrs:
if phdr.header.p_type == PT.INTERP:
return phdr.header.p_vaddr
return 0
@property
def type(self):
return Type.ELF
def setASLR(self, enable):
raise LoaderError('Not available for elf files')
def setNX(self, enable):
perm = elf.PF.READ | elf.PF.WRITE if enable else elf.PF.READ | elf.PF.WRITE | elf.PF.EXEC
phdrs = self._binary.segments
for phdr in phdrs:
if phdr.header.p_type == elf.PT.GNU_STACK:
phdr.header.p_flags = perm
self.save()
def getSection(self, name):
for shdr in self._binary.sections:
if shdr.name == name:
return Section(shdr.name, shdr.raw, shdr.header.sh_addr, shdr.header.sh_addr - self._binary.imageBase)
raise RopperError('No such section: %s' % name)
def checksec(self):
return {}
def _loadFile(self, fileName, bytes=None):
return elf.ELF(fileName, bytes)
@classmethod
def isSupportedFile(cls, fileName, bytes=None):
if bytes:
return elf.ELF.isSupportedContent(bytes)
return elf.ELF.isSupportedFile(fileName)
def getArch(*params):
arch = ARCH[params[0]]
if arch==ARM and (params[1] & 1) == 1:
return ARMTHUMB
return arch
ARCH = {(elf.EM.INTEL_386 , elf.ELFCLASS.BITS_32, elf.ELFDATA.LSB): x86,
(elf.EM.INTEL_80860, elf.ELFCLASS.BITS_32, elf.ELFDATA.LSB): x86,
(elf.EM.IA_64, elf.ELFCLASS.BITS_64, elf.ELFDATA.LSB): x86_64,
(elf.EM.X86_64, elf.ELFCLASS.BITS_64, elf.ELFDATA.LSB): x86_64,
(elf.EM.MIPS, elf.ELFCLASS.BITS_32, elf.ELFDATA.MSB): MIPSBE,
(elf.EM.MIPS, elf.ELFCLASS.BITS_32, elf.ELFDATA.LSB): MIPS,
(elf.EM.MIPS, elf.ELFCLASS.BITS_64, elf.ELFDATA.MSB): MIPS64BE,
(elf.EM.MIPS, elf.ELFCLASS.BITS_64, elf.ELFDATA.LSB): MIPS64,
(elf.EM.ARM, elf.ELFCLASS.BITS_32, elf.ELFDATA.MSB) : ARMBE,
(elf.EM.ARM, elf.ELFCLASS.BITS_32, elf.ELFDATA.LSB) : ARM,
(elf.EM.ARM64, elf.ELFCLASS.BITS_64, elf.ELFDATA.LSB) : ARM64,
(elf.EM.PPC, elf.ELFCLASS.BITS_32, elf.ELFDATA.MSB) : PPC,
(elf.EM.PPC64, elf.ELFCLASS.BITS_64, elf.ELFDATA.MSB) : PPC64,
(elf.EM.SPARCV9, elf.ELFCLASS.BITS_64, elf.ELFDATA.MSB) : SPARC64} | /ropper2-2.0.10-py3-none-any.whl/ropper/loaders/elf.py | 0.503418 | 0.176423 | elf.py | pypi |
from ctypes import *
from ropper.loaders.loader import *
from filebytes import pe
import os
import struct
class ImageImportDescriptorData(DataContainer):
"""
struct = IMAGE_IMPORT_DESCRIPTOR
dll = string (dll name)
functions = list (imported function names)
"""
class PE(Loader):
def __init__(self, filename, bytes=None, arch=None):
super(PE, self).__init__(filename, bytes, arch)
@property
def entryPoint(self):
return self._binary.entryPoint
def _loadDefaultArch(self):
return getArch(self._binary.imageNtHeaders.header.FileHeader.Machine)
@property
def type(self):
return Type.PE
@property
def executableSections(self):
# toReturn = [self.sections['.text']]
toReturn = []
for section in self._binary.sections:
if section.header.Characteristics & pe.IMAGE_SCN.CNT_CODE > 0:
s = Section(section.name, section.raw, section.header.VirtualAddress + self.imageBase, section.header.VirtualAddress)
toReturn.append(s)
return toReturn
@property
def dataSections(self):
toReturn = []
for section in self._binary.sections:
if section.header.Characteristics & pe.IMAGE_SCN.CNT_INITIALIZED_DATA or section.header.Characteristics & pe.IMAGE_SCN.CNT_UNINITIALIZED_DATA:
s = Section(section.name, section.raw, section.header.VirtualAddress + self.imageBase, section.header.VirtualAddress)
toReturn.append(s)
return toReturn
def getWriteableSection(self):
for section in self._binary.sections:
if section.header.Characteristics & pe.IMAGE_SCN.MEM_WRITE:
s = Section(section.name, section.raw, section.header.VirtualAddress + self.imageBase, section.header.VirtualAddress)
return s
def getSection(self, name):
for section in self.sections:
if str(section.name) == name:
s = Section(section.name, section.raw, section.header.VirtualAddress + self.imageBase, section.header.VirtualAddress)
return s
raise RopperError('No such secion: %s' % name)
def setNX(self, enable):
if enable:
self._binary.imageNtHeaders.header.OptionalHeader.DllCharacteristics |= pe.ImageDllCharacteristics.NX_COMPAT
else:
self._binary.imageNtHeaders.header.OptionalHeader.DllCharacteristics &= ~pe.ImageDllCharacteristics.NX_COMPAT
self.save()
def setASLR(self, enable):
if enable:
self._binary.imageNtHeaders.header.OptionalHeader.DllCharacteristics |= pe.ImageDllCharacteristics.DYNAMIC_BASE
else:
self._binary.imageNtHeaders.header.OptionalHeader.DllCharacteristics &= ~pe.ImageDllCharacteristics.DYNAMIC_BASE
self.save()
def _getImageBase(self):
return self._binary.imageBase
def checksec(self):
return {'SafeSEH' : self.imageNtHeaders.OptionalHeader.DataDirectory[ImageDirectoryEntry.LOAD_CONFIG].Size != 0,
'ASLR' : self.imageNtHeaders.OptionalHeader.DllCharacteristics & ImageDllCharacteristics.DYNAMIC_BASE != 0,
'DEP' : self.imageNtHeaders.OptionalHeader.DllCharacteristics & ImageDllCharacteristics.NX_COMPAT != 0}
def _loadFile(self, fileName, bytes=None):
return pe.PE(fileName, bytes)
@classmethod
def isSupportedFile(cls, fileName, bytes=None):
if bytes:
return pe.PE.isSupportedContent(bytes)
return pe.PE.isSupportedFile(fileName)
def getArch(*params):
return ARCH[params[0]]
ARCH = {int(pe.IMAGE_FILE_MACHINE.AMD64):
x86_64, int(pe.IMAGE_FILE_MACHINE.I386): x86,
int(pe.IMAGE_FILE_MACHINE.ARM) : ARM,
int(pe.IMAGE_FILE_MACHINE.ARMV) : ARMTHUMB} | /ropper2-2.0.10-py3-none-any.whl/ropper/loaders/pe.py | 0.622804 | 0.167049 | pe.py | pypi |
from ropper.printer.printer import *
from ropper.loaders.elf import *
class ELFPrinter(FileDataPrinter):
@classmethod
def validType(cls):
return Type.ELF
def printInformation(self, binary):
ehdr = binary._binary.elfHeader.header
data = [(cstr('Class', Color.BLUE), cstr(elf.ELFCLASS[ehdr.e_ident[elf.EI.CLASS]], Color.WHITE)),
(cstr('Machine', Color.BLUE), cstr(elf.EM[ehdr.e_machine], Color.WHITE)),
(cstr('Version', Color.BLUE), cstr(ehdr.e_version, Color.WHITE)),
(cstr('EntryPoint', Color.BLUE), cstr(self._toHex(
ehdr.e_entry,binary.arch.addressLength), Color.WHITE)),
(cstr('ProgramHeader Offset', Color.BLUE), cstr(ehdr.e_phoff, Color.WHITE)),
(cstr('SectionHeader Offset', Color.BLUE), cstr(ehdr.e_shoff, Color.WHITE)),
(cstr('Flags', Color.BLUE), cstr(self._toHex(ehdr.e_flags, int(binary.arch.addressLength)), Color.WHITE)),
(cstr('ELF Header Size', Color.BLUE), cstr(ehdr.e_ehsize, Color.WHITE)),
(cstr('ProgramHeader Size', Color.BLUE), cstr(ehdr.e_phentsize, Color.WHITE)),
(cstr('ProgramHeader Number', Color.BLUE), cstr(ehdr.e_phnum, Color.WHITE)),
(cstr('SectionHeader Size', Color.BLUE), cstr(ehdr.e_shentsize, Color.WHITE)),
(cstr('SectionHeader Number', Color.BLUE), cstr(ehdr.e_shnum, Color.WHITE))]
self._printTable('ELF Header', (cstr('Name', Color.LIGHT_GRAY), cstr('Value',Color.LIGHT_GRAY)), data)
def printSymbols(self, binary):
for section in binary._binary.sections:
if section.name in ('.symtab','.dynsym'):
data = []
symbols = section.symbols
for idx in range(len(symbols)):
symbol = symbols[idx]
data.append((cstr(idx, Color.BLUE),
cstr(elf.STT[symbol.type], Color.GREEN),
cstr(elf.STB[symbol.bind], Color.LIGHT_GRAY),
cstr(symbol.name, Color.WHITE)))
self._printTable('Symbols from %s' % section.name,
(cstr('Nr', Color.LIGHT_GRAY),
cstr('Type', Color.LIGHT_GRAY),
cstr('Bind', Color.LIGHT_GRAY),
cstr('Name', Color.LIGHT_GRAY)),
data)
def printSections(self, binary):
data = []
for index in range(len(binary._binary.sections)):
data.append((cstr('[%.2d]' % index, Color.BLUE),
cstr(binary._binary.sections[index].name, Color.WHITE),
cstr(toHex(binary._binary.sections[index].header.sh_addr), Color.GREEN),
cstr(toHex(binary._binary.sections[index].header.sh_offset), Color.GREEN),
cstr(elf.SHT[binary._binary.sections[index].header.sh_type], Color.YELLOW)
))
self._printTable('Sections',
(cstr('Nr', Color.LIGHT_GRAY),
cstr('Name', Color.LIGHT_GRAY),
cstr('Address', Color.LIGHT_GRAY),
cstr('Offset', Color.LIGHT_GRAY),
cstr('Type', Color.LIGHT_GRAY),
),
data)
def printSegments(self, elffile):
phdrs = elffile._binary.segments
data = []
for phdrData in phdrs:
phdr = phdrData.header
ptype = 'Not available'
if phdr.p_type in elf.PT:
ptype = elf.PT[phdr.p_type]
data.append((cstr(ptype, Color.BLUE),
cstr(self._toHex(phdr.p_offset), Color.WHITE),
cstr(self._toHex(phdr.p_paddr, int(elffile.arch.addressLength)), Color.LIGHT_GRAY),
cstr(self._toHex(phdr.p_filesz), Color.WHITE),
cstr(self._toHex(phdr.p_memsz), Color.LIGHT_GRAY),
cstr(elf.PF.shortString(phdr.p_flags), (Color.GREEN if phdr.p_flags & elf.PF.EXEC == 0 else Color.RED) )))
self._printTable('Segments',
(cstr('Type', Color.LIGHT_GRAY),
cstr('Offset', Color.LIGHT_GRAY),
cstr('VAddress', Color.LIGHT_GRAY),
cstr('FileSize', Color.LIGHT_GRAY),
cstr('MemSize', Color.LIGHT_GRAY),
cstr('Flags', Color.LIGHT_GRAY)),
data)
def printEntryPoint(self, binary):
self._printLine(self._toHex(binary.entryPoint, binary.arch.addressLength))
def printImageBase(self, binary):
self._printLine(
self._toHex(binary.imageBase, binary.arch.addressLength))
def printArchitecture(self, binary):
self._printLine(str(binary.arch))
def printFileType(self, binary):
self._printLine(str(binary.type))
def printImports(self, elffile):
printed = False
for section in elffile._binary.sections:
if section.header.sh_type in (elf.SHT.REL,elf.SHT.RELA):
relocs = section.relocations
data = []
for reloc in relocs:
data.append((cstr(self._toHex(reloc.header.r_offset, elffile.arch.addressLength), Color.BLUE),
cstr(elf.R_386[reloc.type], Color.YELLOW),
cstr(reloc.symbol.name, Color.WHITE)))
self._printTable('Relocation section: %s' % section,
(cstr('Offset', Color.LIGHT_GRAY),
cstr('Type', Color.LIGHT_GRAY),
cstr('Name', Color.LIGHT_GRAY)),
data)
printed = True
if not printed:
self._printLine('no imorts!') | /ropper2-2.0.10-py3-none-any.whl/ropper/printer/elfprinter.py | 0.581184 | 0.246641 | elfprinter.py | pypi |
from ropper.printer.printer import *
from ropper.loaders.pe import *
from filebytes.pe import *
import datetime
class PEPrinter(FileDataPrinter):
@classmethod
def validType(cls):
return Type.PE
def printInformation(self, binary):
self.__printImageHeaders(binary)
self.__printOptionalHeaders(binary)
def __printImageHeaders(self, pefile):
fh = pefile._binary.imageNtHeaders.header.FileHeader
data = [
(cstr('Characteristics', Color.BLUE),
cstr(self._toHex(fh.Characteristics), Color.WHITE)),
(cstr('Machine', Color.BLUE),
cstr(pe.IMAGE_FILE_MACHINE[fh.Machine], Color.WHITE)),
(cstr('NumberOfSections', Color.BLUE),
cstr((fh.NumberOfSections), Color.WHITE)),
(cstr('PointerToSymbolTable', Color.BLUE),
cstr(self._toHex(fh.PointerToSymbolTable, pefile.arch.addressLength), Color.WHITE)),
(cstr('SizeOfOptionalHeader', Color.BLUE),
cstr((fh.SizeOfOptionalHeader), Color.WHITE)),
(cstr('TimeDateStamp', Color.BLUE),
cstr((datetime.datetime.fromtimestamp(
fh.TimeDateStamp
).strftime('%Y-%m-%d %H:%M:%S')), Color.WHITE))
]
self._printTable('Image Headers', (cstr('Name',Color.LIGHT_GRAY), cstr('Value',Color.LIGHT_GRAY)), data)
def __printOptionalHeaders(self, pefile):
oh = pefile._binary.imageNtHeaders.header.OptionalHeader
addressLength = pefile.arch.addressLength
data = [
(cstr('AddressOfEntryPoint', Color.BLUE),
cstr(self._toHex(oh.AddressOfEntryPoint, addressLength), Color.WHITE)),
(cstr('BaseOfCode', Color.BLUE),
cstr(self._toHex(oh.BaseOfCode, addressLength), Color.WHITE)),
(cstr('CheckSum', Color.BLUE),
cstr(self._toHex(oh.CheckSum,4), Color.WHITE)),
(cstr('DllCharacteristics', Color.BLUE),
cstr(self._toHex(oh.DllCharacteristics,2), Color.WHITE)),
(cstr('FileAlignment', Color.BLUE),
cstr(self._toHex(oh.FileAlignment,4), Color.WHITE)),
(cstr('ImageBase', Color.BLUE),
cstr(self._toHex(oh.ImageBase, addressLength), Color.WHITE)),
(cstr('LoaderFlags', Color.BLUE),
cstr(self._toHex(oh.LoaderFlags,4), Color.WHITE)),
(cstr('Magic', Color.BLUE),
cstr(self._toHex(oh.Magic,4), Color.WHITE)),
(cstr('MajorImageVersion', Color.BLUE),
cstr(self._toHex(oh.MajorImageVersion,2), Color.WHITE)),
(cstr('MajorLinkerVersion', Color.BLUE),
cstr(self._toHex(oh.MajorLinkerVersion,2), Color.WHITE)),
(cstr('MajorOperatingSystemVersion', Color.BLUE),
cstr(self._toHex(oh.MajorOperatingSystemVersion,2), Color.WHITE)),
(cstr('MajorSubsystemVersion', Color.BLUE),
cstr(self._toHex(oh.MajorSubsystemVersion,2), Color.WHITE)),
(cstr('MinorImageVersion', Color.BLUE),
cstr(self._toHex(oh.MinorImageVersion,2), Color.WHITE)),
(cstr('NumberOfRvaAndSizes', Color.BLUE),
cstr(self._toHex(oh.NumberOfRvaAndSizes,4), Color.WHITE)),
(cstr('SectionAlignment', Color.BLUE),
cstr(self._toHex(oh.SectionAlignment,4), Color.WHITE)),
(cstr('SizeOfCode', Color.BLUE),
cstr(self._toHex(oh.SizeOfCode,4), Color.WHITE)),
(cstr('SizeOfHeaders', Color.BLUE),
cstr(self._toHex(oh.SizeOfHeaders,4), Color.WHITE)),
(cstr('SizeOfHeapCommit', Color.BLUE),
cstr(self._toHex(oh.SizeOfHeapCommit,4), Color.WHITE)),
(cstr('SizeOfHeapReserve', Color.BLUE),
cstr(self._toHex(oh.SizeOfHeapReserve,4), Color.WHITE)),
(cstr('SizeOfImage', Color.BLUE),
cstr(self._toHex(oh.SizeOfImage,4), Color.WHITE)),
(cstr('SizeOfInitializedData', Color.BLUE),
cstr(self._toHex(oh.SizeOfInitializedData,4), Color.WHITE)),
(cstr('SizeOfStackCommit', Color.BLUE),
cstr(self._toHex(oh.SizeOfStackCommit,4), Color.WHITE)),
(cstr('SizeOfStackReserve', Color.BLUE),
cstr(self._toHex(oh.SizeOfStackReserve,4), Color.WHITE)),
(cstr('SizeOfUninitializedData', Color.BLUE),
cstr(self._toHex(oh.SizeOfUninitializedData,4), Color.WHITE)),
(cstr('Subsystem', Color.BLUE),
cstr(self._toHex(oh.Subsystem,4), Color.WHITE)),
(cstr('Win32VersionValue', Color.BLUE),
cstr(self._toHex(oh.Win32VersionValue,4), Color.WHITE))
]
self._printTable('Image Optional Headers', (cstr('Name', Color.LIGHT_GRAY), cstr('Value',Color.LIGHT_GRAY)), data)
def printDllCharacteristics(self, pefile):
dllc = pefile._binary.imageNtHeaders.header.OptionalHeader.DllCharacteristics
yes = cstr('Yes', Color.YELLOW)
no = cstr('NO', Color.GREEN)
data = [
(cstr('DynamicBase', Color.BLUE), yes if (
dllc & ImageDllCharacteristics.DYNAMIC_BASE) > 0 else no),
(cstr('ForceIntegrity', Color.BLUE), yes if (
dllc & ImageDllCharacteristics.FORCE_INTEGRITY) > 0 else no),
(cstr('NxCompat', Color.BLUE), yes if (
dllc & ImageDllCharacteristics.NX_COMPAT) > 0 else no),
(cstr('No Isolation', Color.BLUE), yes if (
dllc & ImageDllCharacteristics.NO_ISOLATION) > 0 else no),
(cstr('No SEH', Color.BLUE), yes if (dllc & ImageDllCharacteristics.NO_SEH)
> 0 else no),
(cstr('No Bind', Color.BLUE), yes if (dllc & ImageDllCharacteristics.NO_BIND)
> 0 else no),
(cstr('WdmDriver', Color.BLUE), yes if (
dllc & ImageDllCharacteristics.WDM_DRIVER) > 0 else no),
(cstr('ControlFLowGuard', Color.BLUE), yes if (
dllc & ImageDllCharacteristics.CONTROL_FLOW_GUARD) > 0 else no),
(cstr('TerminalServerAware', Color.BLUE), yes if (
dllc & ImageDllCharacteristics.TERMINAL_SERVER_AWARE) > 0 else no)
]
self._printTable('DllCharacteristics', (cstr('Name', Color.LIGHT_GRAY), cstr('Value', Color.LIGHT_GRAY)), data)
def printEntryPoint(self, binary):
self._printLine(self._toHex(binary.entryPoint, binary.arch.addressLength))
def printImageBase(self, binary):
self._printLine(
self._toHex(binary.imageBase, binary.arch.addressLength))
def printImports(self, pefile):
imports = pefile._binary.dataDirectory[pe.ImageDirectoryEntry.IMPORT]
if imports:
data = []
for descriptorData in imports:
for function in descriptorData.importAddressTable:
if function.ordinal:
data.append((cstr(descriptorData.dllName, Color.BLUE),
cstr(self._toHex(pefile._binary.imageBase + function.rva,pefile.arch.addressLength), Color.CYAN),
cstr(hex(function.ordinal), Color.LIGHT_GRAY),
cstr('', Color.WHITE)))
else:
data.append((cstr(descriptorData.dllName, Color.BLUE),
cstr(self._toHex(pefile._binary.imageBase+function.rva,pefile.arch.addressLength), Color.CYAN),
cstr(hex(function.importByName.hint) if function.importByName else '', Color.LIGHT_GRAY),
cstr(function.importByName.name if function.importByName else '', Color.WHITE)))
self._printTable(
'Imports', (cstr('DLL', Color.LIGHT_GRAY), cstr('Address', Color.LIGHT_GRAY), cstr('Hint/Ordinal', Color.LIGHT_GRAY), cstr('Function', Color.LIGHT_GRAY)), data)
else:
print('No imports!')
def printSections(self, pefile):
data = []
for section in pefile._binary.sections:
data.append((cstr(section.header.Name, Color.BLUE),
cstr(self._toHex(section.header.VirtualAddress,pefile.arch.addressLength), Color.CYAN),
cstr(self._toHex(section.header.SizeOfRawData), Color.LIGHT_GRAY),
cstr(self._toHex(section.header.PointerToRawData,pefile.arch.addressLength), Color.WHITE),
cstr(self._toHex(section.header.PointerToRelocations,pefile.arch.addressLength), Color.LIGHT_GRAY),
cstr(self._toHex(section.header.NumberOfRelocations), Color.WHITE),))
self._printTable(
'Section Header', (cstr('Name', Color.LIGHT_GRAY), cstr('VAddr', Color.LIGHT_GRAY), cstr('RawDataSize', Color.LIGHT_GRAY), cstr('RawDataPtr', Color.LIGHT_GRAY), cstr('RelocPtr', Color.LIGHT_GRAY), cstr('NrOfReloc', Color.LIGHT_GRAY)), data)
def printArchitecture(self, binary):
self._printLine(str(binary.arch))
def printFileType(self, binary):
self._printLine(str(binary.type)) | /ropper2-2.0.10-py3-none-any.whl/ropper/printer/peprinter.py | 0.683842 | 0.174586 | peprinter.py | pypi |
=====
RoPWR
=====
.. image:: https://github.com/guillermo-navas-palencia/ropwr/workflows/CI/badge.svg
:target: https://github.com/guillermo-navas-palencia/ropwr/workflows/CI/badge.svg
.. image:: https://img.shields.io/github/license/guillermo-navas-palencia/ropwr
:target: https://img.shields.io/github/license/guillermo-navas-palencia/ropwr
.. image:: https://img.shields.io/pypi/v/ropwr?color=blue
:target: https://img.shields.io/pypi/v/ropwr?color=blue
.. image:: https://pepy.tech/badge/ropwr
:target: https://pepy.tech/project/ropwr
The **RoPWR** library implements several mathematical programming formulations
to compute the optimal continuous/discontinuous piecewise polynomial regression
given a list of split points. It supports several monotonic constraints,
objective functions and regularizations. The library is written in Python and
relies on cvxpy (ECOS, OSQP, SCS and HIGHS solvers) to solve the underlying optimization
problems. Other formulations are solved using a direct approach.
.. contents:: **Table of Contents**
Installation
============
To install the current release of ropwr from PyPI:
.. code-block:: text
pip install ropwr
To install from source, download or clone the git repository
.. code-block:: text
git clone https://github.com/guillermo-navas-palencia/ropwr.git
cd ropwr
python setup.py install
Dependencies
------------
RoPWR requires
* cvxpy (>=1.1.14)
* numpy (>=1.16)
* scikit-learn (>=0.22)
* scipy (>=1.6.1)
Getting started
===============
Please visit the RoPWR documentation (**current** release) http://gnpalencia.org/ropwr/. You can get started following the `tutorial <http://gnpalencia.org/ropwr/tutorials/tutorial.html>`_ and checking the API reference.
Examples
--------
To get us started, let’s load a well-known dataset from the UCI repository and transform the data into a ``pandas.DataFrame``.
.. code-block:: python
import pandas as pd
from sklearn.datasets import load_boston
data = load_boston()
df = pd.DataFrame(data.data, columns=data.feature_names)
x = df["NOX"].values
y = data.target
To devise split points, we use the implementation of the unsupervised technique equal-size or equal-frequency interval implemented in scikit-learn ``KBinsDiscretizer``.
.. code-block:: python
from sklearn.preprocessing import KBinsDiscretizer
from ropwr import RobustPWRegression
est = KBinsDiscretizer(n_bins=10, strategy="quantile")
est.fit(x.reshape(-1, 1), y)
splits = est.bin_edges_[0][1:-1]
If the trend of the relationship with the target is unclear, use the default piecewise regression.
.. code-block:: python
pw = RobustPWRegression()
pw.fit(x, y, splits)
.. image:: doc/source/_images/pw_default.png
:target: doc/source/_images/pw_default.png
The relationship with the target exhibits a sort of U-shaped trend. Let's try to force convexity.
.. code-block:: python
pw = RobustPWRegression(objective="l1", degree=1, monotonic_trend="convex")
pw.fit(x, y, splits)
.. image:: doc/source/_images/pw_convex.png
:target: doc/source/_images/pw_convex.png
To reduce the mean squared error (MSE) and mean absolute error (MAE), we replace convex by valley.
.. code-block:: python
pw = RobustPWRegression(objective="l1", degree=1, monotonic_trend="valley")
pw.fit(x, y, splits)
.. image:: doc/source/_images/pw_valley.png
:target: doc/source/_images/pw_valley.png
RoPWR supports four objectives functions ("l1", "l2", "huber", "quantile") and the addition of a
regularization term (l1-Lasso or l2-Ridge). Additionally, it permits imposing a lower or upper limit to the prediction.
.. code-block:: python
from sklearn.datasets import fetch_california_housing
data = fetch_california_housing()
df = pd.DataFrame(data.data, columns=data.feature_names)
x = df["MedInc"].values
y = df["target"].values
est = KBinsDiscretizer(n_bins=15, strategy="quantile")
est.fit(x.reshape(-1, 1), y)
splits = est.bin_edges_[0][1:-1]
pw = RobustPWRegression(objective="huber", monotonic_trend="ascending",
degree=2, regularization="l1", verbose=True)
pw.fit(x, y, splits, lb=1, ub=5)
.. code-block:: text
ECOS 2.0.7 - (C) embotech GmbH, Zurich Switzerland, 2012-15. Web: www.embotech.com/ECOS
It pcost dcost gap pres dres k/t mu step sigma IR | BT
0 +0.000e+00 -3.418e+04 +8e+05 7e-01 5e+00 1e+00 7e+00 --- --- 2 1 - | - -
1 -5.445e+03 -1.409e+04 +3e+05 3e-01 8e-02 1e+00 2e+00 0.8351 2e-01 2 1 1 | 0 0
2 -5.079e+03 -1.370e+04 +3e+05 3e-01 7e-02 1e+00 2e+00 0.1140 9e-01 2 1 2 | 0 0
3 +1.681e+03 -2.408e+03 +2e+05 2e-01 4e-02 7e-01 1e+00 0.6098 2e-01 2 1 2 | 0 0
4 +6.977e+03 +5.329e+03 +7e+04 7e-02 2e-02 3e-01 5e-01 0.6562 1e-01 2 1 2 | 0 0
5 +1.037e+04 +9.826e+03 +2e+04 2e-02 1e-02 9e-02 2e-01 0.7604 1e-01 2 2 2 | 0 0
6 +1.102e+04 +1.066e+04 +2e+04 1e-02 9e-03 6e-02 1e-01 0.4819 3e-01 2 2 1 | 0 0
7 +1.202e+04 +1.189e+04 +6e+03 5e-03 5e-03 2e-02 5e-02 0.7116 1e-01 1 2 2 | 0 0
8 +1.202e+04 +1.189e+04 +6e+03 5e-03 5e-03 2e-02 5e-02 0.0642 9e-01 2 2 1 | 0 0
9 +1.216e+04 +1.206e+04 +4e+03 4e-03 4e-03 1e-02 3e-02 0.3528 3e-01 2 2 2 | 0 0
10 +1.216e+04 +1.206e+04 +4e+03 4e-03 4e-03 1e-02 3e-02 0.0043 1e+00 1 2 2 | 0 0
11 +1.215e+04 +1.206e+04 +4e+03 4e-03 4e-03 1e-02 3e-02 0.1560 9e-01 3 2 2 | 0 0
12 +1.220e+04 +1.212e+04 +4e+03 3e-03 3e-03 1e-02 3e-02 0.2911 6e-01 2 2 2 | 0 0
13 +1.219e+04 +1.211e+04 +3e+03 3e-03 3e-03 9e-03 3e-02 0.7226 9e-01 1 1 2 | 0 0
14 +1.246e+04 +1.242e+04 +1e+03 1e-03 1e-03 4e-03 1e-02 0.5864 3e-02 2 2 1 | 0 0
15 +1.255e+04 +1.253e+04 +8e+02 7e-04 8e-04 2e-03 7e-03 0.5172 1e-01 2 2 1 | 0 0
16 +1.261e+04 +1.260e+04 +4e+02 3e-04 4e-04 1e-03 3e-03 0.5858 8e-02 1 1 1 | 0 0
17 +1.264e+04 +1.264e+04 +1e+02 1e-04 1e-04 3e-04 1e-03 0.9487 3e-01 1 2 2 | 0 0
18 +1.266e+04 +1.266e+04 +2e+01 1e-05 2e-05 4e-05 1e-04 0.8967 3e-02 1 2 2 | 0 0
19 +1.266e+04 +1.266e+04 +2e+00 2e-06 2e-06 5e-06 2e-05 0.8827 1e-02 2 1 1 | 0 0
20 +1.266e+04 +1.266e+04 +6e-01 5e-07 6e-07 1e-06 5e-06 0.9890 3e-01 1 1 1 | 0 0
21 +1.266e+04 +1.266e+04 +1e-01 9e-08 1e-07 2e-07 8e-07 0.8542 3e-02 2 1 1 | 0 0
22 +1.266e+04 +1.266e+04 +4e-02 3e-08 4e-08 9e-08 3e-07 0.8281 2e-01 2 1 1 | 0 0
23 +1.266e+04 +1.266e+04 +2e-02 1e-08 2e-08 4e-08 1e-07 0.7671 2e-01 2 1 1 | 0 0
24 +1.266e+04 +1.266e+04 +3e-03 2e-09 3e-09 6e-09 2e-08 0.9531 1e-01 2 1 1 | 0 0
25 +1.266e+04 +1.266e+04 +4e-05 3e-11 4e-11 8e-11 3e-10 0.9862 1e-04 2 1 1 | 0 0
OPTIMAL (within feastol=3.7e-11, reltol=2.8e-09, abstol=3.5e-05).
Runtime: 4.340140 seconds.
.. image:: doc/source/_images/pw_huber_reg_l1.png
:target: doc/source/_images/pw_huber_reg_l1.png
| /ropwr-0.3.0.tar.gz/ropwr-0.3.0/README.rst | 0.871653 | 0.731934 | README.rst | pypi |
from collections import ChainMap
import os
import yaml
class RosdocIndex(object):
def __init__(self, rosdoc_index_paths): # noqa: D107
self.forward_deps = self._read_folder(rosdoc_index_paths, 'deps')
self.reverse_deps = {}
self._build_reverse_deps()
self.metapackage_deps = self._read_folder(
rosdoc_index_paths, 'metapackage_deps')
self.metapackage_index = {}
self._build_metapackage_index()
self.locations = self._read_folder(rosdoc_index_paths, 'locations')
self.hashes = self._read_folder(rosdoc_index_paths, 'hashes')
def get_recursive_dependencies(self, pkg_name):
# since the dependencies available from the rosdoc_index are not in
# sync the algorithm must handle circular dependencies gracefully
recursive_deps = set([])
pkg_names = set([pkg_name])
while len(pkg_names) > 0:
name = pkg_names.pop()
if name not in self.forward_deps:
continue
deps = set(self.forward_deps[name])
assert name not in deps
# consider only new dependencies
deps -= recursive_deps
# add to set to be traversed
pkg_names |= deps
# add to recursive dependencies
recursive_deps |= deps
return recursive_deps
def set_forward_deps(self, key, deps):
self.forward_deps[key] = deps
self._build_reverse_deps()
def set_metapackage_deps(self, key, deps):
self.metapackage_deps[key] = deps
if deps is None:
del self.metapackage_deps[key]
self._build_metapackage_index()
def write_modified_data(self, path, folder_names=None):
all_folder_names = ['deps', 'metapackage_deps', 'locations', 'hashes']
if folder_names is None:
folder_names = all_folder_names
for folder_name in folder_names:
assert folder_name in all_folder_names
# write only the added / modified entries
if 'deps' in folder_names:
self._write_folder(path, 'deps', self.forward_deps.maps[0])
if 'metapackage_deps' in folder_names:
self._write_folder(
path, 'metapackage_deps', self.metapackage_deps.maps[0])
if 'locations' in folder_names:
self._write_folder(path, 'locations', self.locations.maps[0])
if 'hashes' in folder_names:
self._write_folder(path, 'hashes', self.hashes.maps[0])
# turn a list of folders with files into a ChainMap
def _read_folder(self, basepaths, folder_name):
maps = [{}] # the first dict will be used for added/modified entries
for basepath in basepaths:
data = {}
path = os.path.join(basepath, folder_name)
if os.path.exists(path):
for key in os.listdir(path):
with open(os.path.join(path, key), 'r') as h:
data[key] = yaml.load(h)
maps.append(data)
return ChainMap(*maps)
# write a dict to files where is the filenames equal the keys
def _write_folder(self, basepath, folder_name, data):
path = os.path.join(basepath, folder_name)
# ensure that thedirectory exists
if not os.path.isdir(path):
os.makedirs(path)
for key, values in data.items():
filename = os.path.join(path, key)
if values is not None:
with open(filename, 'w') as h:
yaml.safe_dump(values, h)
elif os.path.exists(filename):
os.remove(filename)
def _build_metapackage_index(self):
self.metapackage_index = {}
for pkg_name, deps in self.metapackage_deps.items():
for dep in deps or []:
self.metapackage_index.setdefault(dep, []).append(pkg_name)
def _build_reverse_deps(self):
self.reverse_deps = {}
for pkg_name, deps in self.forward_deps.items():
for dep in deps or []:
self.reverse_deps.setdefault(dep, []).append(pkg_name) | /ros_buildfarm-3.0.0-py3-none-any.whl/ros_buildfarm/rosdoc_index.py | 0.490236 | 0.231267 | rosdoc_index.py | pypi |
from .build_file import BuildFile
class CIBuildFile(BuildFile):
_type = 'ci-build'
def __init__(self, name, data):
assert 'type' in data, "Expected file type is '%s'" % \
CIBuildFile._type
assert data['type'] == CIBuildFile._type, \
"Expected file type is '%s', not '%s'" % \
(CIBuildFile._type, data['type'])
assert 'version' in data, \
"Source build file for '%s' lacks required version information" % \
self.name
assert int(data['version']) in [1], \
"Unable to handle '%s' format version '%d'." % \
(CIBuildFile._type, int(data['version']))
self.version = int(data['version'])
super(CIBuildFile, self).__init__(name, data)
self.build_tool = data.get('build_tool', 'colcon')
assert self.build_tool in ('catkin_make_isolated', 'colcon')
self.build_tool_args = None
if 'build_tool_args' in data:
self.build_tool_args = data['build_tool_args']
self.install_packages = []
if 'install_packages' in data:
self.install_packages = data['install_packages']
assert isinstance(self.install_packages, list)
self.jenkins_job_label = None
if 'jenkins_job_label' in data:
self.jenkins_job_label = data['jenkins_job_label']
self.jenkins_job_priority = None
if 'jenkins_job_priority' in data:
self.jenkins_job_priority = int(data['jenkins_job_priority'])
self.jenkins_job_schedule = None
if 'jenkins_job_schedule' in data:
self.jenkins_job_schedule = data['jenkins_job_schedule']
self.jenkins_job_timeout = None
if 'jenkins_job_timeout' in data:
self.jenkins_job_timeout = int(data['jenkins_job_timeout'])
self.package_selection_args = None
if 'package_selection_args' in data:
self.package_selection_args = data['package_selection_args']
self.repos_files = []
if 'repos_files' in data:
self.repos_files = data['repos_files']
assert isinstance(self.repos_files, list)
self.skip_rosdep_keys = []
if 'skip_rosdep_keys' in data:
self.skip_rosdep_keys = data['skip_rosdep_keys']
assert isinstance(self.skip_rosdep_keys, list)
self.test_branch = None
if 'test_branch' in data:
self.test_branch = data['test_branch']
self.underlay_from_ci_jobs = []
if 'underlay_from_ci_jobs' in data:
self.underlay_from_ci_jobs = data['underlay_from_ci_jobs']
assert isinstance(self.underlay_from_ci_jobs, list) | /ros_buildfarm-3.0.0-py3-none-any.whl/ros_buildfarm/config/ci_build_file.py | 0.555918 | 0.256646 | ci_build_file.py | pypi |
from .build_file import BuildFile
class SourceBuildFile(BuildFile):
_type = 'source-build'
def __init__(self, name, data): # noqa: D107
assert 'type' in data, "Expected file type is '%s'" % \
SourceBuildFile._type
assert data['type'] == SourceBuildFile._type, \
"Expected file type is '%s', not '%s'" % \
(SourceBuildFile._type, data['type'])
assert 'version' in data, \
"Source build file for '%s' lacks required version information" % \
self.name
assert int(data['version']) in [1, 2, 3], \
("Unable to handle '%s' format version '%d', please update " +
"rosdistro (e.g. on Ubuntu/Debian use: sudo apt update && " +
"sudo apt install --only-upgrade python-rosdistro)") % \
(SourceBuildFile._type, int(data['version']))
self.version = int(data['version'])
super(SourceBuildFile, self).__init__(name, data)
assert len(self.targets) > 0
self.jenkins_commit_job_priority = None
if 'jenkins_commit_job_priority' in data:
self.jenkins_commit_job_priority = \
int(data['jenkins_commit_job_priority'])
self.jenkins_pull_request_job_priority = None
if 'jenkins_pull_request_job_priority' in data:
self.jenkins_pull_request_job_priority = \
int(data['jenkins_pull_request_job_priority'])
self.jenkins_job_label = None
if 'jenkins_job_label' in data:
self.jenkins_job_label = data['jenkins_job_label']
self.jenkins_job_timeout = None
if 'jenkins_job_timeout' in data:
self.jenkins_job_timeout = int(data['jenkins_job_timeout'])
self.build_tool = data.get('build_tool', 'catkin_make_isolated')
assert self.build_tool in ('catkin_make_isolated', 'colcon')
self.notify_committers = None
self.notify_compiler_warnings = False
self.notify_pull_requests = False
if 'notifications' in data:
if 'committers' in data['notifications']:
self.notify_committers = \
bool(data['notifications']['committers'])
if 'compiler_warnings' in data['notifications']:
self.notify_compiler_warnings = \
bool(data['notifications']['compiler_warnings'])
if 'pull_requests' in data['notifications']:
self.notify_pull_requests = \
bool(data['notifications']['pull_requests'])
self.repository_blacklist = []
if 'repository_blacklist' in data:
self.repository_blacklist = data['repository_blacklist']
assert isinstance(self.repository_blacklist, list)
self.repository_whitelist = []
if 'repository_whitelist' in data:
self.repository_whitelist = data['repository_whitelist']
assert isinstance(self.repository_whitelist, list)
self.skip_ignored_repositories = None
if 'skip_ignored_repositories' in data:
self.skip_ignored_repositories = \
bool(data['skip_ignored_repositories'])
self.custom_rosdep_urls = []
if '_config' in data['targets']:
if 'custom_rosdep_urls' in data['targets']['_config']:
self.custom_rosdep_urls = \
data['targets']['_config']['custom_rosdep_urls']
assert isinstance(self.custom_rosdep_urls, list)
self.test_commits_default = False
self.test_commits_force = None
if 'test_commits' in data:
if 'default' in data['test_commits']:
self.test_commits_default = bool(
data['test_commits']['default'])
if 'force' in data['test_commits']:
self.test_commits_force = bool(
data['test_commits']['force'])
self.test_pull_requests_default = False
self.test_pull_requests_force = None
if 'test_pull_requests' in data:
if 'default' in data['test_pull_requests']:
self.test_pull_requests_default = bool(
data['test_pull_requests']['default'])
if 'force' in data['test_pull_requests']:
self.test_pull_requests_force = bool(
data['test_pull_requests']['force'])
self.collate_test_stats = bool(data.get('collate_test_stats', False))
def filter_repositories(self, repository_names):
res = set(repository_names)
if self.repository_whitelist:
res &= set(self.repository_whitelist)
res -= set(self.repository_blacklist)
return res | /ros_buildfarm-3.0.0-py3-none-any.whl/ros_buildfarm/config/source_build_file.py | 0.410284 | 0.324771 | source_build_file.py | pypi |
import abc
import builtins
import datetime
import enum
import typing
import jsii
import publication
import typing_extensions
from typeguard import check_type
from ._jsii import *
import ros_cdk_core as _ros_cdk_core_7adfd82f
class Configuration(
_ros_cdk_core_7adfd82f.Resource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-acm.Configuration",
):
'''A ROS resource type: ``ALIYUN::ACM::Configuration``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["ConfigurationProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
'''Create a new ``ALIYUN::ACM::Configuration``.
Param scope - scope in which this resource is defined
Param id - scoped id of the resource
Param props - resource properties
:param scope: -
:param id: -
:param props: -
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__894c3727e8dc6ff5c02aed2616f4464bbc7a2b75e51879c4121e6c240f1b6bc4)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@builtins.property
@jsii.member(jsii_name="attrDataId")
def attr_data_id(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute DataId: The ID of the configuration.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrDataId"))
@builtins.property
@jsii.member(jsii_name="attrGroup")
def attr_group(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute Group: Group.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrGroup"))
@builtins.property
@jsii.member(jsii_name="attrNamespaceId")
def attr_namespace_id(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute NamespaceId: ID of namespace.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrNamespaceId"))
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-acm.ConfigurationProps",
jsii_struct_bases=[],
name_mapping={
"content": "content",
"data_id": "dataId",
"namespace_id": "namespaceId",
"app_name": "appName",
"desc": "desc",
"group": "group",
"tags": "tags",
"type": "type",
},
)
class ConfigurationProps:
def __init__(
self,
*,
content: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
data_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
namespace_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
app_name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
desc: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
group: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
tags: typing.Optional[builtins.str] = None,
type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::ACM::Configuration``.
:param content: Property content: The contents of the configuration.
:param data_id: Property dataId: The ID of the configuration. Allowed characters are upper and lower case letters, numbers, decimal points (.), Colons (:), asterisks (*), underscores (_), and underscores (-). When the ID prefix is the following value, ACM will automatically use KMS service to encrypt this configuration: The prefix is cipher-: the KMS service is called to encrypt and decrypt the configuration. The size of the encrypted data does not exceed 4 KB, and the maximum does not exceed 6 KB. Special symbols such as and (&) will decrypt errors and are not recommended. The prefix is cipher-kms-aes-128-: using KMS's envelope encryption and decryption method, the configuration content can exceed 6 KB, up to 100 KB. The plain text data of the configuration content will not be transmitted to the KMS system, which is more secure and recommended.
:param namespace_id: Property namespaceId: ID of namespace.
:param app_name: Property appName: Configuration application name.
:param desc: Property desc: Configuration description explains.
:param group: Property group: Group.
:param tags: Property tags: Label configurations, such as the presence of a plurality of tags, separated by commas.
:param type: Property type: Provisioning content format, optional values as follows: text, json, xml, yaml, text/html, properties.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__ccb96fa8b80230bfab280308c9778990516f696e3f892ef3d2b8f4d66e11098f)
check_type(argname="argument content", value=content, expected_type=type_hints["content"])
check_type(argname="argument data_id", value=data_id, expected_type=type_hints["data_id"])
check_type(argname="argument namespace_id", value=namespace_id, expected_type=type_hints["namespace_id"])
check_type(argname="argument app_name", value=app_name, expected_type=type_hints["app_name"])
check_type(argname="argument desc", value=desc, expected_type=type_hints["desc"])
check_type(argname="argument group", value=group, expected_type=type_hints["group"])
check_type(argname="argument tags", value=tags, expected_type=type_hints["tags"])
check_type(argname="argument type", value=type, expected_type=type_hints["type"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"content": content,
"data_id": data_id,
"namespace_id": namespace_id,
}
if app_name is not None:
self._values["app_name"] = app_name
if desc is not None:
self._values["desc"] = desc
if group is not None:
self._values["group"] = group
if tags is not None:
self._values["tags"] = tags
if type is not None:
self._values["type"] = type
@builtins.property
def content(self) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property content: The contents of the configuration.'''
result = self._values.get("content")
assert result is not None, "Required property 'content' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def data_id(self) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property dataId: The ID of the configuration.
Allowed characters are upper and lower case letters, numbers, decimal points (.), Colons (:), asterisks (*), underscores (_), and underscores (-). When the ID prefix is the following value, ACM will automatically use KMS service to encrypt this configuration:
The prefix is cipher-: the KMS service is called to encrypt and decrypt the configuration. The size of the encrypted data does not exceed 4 KB, and the maximum does not exceed 6 KB. Special symbols such as and (&) will decrypt errors and are not recommended.
The prefix is cipher-kms-aes-128-: using KMS's envelope encryption and decryption method, the configuration content can exceed 6 KB, up to 100 KB. The plain text data of the configuration content will not be transmitted to the KMS system, which is more secure and recommended.
'''
result = self._values.get("data_id")
assert result is not None, "Required property 'data_id' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def namespace_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property namespaceId: ID of namespace.'''
result = self._values.get("namespace_id")
assert result is not None, "Required property 'namespace_id' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def app_name(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property appName: Configuration application name.'''
result = self._values.get("app_name")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def desc(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property desc: Configuration description explains.'''
result = self._values.get("desc")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def group(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property group: Group.'''
result = self._values.get("group")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def tags(self) -> typing.Optional[builtins.str]:
'''Property tags: Label configurations, such as the presence of a plurality of tags, separated by commas.'''
result = self._values.get("tags")
return typing.cast(typing.Optional[builtins.str], result)
@builtins.property
def type(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property type: Provisioning content format, optional values as follows: text, json, xml, yaml, text/html, properties.'''
result = self._values.get("type")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "ConfigurationProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class Namespace(
_ros_cdk_core_7adfd82f.Resource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-acm.Namespace",
):
'''A ROS resource type: ``ALIYUN::ACM::Namespace``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["NamespaceProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
'''Create a new ``ALIYUN::ACM::Namespace``.
Param scope - scope in which this resource is defined
Param id - scoped id of the resource
Param props - resource properties
:param scope: -
:param id: -
:param props: -
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__cae2b80892d06c0a4940f51bc1e758022c684754c242bd454be0a4c2a28454df)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@builtins.property
@jsii.member(jsii_name="attrEndpoint")
def attr_endpoint(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute Endpoint: Endpoint.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrEndpoint"))
@builtins.property
@jsii.member(jsii_name="attrNamespaceId")
def attr_namespace_id(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute NamespaceId: ID namespace.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrNamespaceId"))
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-acm.NamespaceProps",
jsii_struct_bases=[],
name_mapping={"name": "name"},
)
class NamespaceProps:
def __init__(
self,
*,
name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
'''Properties for defining a ``ALIYUN::ACM::Namespace``.
:param name: Property name: Namespace name.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__5f32f0c93abeee0d702f86bd8066b4c5941b44fe48f6dce3663d04260e7b62da)
check_type(argname="argument name", value=name, expected_type=type_hints["name"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"name": name,
}
@builtins.property
def name(self) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property name: Namespace name.'''
result = self._values.get("name")
assert result is not None, "Required property 'name' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "NamespaceProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class RosConfiguration(
_ros_cdk_core_7adfd82f.RosResource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-acm.RosConfiguration",
):
'''A ROS template type: ``ALIYUN::ACM::Configuration``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["RosConfigurationProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
'''Create a new ``ALIYUN::ACM::Configuration``.
:param scope: - scope in which this resource is defined.
:param id: - scoped id of the resource.
:param props: - resource properties.
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__a25089b984775d1efcf26f36fd2fb7849eb00506932f3fa2abc527a36d424a2e)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@jsii.member(jsii_name="renderProperties")
def _render_properties(
self,
props: typing.Mapping[builtins.str, typing.Any],
) -> typing.Mapping[builtins.str, typing.Any]:
'''
:param props: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__9980147988528f7a6c0634e54054e7d77f95af7f89f6497939707a765ddbf296)
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))
@jsii.python.classproperty
@jsii.member(jsii_name="ROS_RESOURCE_TYPE_NAME")
def ROS_RESOURCE_TYPE_NAME(cls) -> builtins.str:
'''The resource type name for this resource class.'''
return typing.cast(builtins.str, jsii.sget(cls, "ROS_RESOURCE_TYPE_NAME"))
@builtins.property
@jsii.member(jsii_name="attrDataId")
def attr_data_id(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: DataId: The ID of the configuration
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrDataId"))
@builtins.property
@jsii.member(jsii_name="attrGroup")
def attr_group(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: Group: Group
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrGroup"))
@builtins.property
@jsii.member(jsii_name="attrNamespaceId")
def attr_namespace_id(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: NamespaceId: ID of namespace
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrNamespaceId"))
@builtins.property
@jsii.member(jsii_name="rosProperties")
def _ros_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "rosProperties"))
@builtins.property
@jsii.member(jsii_name="content")
def content(self) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: content: The contents of the configuration
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "content"))
@content.setter
def content(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__3ba75ca7c510abbb8aeb97a35c38bb7a847f3f3fc6979ae79d5483702ee2bd85)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "content", value)
@builtins.property
@jsii.member(jsii_name="dataId")
def data_id(self) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
dataId: The ID of the configuration. Allowed characters are upper and lower case letters, numbers, decimal points (.), Colons (:), asterisks (*), underscores (_), and underscores (-). When the ID prefix is the following value, ACM will automatically use KMS service to encrypt this configuration:
The prefix is cipher-: the KMS service is called to encrypt and decrypt the configuration. The size of the encrypted data does not exceed 4 KB, and the maximum does not exceed 6 KB. Special symbols such as and (&) will decrypt errors and are not recommended.
The prefix is cipher-kms-aes-128-: using KMS's envelope encryption and decryption method, the configuration content can exceed 6 KB, up to 100 KB. The plain text data of the configuration content will not be transmitted to the KMS system, which is more secure and recommended.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "dataId"))
@data_id.setter
def data_id(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__cb329cea03f29cb5334dbd957d60bd396a05a94508854a4e8e53b39e5fd6ef4e)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "dataId", value)
@builtins.property
@jsii.member(jsii_name="enableResourcePropertyConstraint")
def enable_resource_property_constraint(self) -> builtins.bool:
return typing.cast(builtins.bool, jsii.get(self, "enableResourcePropertyConstraint"))
@enable_resource_property_constraint.setter
def enable_resource_property_constraint(self, value: builtins.bool) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__95e60de134ca10cd0e734a95ae446b2651ca9e498fc52035aa118f1da4ca6adf)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "enableResourcePropertyConstraint", value)
@builtins.property
@jsii.member(jsii_name="namespaceId")
def namespace_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: namespaceId: ID of namespace
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "namespaceId"))
@namespace_id.setter
def namespace_id(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__8cd5eb647c339a20df8223a9da78d9c8caec1be828eda0ee26ecf49f0abf2d59)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "namespaceId", value)
@builtins.property
@jsii.member(jsii_name="appName")
def app_name(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: appName: Configuration application name
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "appName"))
@app_name.setter
def app_name(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__5a0ab300108a674999743d0ab1072175c84a064094187a104b68c1f3cb93d072)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "appName", value)
@builtins.property
@jsii.member(jsii_name="desc")
def desc(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: desc: Configuration description explains
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "desc"))
@desc.setter
def desc(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__6612edcdc8340c7b1a679d71b8875c6a4e364ede7b7cedbbbecb2815110e7463)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "desc", value)
@builtins.property
@jsii.member(jsii_name="group")
def group(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: group: Group
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "group"))
@group.setter
def group(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__e2ea2e5a20f8eacbc961178ff9a12ef50c600e4fb2e4fbc4e7ecff4755657bf0)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "group", value)
@builtins.property
@jsii.member(jsii_name="tags")
def tags(self) -> typing.Optional[builtins.str]:
'''
:Property: tags: Label configurations, such as the presence of a plurality of tags, separated by commas
'''
return typing.cast(typing.Optional[builtins.str], jsii.get(self, "tags"))
@tags.setter
def tags(self, value: typing.Optional[builtins.str]) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__dc99f95936dd47510b69be40c755b44391870bf3776821b4a33b7116dffa45e5)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "tags", value)
@builtins.property
@jsii.member(jsii_name="type")
def type(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
type: Provisioning content format, optional values as follows:
text, json, xml, yaml, text/html, properties
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "type"))
@type.setter
def type(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__e12ec60b0dd37008ba94fa3cfc38584baf84e6b441b6ed44ea65261a4eadfd97)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "type", value)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-acm.RosConfigurationProps",
jsii_struct_bases=[],
name_mapping={
"content": "content",
"data_id": "dataId",
"namespace_id": "namespaceId",
"app_name": "appName",
"desc": "desc",
"group": "group",
"tags": "tags",
"type": "type",
},
)
class RosConfigurationProps:
def __init__(
self,
*,
content: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
data_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
namespace_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
app_name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
desc: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
group: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
tags: typing.Optional[builtins.str] = None,
type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::ACM::Configuration``.
:param content:
:param data_id:
:param namespace_id:
:param app_name:
:param desc:
:param group:
:param tags:
:param type:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__8a9dd18ee5755301e6447abec7537d4139de646a58dcce2df4becb85fd5f22b1)
check_type(argname="argument content", value=content, expected_type=type_hints["content"])
check_type(argname="argument data_id", value=data_id, expected_type=type_hints["data_id"])
check_type(argname="argument namespace_id", value=namespace_id, expected_type=type_hints["namespace_id"])
check_type(argname="argument app_name", value=app_name, expected_type=type_hints["app_name"])
check_type(argname="argument desc", value=desc, expected_type=type_hints["desc"])
check_type(argname="argument group", value=group, expected_type=type_hints["group"])
check_type(argname="argument tags", value=tags, expected_type=type_hints["tags"])
check_type(argname="argument type", value=type, expected_type=type_hints["type"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"content": content,
"data_id": data_id,
"namespace_id": namespace_id,
}
if app_name is not None:
self._values["app_name"] = app_name
if desc is not None:
self._values["desc"] = desc
if group is not None:
self._values["group"] = group
if tags is not None:
self._values["tags"] = tags
if type is not None:
self._values["type"] = type
@builtins.property
def content(self) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: content: The contents of the configuration
'''
result = self._values.get("content")
assert result is not None, "Required property 'content' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def data_id(self) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
dataId: The ID of the configuration. Allowed characters are upper and lower case letters, numbers, decimal points (.), Colons (:), asterisks (*), underscores (_), and underscores (-). When the ID prefix is the following value, ACM will automatically use KMS service to encrypt this configuration:
The prefix is cipher-: the KMS service is called to encrypt and decrypt the configuration. The size of the encrypted data does not exceed 4 KB, and the maximum does not exceed 6 KB. Special symbols such as and (&) will decrypt errors and are not recommended.
The prefix is cipher-kms-aes-128-: using KMS's envelope encryption and decryption method, the configuration content can exceed 6 KB, up to 100 KB. The plain text data of the configuration content will not be transmitted to the KMS system, which is more secure and recommended.
'''
result = self._values.get("data_id")
assert result is not None, "Required property 'data_id' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def namespace_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: namespaceId: ID of namespace
'''
result = self._values.get("namespace_id")
assert result is not None, "Required property 'namespace_id' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def app_name(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: appName: Configuration application name
'''
result = self._values.get("app_name")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def desc(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: desc: Configuration description explains
'''
result = self._values.get("desc")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def group(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: group: Group
'''
result = self._values.get("group")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def tags(self) -> typing.Optional[builtins.str]:
'''
:Property: tags: Label configurations, such as the presence of a plurality of tags, separated by commas
'''
result = self._values.get("tags")
return typing.cast(typing.Optional[builtins.str], result)
@builtins.property
def type(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
type: Provisioning content format, optional values as follows:
text, json, xml, yaml, text/html, properties
'''
result = self._values.get("type")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "RosConfigurationProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class RosNamespace(
_ros_cdk_core_7adfd82f.RosResource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-acm.RosNamespace",
):
'''A ROS template type: ``ALIYUN::ACM::Namespace``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["RosNamespaceProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
'''Create a new ``ALIYUN::ACM::Namespace``.
:param scope: - scope in which this resource is defined.
:param id: - scoped id of the resource.
:param props: - resource properties.
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__68ce53df2af3f3d1e4b722ce9e5245d559c4befe9d2710f7f3508604b7f69724)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@jsii.member(jsii_name="renderProperties")
def _render_properties(
self,
props: typing.Mapping[builtins.str, typing.Any],
) -> typing.Mapping[builtins.str, typing.Any]:
'''
:param props: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__8de63ccf436fc8634c4c1fb5a22e9e193697f1858248bd352d221fc606af160e)
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))
@jsii.python.classproperty
@jsii.member(jsii_name="ROS_RESOURCE_TYPE_NAME")
def ROS_RESOURCE_TYPE_NAME(cls) -> builtins.str:
'''The resource type name for this resource class.'''
return typing.cast(builtins.str, jsii.sget(cls, "ROS_RESOURCE_TYPE_NAME"))
@builtins.property
@jsii.member(jsii_name="attrEndpoint")
def attr_endpoint(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: Endpoint: Endpoint
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrEndpoint"))
@builtins.property
@jsii.member(jsii_name="attrNamespaceId")
def attr_namespace_id(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: NamespaceId: ID namespace
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrNamespaceId"))
@builtins.property
@jsii.member(jsii_name="rosProperties")
def _ros_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "rosProperties"))
@builtins.property
@jsii.member(jsii_name="enableResourcePropertyConstraint")
def enable_resource_property_constraint(self) -> builtins.bool:
return typing.cast(builtins.bool, jsii.get(self, "enableResourcePropertyConstraint"))
@enable_resource_property_constraint.setter
def enable_resource_property_constraint(self, value: builtins.bool) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__ef8aac44f5d016c3d3c6faecaae454729b31e47a92cffca1a8b436d3d985726d)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "enableResourcePropertyConstraint", value)
@builtins.property
@jsii.member(jsii_name="name")
def name(self) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: name: Namespace name
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "name"))
@name.setter
def name(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__04cd278254f8758bbf93aab6305c0a5045e985f04b9bb44983cc129f76f43ce5)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "name", value)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-acm.RosNamespaceProps",
jsii_struct_bases=[],
name_mapping={"name": "name"},
)
class RosNamespaceProps:
def __init__(
self,
*,
name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
'''Properties for defining a ``ALIYUN::ACM::Namespace``.
:param name:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__223598296db8abf819d4cf0511cdb5df247acd0cba895f5f416db42cb31c7418)
check_type(argname="argument name", value=name, expected_type=type_hints["name"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"name": name,
}
@builtins.property
def name(self) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: name: Namespace name
'''
result = self._values.get("name")
assert result is not None, "Required property 'name' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "RosNamespaceProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
__all__ = [
"Configuration",
"ConfigurationProps",
"Namespace",
"NamespaceProps",
"RosConfiguration",
"RosConfigurationProps",
"RosNamespace",
"RosNamespaceProps",
"datasource",
]
publication.publish()
# Loading modules to ensure their types are registered with the jsii runtime library
from . import datasource
def _typecheckingstub__894c3727e8dc6ff5c02aed2616f4464bbc7a2b75e51879c4121e6c240f1b6bc4(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[ConfigurationProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__ccb96fa8b80230bfab280308c9778990516f696e3f892ef3d2b8f4d66e11098f(
*,
content: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
data_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
namespace_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
app_name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
desc: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
group: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
tags: typing.Optional[builtins.str] = None,
type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__cae2b80892d06c0a4940f51bc1e758022c684754c242bd454be0a4c2a28454df(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[NamespaceProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__5f32f0c93abeee0d702f86bd8066b4c5941b44fe48f6dce3663d04260e7b62da(
*,
name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__a25089b984775d1efcf26f36fd2fb7849eb00506932f3fa2abc527a36d424a2e(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[RosConfigurationProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__9980147988528f7a6c0634e54054e7d77f95af7f89f6497939707a765ddbf296(
props: typing.Mapping[builtins.str, typing.Any],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__3ba75ca7c510abbb8aeb97a35c38bb7a847f3f3fc6979ae79d5483702ee2bd85(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__cb329cea03f29cb5334dbd957d60bd396a05a94508854a4e8e53b39e5fd6ef4e(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__95e60de134ca10cd0e734a95ae446b2651ca9e498fc52035aa118f1da4ca6adf(
value: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__8cd5eb647c339a20df8223a9da78d9c8caec1be828eda0ee26ecf49f0abf2d59(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__5a0ab300108a674999743d0ab1072175c84a064094187a104b68c1f3cb93d072(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__6612edcdc8340c7b1a679d71b8875c6a4e364ede7b7cedbbbecb2815110e7463(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__e2ea2e5a20f8eacbc961178ff9a12ef50c600e4fb2e4fbc4e7ecff4755657bf0(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__dc99f95936dd47510b69be40c755b44391870bf3776821b4a33b7116dffa45e5(
value: typing.Optional[builtins.str],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__e12ec60b0dd37008ba94fa3cfc38584baf84e6b441b6ed44ea65261a4eadfd97(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__8a9dd18ee5755301e6447abec7537d4139de646a58dcce2df4becb85fd5f22b1(
*,
content: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
data_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
namespace_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
app_name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
desc: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
group: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
tags: typing.Optional[builtins.str] = None,
type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__68ce53df2af3f3d1e4b722ce9e5245d559c4befe9d2710f7f3508604b7f69724(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[RosNamespaceProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__8de63ccf436fc8634c4c1fb5a22e9e193697f1858248bd352d221fc606af160e(
props: typing.Mapping[builtins.str, typing.Any],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__ef8aac44f5d016c3d3c6faecaae454729b31e47a92cffca1a8b436d3d985726d(
value: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__04cd278254f8758bbf93aab6305c0a5045e985f04b9bb44983cc129f76f43ce5(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__223598296db8abf819d4cf0511cdb5df247acd0cba895f5f416db42cb31c7418(
*,
name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass | /ros-cdk-acm-1.0.17.tar.gz/ros-cdk-acm-1.0.17/src/ros_cdk_acm/__init__.py | 0.630116 | 0.166404 | __init__.py | pypi |
import abc
import builtins
import datetime
import enum
import typing
import jsii
import publication
import typing_extensions
from typeguard import check_type
from .._jsii import *
import ros_cdk_core as _ros_cdk_core_7adfd82f
class Configurations(
_ros_cdk_core_7adfd82f.Resource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-acm.datasource.Configurations",
):
'''A ROS resource type: ``DATASOURCE::ACM::Configurations``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["ConfigurationsProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
'''Create a new ``DATASOURCE::ACM::Configurations``.
Param scope - scope in which this resource is defined
Param id - scoped id of the resource
Param props - resource properties
:param scope: -
:param id: -
:param props: -
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__b3041a7f53627c8d1ecb69da2495fea2c9f690e7d3530c4549348a0f62d93755)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@builtins.property
@jsii.member(jsii_name="attrConfigurations")
def attr_configurations(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute Configurations: The list of configurations.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrConfigurations"))
@builtins.property
@jsii.member(jsii_name="attrDataIds")
def attr_data_ids(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute DataIds: The list of configuration data IDs.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrDataIds"))
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-acm.datasource.ConfigurationsProps",
jsii_struct_bases=[],
name_mapping={
"namespace_id": "namespaceId",
"app_name": "appName",
"data_id": "dataId",
"group": "group",
},
)
class ConfigurationsProps:
def __init__(
self,
*,
namespace_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
app_name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
data_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
group: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``DATASOURCE::ACM::Configurations``.
:param namespace_id: Property namespaceId: The namespace ID of configuration.
:param app_name: Property appName: The app name of configuration.
:param data_id: Property dataId: The data ID of configuration.
:param group: Property group: The group of configuration.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__ffc1fb33063c2473cbe1972b9b7e1d9df3de6329b83404eeb0d4448005026bb4)
check_type(argname="argument namespace_id", value=namespace_id, expected_type=type_hints["namespace_id"])
check_type(argname="argument app_name", value=app_name, expected_type=type_hints["app_name"])
check_type(argname="argument data_id", value=data_id, expected_type=type_hints["data_id"])
check_type(argname="argument group", value=group, expected_type=type_hints["group"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"namespace_id": namespace_id,
}
if app_name is not None:
self._values["app_name"] = app_name
if data_id is not None:
self._values["data_id"] = data_id
if group is not None:
self._values["group"] = group
@builtins.property
def namespace_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property namespaceId: The namespace ID of configuration.'''
result = self._values.get("namespace_id")
assert result is not None, "Required property 'namespace_id' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def app_name(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property appName: The app name of configuration.'''
result = self._values.get("app_name")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def data_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property dataId: The data ID of configuration.'''
result = self._values.get("data_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def group(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property group: The group of configuration.'''
result = self._values.get("group")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "ConfigurationsProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class Namespaces(
_ros_cdk_core_7adfd82f.Resource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-acm.datasource.Namespaces",
):
'''A ROS resource type: ``DATASOURCE::ACM::Namespaces``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Optional[typing.Union["NamespacesProps", typing.Dict[builtins.str, typing.Any]]] = None,
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
'''Create a new ``DATASOURCE::ACM::Namespaces``.
Param scope - scope in which this resource is defined
Param id - scoped id of the resource
Param props - resource properties
:param scope: -
:param id: -
:param props: -
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__53c5873e1def3b2a9cbbd7ebb5ca731cc95a405e4e6bec9b4887ff4fa932f76a)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@builtins.property
@jsii.member(jsii_name="attrNamespaceIds")
def attr_namespace_ids(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute NamespaceIds: The list of namespace IDs.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrNamespaceIds"))
@builtins.property
@jsii.member(jsii_name="attrNamespaces")
def attr_namespaces(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute Namespaces: The list of namespaces.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrNamespaces"))
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-acm.datasource.NamespacesProps",
jsii_struct_bases=[],
name_mapping={},
)
class NamespacesProps:
def __init__(self) -> None:
'''Properties for defining a ``DATASOURCE::ACM::Namespaces``.'''
self._values: typing.Dict[builtins.str, typing.Any] = {}
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "NamespacesProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class RosConfigurations(
_ros_cdk_core_7adfd82f.RosResource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-acm.datasource.RosConfigurations",
):
'''A ROS template type: ``DATASOURCE::ACM::Configurations``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["RosConfigurationsProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
'''Create a new ``DATASOURCE::ACM::Configurations``.
:param scope: - scope in which this resource is defined.
:param id: - scoped id of the resource.
:param props: - resource properties.
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__2dd6805668d6b96aa352e92151fba82bb38b214eb7fe8d0f4a727ad83193a60a)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@jsii.member(jsii_name="renderProperties")
def _render_properties(
self,
props: typing.Mapping[builtins.str, typing.Any],
) -> typing.Mapping[builtins.str, typing.Any]:
'''
:param props: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__19c0736a31cabc49371426e7c557e17585aaaeac4b2e4937c2844dc611eda4c6)
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))
@jsii.python.classproperty
@jsii.member(jsii_name="ROS_RESOURCE_TYPE_NAME")
def ROS_RESOURCE_TYPE_NAME(cls) -> builtins.str:
'''The resource type name for this resource class.'''
return typing.cast(builtins.str, jsii.sget(cls, "ROS_RESOURCE_TYPE_NAME"))
@builtins.property
@jsii.member(jsii_name="attrConfigurations")
def attr_configurations(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: Configurations: The list of configurations.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrConfigurations"))
@builtins.property
@jsii.member(jsii_name="attrDataIds")
def attr_data_ids(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: DataIds: The list of configuration data IDs.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrDataIds"))
@builtins.property
@jsii.member(jsii_name="rosProperties")
def _ros_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "rosProperties"))
@builtins.property
@jsii.member(jsii_name="enableResourcePropertyConstraint")
def enable_resource_property_constraint(self) -> builtins.bool:
return typing.cast(builtins.bool, jsii.get(self, "enableResourcePropertyConstraint"))
@enable_resource_property_constraint.setter
def enable_resource_property_constraint(self, value: builtins.bool) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__c25b97fbd6f657df4687b8ecd41610a45cba2886843d09a01100b83dc7587874)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "enableResourcePropertyConstraint", value)
@builtins.property
@jsii.member(jsii_name="namespaceId")
def namespace_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: namespaceId: The namespace ID of configuration
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "namespaceId"))
@namespace_id.setter
def namespace_id(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__f8057e33d1f698a9bb9e4a793392a9e36195e216b6069607d25d8a34ad8367a0)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "namespaceId", value)
@builtins.property
@jsii.member(jsii_name="appName")
def app_name(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: appName: The app name of configuration
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "appName"))
@app_name.setter
def app_name(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__c4fbc1e44ddd8b34ded7ebdb5fc72bbe8e3ffd5b248ccce3402b6473578a06a5)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "appName", value)
@builtins.property
@jsii.member(jsii_name="dataId")
def data_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: dataId: The data ID of configuration
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "dataId"))
@data_id.setter
def data_id(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__73d1437abe67da9fe74ba842ad72c5bf1d103e4edae509fd862abcb34db1192d)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "dataId", value)
@builtins.property
@jsii.member(jsii_name="group")
def group(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: group: The group of configuration
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "group"))
@group.setter
def group(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__676c2a56bb563b9524ac308bec7177822021526719c60e6a7d7a4e7b4c620e58)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "group", value)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-acm.datasource.RosConfigurationsProps",
jsii_struct_bases=[],
name_mapping={
"namespace_id": "namespaceId",
"app_name": "appName",
"data_id": "dataId",
"group": "group",
},
)
class RosConfigurationsProps:
def __init__(
self,
*,
namespace_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
app_name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
data_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
group: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``DATASOURCE::ACM::Configurations``.
:param namespace_id:
:param app_name:
:param data_id:
:param group:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__74500ea7e19f71298c88bb657bd096241aca03595155ea49f157abb8eb8b1802)
check_type(argname="argument namespace_id", value=namespace_id, expected_type=type_hints["namespace_id"])
check_type(argname="argument app_name", value=app_name, expected_type=type_hints["app_name"])
check_type(argname="argument data_id", value=data_id, expected_type=type_hints["data_id"])
check_type(argname="argument group", value=group, expected_type=type_hints["group"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"namespace_id": namespace_id,
}
if app_name is not None:
self._values["app_name"] = app_name
if data_id is not None:
self._values["data_id"] = data_id
if group is not None:
self._values["group"] = group
@builtins.property
def namespace_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: namespaceId: The namespace ID of configuration
'''
result = self._values.get("namespace_id")
assert result is not None, "Required property 'namespace_id' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def app_name(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: appName: The app name of configuration
'''
result = self._values.get("app_name")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def data_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: dataId: The data ID of configuration
'''
result = self._values.get("data_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def group(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: group: The group of configuration
'''
result = self._values.get("group")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "RosConfigurationsProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class RosNamespaces(
_ros_cdk_core_7adfd82f.RosResource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-acm.datasource.RosNamespaces",
):
'''A ROS template type: ``DATASOURCE::ACM::Namespaces``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["RosNamespacesProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
'''Create a new ``DATASOURCE::ACM::Namespaces``.
:param scope: - scope in which this resource is defined.
:param id: - scoped id of the resource.
:param props: - resource properties.
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__26dc32255571d4128904dc9f45e867c4916697672040bdca2c81ed2d17fefc9e)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@jsii.member(jsii_name="renderProperties")
def _render_properties(
self,
props: typing.Mapping[builtins.str, typing.Any],
) -> typing.Mapping[builtins.str, typing.Any]:
'''
:param props: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__c88da05b829d318a93a3290f03a574eb5c8b1fe61520f4f58c50089f6b4a5a7b)
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))
@jsii.python.classproperty
@jsii.member(jsii_name="ROS_RESOURCE_TYPE_NAME")
def ROS_RESOURCE_TYPE_NAME(cls) -> builtins.str:
'''The resource type name for this resource class.'''
return typing.cast(builtins.str, jsii.sget(cls, "ROS_RESOURCE_TYPE_NAME"))
@builtins.property
@jsii.member(jsii_name="attrNamespaceIds")
def attr_namespace_ids(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: NamespaceIds: The list of namespace IDs.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrNamespaceIds"))
@builtins.property
@jsii.member(jsii_name="attrNamespaces")
def attr_namespaces(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: Namespaces: The list of namespaces.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrNamespaces"))
@builtins.property
@jsii.member(jsii_name="rosProperties")
def _ros_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "rosProperties"))
@builtins.property
@jsii.member(jsii_name="enableResourcePropertyConstraint")
def enable_resource_property_constraint(self) -> builtins.bool:
return typing.cast(builtins.bool, jsii.get(self, "enableResourcePropertyConstraint"))
@enable_resource_property_constraint.setter
def enable_resource_property_constraint(self, value: builtins.bool) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__63ddb3fc74f749da72716bdc9c686229c483465b3aaf742b8c7329f4237825fd)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "enableResourcePropertyConstraint", value)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-acm.datasource.RosNamespacesProps",
jsii_struct_bases=[],
name_mapping={},
)
class RosNamespacesProps:
def __init__(self) -> None:
'''Properties for defining a ``DATASOURCE::ACM::Namespaces``.'''
self._values: typing.Dict[builtins.str, typing.Any] = {}
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "RosNamespacesProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
__all__ = [
"Configurations",
"ConfigurationsProps",
"Namespaces",
"NamespacesProps",
"RosConfigurations",
"RosConfigurationsProps",
"RosNamespaces",
"RosNamespacesProps",
]
publication.publish()
def _typecheckingstub__b3041a7f53627c8d1ecb69da2495fea2c9f690e7d3530c4549348a0f62d93755(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[ConfigurationsProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__ffc1fb33063c2473cbe1972b9b7e1d9df3de6329b83404eeb0d4448005026bb4(
*,
namespace_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
app_name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
data_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
group: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__53c5873e1def3b2a9cbbd7ebb5ca731cc95a405e4e6bec9b4887ff4fa932f76a(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Optional[typing.Union[NamespacesProps, typing.Dict[builtins.str, typing.Any]]] = None,
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__2dd6805668d6b96aa352e92151fba82bb38b214eb7fe8d0f4a727ad83193a60a(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[RosConfigurationsProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__19c0736a31cabc49371426e7c557e17585aaaeac4b2e4937c2844dc611eda4c6(
props: typing.Mapping[builtins.str, typing.Any],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__c25b97fbd6f657df4687b8ecd41610a45cba2886843d09a01100b83dc7587874(
value: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__f8057e33d1f698a9bb9e4a793392a9e36195e216b6069607d25d8a34ad8367a0(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__c4fbc1e44ddd8b34ded7ebdb5fc72bbe8e3ffd5b248ccce3402b6473578a06a5(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__73d1437abe67da9fe74ba842ad72c5bf1d103e4edae509fd862abcb34db1192d(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__676c2a56bb563b9524ac308bec7177822021526719c60e6a7d7a4e7b4c620e58(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__74500ea7e19f71298c88bb657bd096241aca03595155ea49f157abb8eb8b1802(
*,
namespace_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
app_name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
data_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
group: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__26dc32255571d4128904dc9f45e867c4916697672040bdca2c81ed2d17fefc9e(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[RosNamespacesProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__c88da05b829d318a93a3290f03a574eb5c8b1fe61520f4f58c50089f6b4a5a7b(
props: typing.Mapping[builtins.str, typing.Any],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__63ddb3fc74f749da72716bdc9c686229c483465b3aaf742b8c7329f4237825fd(
value: builtins.bool,
) -> None:
"""Type checking stubs"""
pass | /ros-cdk-acm-1.0.17.tar.gz/ros-cdk-acm-1.0.17/src/ros_cdk_acm/datasource/__init__.py | 0.641871 | 0.163813 | __init__.py | pypi |
import abc
import builtins
import datetime
import enum
import typing
import jsii
import publication
import typing_extensions
from typeguard import check_type
from ._jsii import *
import ros_cdk_core as _ros_cdk_core_7adfd82f
class Binding(
_ros_cdk_core_7adfd82f.Resource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-amqp.Binding",
):
'''A ROS resource type: ``ALIYUN::AMQP::Binding``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["BindingProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
'''Create a new ``ALIYUN::AMQP::Binding``.
Param scope - scope in which this resource is defined
Param id - scoped id of the resource
Param props - resource properties
:param scope: -
:param id: -
:param props: -
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__1f96cf7feb719b7dcc39c3887d52562dc4b869b04056e71ea317c8eaca2aaf16)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-amqp.BindingProps",
jsii_struct_bases=[],
name_mapping={
"argument": "argument",
"binding_key": "bindingKey",
"binding_type": "bindingType",
"destination_name": "destinationName",
"instance_id": "instanceId",
"source_exchange": "sourceExchange",
"virtual_host": "virtualHost",
},
)
class BindingProps:
def __init__(
self,
*,
argument: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
binding_key: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
binding_type: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
destination_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
instance_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
source_exchange: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
virtual_host: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
'''Properties for defining a ``ALIYUN::AMQP::Binding``.
:param argument: Property argument: X-match Attributes. Valid Values: "x-match:all": Default Value, All the Message Header of Key-Value Pairs Stored in the Must Match. "x-match:any": at Least One Pair of the Message Header of Key-Value Pairs Stored in the Must Match.
:param binding_key: Property bindingKey: The Binding Key.
:param binding_type: Property bindingType: The Target Binding Types. Valid values: EXCHANGE, QUEUE.
:param destination_name: Property destinationName: The Target Queue Or Exchange of the Name.
:param instance_id: Property instanceId: InstanceId.
:param source_exchange: Property sourceExchange: The Source Exchange Name.
:param virtual_host: Property virtualHost: The name of the virtual host.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__4ec832c41eef681036d776a88f7dc25ff8e59e26e8c2c36265909f992b0d36ab)
check_type(argname="argument argument", value=argument, expected_type=type_hints["argument"])
check_type(argname="argument binding_key", value=binding_key, expected_type=type_hints["binding_key"])
check_type(argname="argument binding_type", value=binding_type, expected_type=type_hints["binding_type"])
check_type(argname="argument destination_name", value=destination_name, expected_type=type_hints["destination_name"])
check_type(argname="argument instance_id", value=instance_id, expected_type=type_hints["instance_id"])
check_type(argname="argument source_exchange", value=source_exchange, expected_type=type_hints["source_exchange"])
check_type(argname="argument virtual_host", value=virtual_host, expected_type=type_hints["virtual_host"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"argument": argument,
"binding_key": binding_key,
"binding_type": binding_type,
"destination_name": destination_name,
"instance_id": instance_id,
"source_exchange": source_exchange,
"virtual_host": virtual_host,
}
@builtins.property
def argument(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property argument: X-match Attributes.
Valid Values:
"x-match:all": Default Value, All the Message Header of Key-Value Pairs Stored in the Must Match.
"x-match:any": at Least One Pair of the Message Header of Key-Value Pairs Stored in the Must Match.
'''
result = self._values.get("argument")
assert result is not None, "Required property 'argument' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def binding_key(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property bindingKey: The Binding Key.'''
result = self._values.get("binding_key")
assert result is not None, "Required property 'binding_key' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def binding_type(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property bindingType: The Target Binding Types.
Valid values: EXCHANGE, QUEUE.
'''
result = self._values.get("binding_type")
assert result is not None, "Required property 'binding_type' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def destination_name(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property destinationName: The Target Queue Or Exchange of the Name.'''
result = self._values.get("destination_name")
assert result is not None, "Required property 'destination_name' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def instance_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property instanceId: InstanceId.'''
result = self._values.get("instance_id")
assert result is not None, "Required property 'instance_id' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def source_exchange(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property sourceExchange: The Source Exchange Name.'''
result = self._values.get("source_exchange")
assert result is not None, "Required property 'source_exchange' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def virtual_host(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property virtualHost: The name of the virtual host.'''
result = self._values.get("virtual_host")
assert result is not None, "Required property 'virtual_host' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "BindingProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class Exchange(
_ros_cdk_core_7adfd82f.Resource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-amqp.Exchange",
):
'''A ROS resource type: ``ALIYUN::AMQP::Exchange``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["ExchangeProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
'''Create a new ``ALIYUN::AMQP::Exchange``.
Param scope - scope in which this resource is defined
Param id - scoped id of the resource
Param props - resource properties
:param scope: -
:param id: -
:param props: -
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__f8c6e87cf9126804e85d1ecfaa618cb1b498fe41673b7dd64c457d90433cc6dd)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@builtins.property
@jsii.member(jsii_name="attrExchangeName")
def attr_exchange_name(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute ExchangeName: The name of the exchange.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrExchangeName"))
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-amqp.ExchangeProps",
jsii_struct_bases=[],
name_mapping={
"auto_delete_state": "autoDeleteState",
"exchange_name": "exchangeName",
"exchange_type": "exchangeType",
"instance_id": "instanceId",
"internal": "internal",
"virtual_host": "virtualHost",
"alternate_exchange": "alternateExchange",
},
)
class ExchangeProps:
def __init__(
self,
*,
auto_delete_state: typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable],
exchange_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
exchange_type: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
instance_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
internal: typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable],
virtual_host: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
alternate_exchange: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::AMQP::Exchange``.
:param auto_delete_state: Property autoDeleteState: Specifies whether the Auto Delete attribute is configured. Valid values: true: The Auto Delete attribute is configured. If the last queue that is bound to an exchange is unbound, the exchange is automatically deleted. false: The Auto Delete attribute is not configured. If the last queue that is bound to an exchange is unbound, the exchange is not automatically deleted.
:param exchange_name: Property exchangeName: The name of the exchange.
:param exchange_type: Property exchangeType: The type of the exchange. Valid values: FANOUT: An exchange of this type routes all the received messages to all the queues bound to this exchange. You can use a fanout exchange to broadcast messages. DIRECT: An exchange of this type routes a message to the queue whose binding key is exactly the same as the routing key of the message. TOPIC: This type is similar to the direct exchange type. An exchange of this type routes a message to one or more queues based on the fuzzy match or multi-condition match result between the routing key of the message and the binding keys of the current exchange. HEADERS: Headers Exchange uses the Headers property instead of Routing Key for routing matching. When binding Headers Exchange and Queue, set the key-value pair of the binding property; when sending a message to the Headers Exchange, set the message's Headers property key-value pair and use the message Headers The message is routed to the bound Queue by comparing the attribute key-value pair and the bound attribute key-value pair.
:param instance_id: Property instanceId: InstanceId.
:param internal: Property internal: Specifies whether an exchange is an internal exchange. Valid values: false: The exchange is not an internal exchange. true: The exchange is an internal exchange.
:param virtual_host: Property virtualHost: The name of the virtual host.
:param alternate_exchange: Property alternateExchange: The alternate exchange. An alternate exchange is configured for an existing exchange. It is used to receive messages that fail to be routed to queues from the existing exchange.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__66b29f6f99deeea992894b8b19f481b61c01856e82c8638f15d1793fb5d0b5cb)
check_type(argname="argument auto_delete_state", value=auto_delete_state, expected_type=type_hints["auto_delete_state"])
check_type(argname="argument exchange_name", value=exchange_name, expected_type=type_hints["exchange_name"])
check_type(argname="argument exchange_type", value=exchange_type, expected_type=type_hints["exchange_type"])
check_type(argname="argument instance_id", value=instance_id, expected_type=type_hints["instance_id"])
check_type(argname="argument internal", value=internal, expected_type=type_hints["internal"])
check_type(argname="argument virtual_host", value=virtual_host, expected_type=type_hints["virtual_host"])
check_type(argname="argument alternate_exchange", value=alternate_exchange, expected_type=type_hints["alternate_exchange"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"auto_delete_state": auto_delete_state,
"exchange_name": exchange_name,
"exchange_type": exchange_type,
"instance_id": instance_id,
"internal": internal,
"virtual_host": virtual_host,
}
if alternate_exchange is not None:
self._values["alternate_exchange"] = alternate_exchange
@builtins.property
def auto_delete_state(
self,
) -> typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property autoDeleteState: Specifies whether the Auto Delete attribute is configured.
Valid values:
true: The Auto Delete attribute is configured. If the last queue that is bound to an exchange is unbound, the exchange is automatically deleted.
false: The Auto Delete attribute is not configured. If the last queue that is bound to an exchange is unbound, the exchange is not automatically deleted.
'''
result = self._values.get("auto_delete_state")
assert result is not None, "Required property 'auto_delete_state' is missing"
return typing.cast(typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def exchange_name(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property exchangeName: The name of the exchange.'''
result = self._values.get("exchange_name")
assert result is not None, "Required property 'exchange_name' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def exchange_type(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property exchangeType: The type of the exchange.
Valid values:
FANOUT: An exchange of this type routes all the received messages to all the queues bound to this exchange. You can use a fanout exchange to broadcast messages.
DIRECT: An exchange of this type routes a message to the queue whose binding key is exactly the same as the routing key of the message.
TOPIC: This type is similar to the direct exchange type. An exchange of this type routes a message to one or more queues based on the fuzzy match or multi-condition match result between the routing key of the message and the binding keys of the current exchange.
HEADERS: Headers Exchange uses the Headers property instead of Routing Key for routing matching. When binding Headers Exchange and Queue, set the key-value pair of the binding property; when sending a message to the Headers Exchange, set the message's Headers property key-value pair and use the message Headers The message is routed to the bound Queue by comparing the attribute key-value pair and the bound attribute key-value pair.
'''
result = self._values.get("exchange_type")
assert result is not None, "Required property 'exchange_type' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def instance_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property instanceId: InstanceId.'''
result = self._values.get("instance_id")
assert result is not None, "Required property 'instance_id' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def internal(
self,
) -> typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property internal: Specifies whether an exchange is an internal exchange.
Valid values:
false: The exchange is not an internal exchange.
true: The exchange is an internal exchange.
'''
result = self._values.get("internal")
assert result is not None, "Required property 'internal' is missing"
return typing.cast(typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def virtual_host(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property virtualHost: The name of the virtual host.'''
result = self._values.get("virtual_host")
assert result is not None, "Required property 'virtual_host' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def alternate_exchange(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property alternateExchange: The alternate exchange.
An alternate exchange is configured for an existing exchange. It is used to receive messages that fail to be routed to queues from the existing exchange.
'''
result = self._values.get("alternate_exchange")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "ExchangeProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class Instance(
_ros_cdk_core_7adfd82f.Resource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-amqp.Instance",
):
'''A ROS resource type: ``ALIYUN::AMQP::Instance``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["InstanceProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
'''Create a new ``ALIYUN::AMQP::Instance``.
Param scope - scope in which this resource is defined
Param id - scoped id of the resource
Param props - resource properties
:param scope: -
:param id: -
:param props: -
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__a32dc2c966a2a552cdf163bdce55a85ff7666fa905e7370ecc125ec13bf0aa87)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@builtins.property
@jsii.member(jsii_name="attrClassicEndpoint")
def attr_classic_endpoint(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute ClassicEndpoint: The classic endpoint of the instance.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrClassicEndpoint"))
@builtins.property
@jsii.member(jsii_name="attrInstanceId")
def attr_instance_id(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute InstanceId: The ID of the instance.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrInstanceId"))
@builtins.property
@jsii.member(jsii_name="attrPrivateEndpoint")
def attr_private_endpoint(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute PrivateEndpoint: The private endpoint of the instance.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrPrivateEndpoint"))
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-amqp.InstanceProps",
jsii_struct_bases=[],
name_mapping={
"instance_type": "instanceType",
"max_tps": "maxTps",
"queue_capacity": "queueCapacity",
"storage_size": "storageSize",
"instance_name": "instanceName",
"max_eip_tps": "maxEipTps",
"order_num": "orderNum",
"pay_type": "payType",
"period": "period",
"period_unit": "periodUnit",
"support_eip": "supportEip",
"support_tracing": "supportTracing",
"tracing_storage_time": "tracingStorageTime",
},
)
class InstanceProps:
def __init__(
self,
*,
instance_type: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
max_tps: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
queue_capacity: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
storage_size: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
instance_name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
max_eip_tps: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
order_num: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
pay_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
period: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
period_unit: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
support_eip: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
support_tracing: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
tracing_storage_time: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::AMQP::Instance``.
:param instance_type: Property instanceType: The Instance Type. Valid values: professional, enterprise, vip.
:param max_tps: Property maxTps: If instance type is professional, the valid value is [1000, 1500, 2000, 2500, 3000, 4000, 5000]. If instance type is enterprise, the valid value is [3000, 5000, 8000, 10000, 15000, 20000, 3000040000, 50000, 80000, 10000]. If instance type is vip, the valid value is [8000, 15000, 25000, 40000, 50000, 100000, 200000, 300000, 500000, 800000, 1000000].
:param queue_capacity: Property queueCapacity: The queue capacity. If instance type is professional, the valid value is [50, 1000] with the step size 5. If instance type is enterprise, the valid value is [200, 6000] with the step size 100 If instance type is vip, the valid value is [200, 80000] with the step size 100
:param storage_size: Property storageSize: The storage size. It is valid when instance_type is vip. If instance type is professional or enterprise, the valid value is 0.If instance type is vip, the valid value is [700, 2800] with the step size 100
:param instance_name: Property instanceName: The instance name.
:param max_eip_tps: Property maxEipTps: The max eip tps. It is valid when support_eip is true. The minimum value is 128, with the step size 128.
:param order_num: Property orderNum: Set the number of instances to be created.
:param pay_type: Property payType: The billing method of the instance. The Message Queue RabbitMQ version does not support new pay-as-you-go instances. Valid values: PrePaid: subscription
:param period: Property period: The period. Valid values: 1, 2, 3, 6, 12, 24, 36.
:param period_unit: Property periodUnit: The unit of the subscription duration. Valid values: Month Year Default value: Month.
:param support_eip: Property supportEip: Whether to support EIP. Valid values: true, false.
:param support_tracing: Property supportTracing: Whether to support tracing. Valid values: true, false.
:param tracing_storage_time: Property tracingStorageTime: The retention period of message traces was set. Valid values: 3, 7, 15. If instance_type=vip, the valid values is 15. If instance_type!=vip, the valid values is 3, 7, 15. If support_tracing == tracing_false, the valid values is 0.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__bfa0d0cf813d8350bb8c8ba9c9cdb1de65d694c183a32ea439e1e7e39cf5263c)
check_type(argname="argument instance_type", value=instance_type, expected_type=type_hints["instance_type"])
check_type(argname="argument max_tps", value=max_tps, expected_type=type_hints["max_tps"])
check_type(argname="argument queue_capacity", value=queue_capacity, expected_type=type_hints["queue_capacity"])
check_type(argname="argument storage_size", value=storage_size, expected_type=type_hints["storage_size"])
check_type(argname="argument instance_name", value=instance_name, expected_type=type_hints["instance_name"])
check_type(argname="argument max_eip_tps", value=max_eip_tps, expected_type=type_hints["max_eip_tps"])
check_type(argname="argument order_num", value=order_num, expected_type=type_hints["order_num"])
check_type(argname="argument pay_type", value=pay_type, expected_type=type_hints["pay_type"])
check_type(argname="argument period", value=period, expected_type=type_hints["period"])
check_type(argname="argument period_unit", value=period_unit, expected_type=type_hints["period_unit"])
check_type(argname="argument support_eip", value=support_eip, expected_type=type_hints["support_eip"])
check_type(argname="argument support_tracing", value=support_tracing, expected_type=type_hints["support_tracing"])
check_type(argname="argument tracing_storage_time", value=tracing_storage_time, expected_type=type_hints["tracing_storage_time"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"instance_type": instance_type,
"max_tps": max_tps,
"queue_capacity": queue_capacity,
"storage_size": storage_size,
}
if instance_name is not None:
self._values["instance_name"] = instance_name
if max_eip_tps is not None:
self._values["max_eip_tps"] = max_eip_tps
if order_num is not None:
self._values["order_num"] = order_num
if pay_type is not None:
self._values["pay_type"] = pay_type
if period is not None:
self._values["period"] = period
if period_unit is not None:
self._values["period_unit"] = period_unit
if support_eip is not None:
self._values["support_eip"] = support_eip
if support_tracing is not None:
self._values["support_tracing"] = support_tracing
if tracing_storage_time is not None:
self._values["tracing_storage_time"] = tracing_storage_time
@builtins.property
def instance_type(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property instanceType: The Instance Type.
Valid values: professional, enterprise, vip.
'''
result = self._values.get("instance_type")
assert result is not None, "Required property 'instance_type' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def max_tps(self) -> typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property maxTps: If instance type is professional, the valid value is [1000, 1500, 2000, 2500, 3000, 4000, 5000].
If instance type is enterprise, the valid value is [3000, 5000, 8000, 10000, 15000, 20000, 3000040000, 50000, 80000, 10000].
If instance type is vip, the valid value is [8000, 15000, 25000, 40000, 50000, 100000, 200000, 300000, 500000, 800000, 1000000].
'''
result = self._values.get("max_tps")
assert result is not None, "Required property 'max_tps' is missing"
return typing.cast(typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def queue_capacity(
self,
) -> typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property queueCapacity: The queue capacity.
If instance type is professional, the valid value is [50, 1000] with the step size 5.
If instance type is enterprise, the valid value is [200, 6000] with the step size 100
If instance type is vip, the valid value is [200, 80000] with the step size 100
'''
result = self._values.get("queue_capacity")
assert result is not None, "Required property 'queue_capacity' is missing"
return typing.cast(typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def storage_size(
self,
) -> typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property storageSize: The storage size.
It is valid when instance_type is vip.
If instance type is professional or enterprise, the valid value is 0.If instance type is vip, the valid value is [700, 2800] with the step size 100
'''
result = self._values.get("storage_size")
assert result is not None, "Required property 'storage_size' is missing"
return typing.cast(typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def instance_name(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property instanceName: The instance name.'''
result = self._values.get("instance_name")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def max_eip_tps(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property maxEipTps: The max eip tps.
It is valid when support_eip is true.
The minimum value is 128, with the step size 128.
'''
result = self._values.get("max_eip_tps")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def order_num(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property orderNum: Set the number of instances to be created.'''
result = self._values.get("order_num")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def pay_type(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property payType: The billing method of the instance.
The Message Queue RabbitMQ version does not support new pay-as-you-go instances. Valid values:
PrePaid: subscription
'''
result = self._values.get("pay_type")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def period(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property period: The period.
Valid values: 1, 2, 3, 6, 12, 24, 36.
'''
result = self._values.get("period")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def period_unit(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property periodUnit: The unit of the subscription duration.
Valid values:
Month
Year
Default value: Month.
'''
result = self._values.get("period_unit")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def support_eip(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property supportEip: Whether to support EIP.
Valid values: true, false.
'''
result = self._values.get("support_eip")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def support_tracing(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property supportTracing: Whether to support tracing.
Valid values: true, false.
'''
result = self._values.get("support_tracing")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def tracing_storage_time(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property tracingStorageTime: The retention period of message traces was set.
Valid values: 3, 7, 15.
If instance_type=vip, the valid values is 15.
If instance_type!=vip, the valid values is 3, 7, 15.
If support_tracing == tracing_false, the valid values is 0.
'''
result = self._values.get("tracing_storage_time")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "InstanceProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class Queue(
_ros_cdk_core_7adfd82f.Resource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-amqp.Queue",
):
'''A ROS resource type: ``ALIYUN::AMQP::Queue``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["QueueProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
'''Create a new ``ALIYUN::AMQP::Queue``.
Param scope - scope in which this resource is defined
Param id - scoped id of the resource
Param props - resource properties
:param scope: -
:param id: -
:param props: -
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__ae7cdfc0213132c213a6e1fb9057e398631f350d9405ffd584b7164eb8df15ac)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@builtins.property
@jsii.member(jsii_name="attrQueueName")
def attr_queue_name(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute QueueName: The name of the queue.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrQueueName"))
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-amqp.QueueProps",
jsii_struct_bases=[],
name_mapping={
"instance_id": "instanceId",
"queue_name": "queueName",
"virtual_host": "virtualHost",
"auto_delete_state": "autoDeleteState",
"auto_expire_state": "autoExpireState",
"dead_letter_exchange": "deadLetterExchange",
"dead_letter_routing_key": "deadLetterRoutingKey",
"exclusive_state": "exclusiveState",
"maximum_priority": "maximumPriority",
"max_length": "maxLength",
"message_ttl": "messageTtl",
},
)
class QueueProps:
def __init__(
self,
*,
instance_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
queue_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
virtual_host: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
auto_delete_state: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
auto_expire_state: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
dead_letter_exchange: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
dead_letter_routing_key: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
exclusive_state: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
maximum_priority: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
max_length: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
message_ttl: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::AMQP::Queue``.
:param instance_id: Property instanceId: InstanceId.
:param queue_name: Property queueName: The name of the queue.
:param virtual_host: Property virtualHost: The name of the virtual host.
:param auto_delete_state: Property autoDeleteState: Specifies whether the Auto Delete attribute is configured. Valid values: true: The Auto Delete attribute is configured. The queue is automatically deleted after the last subscription from consumers to this queue is canceled. false: The Auto Delete attribute is not configured.
:param auto_expire_state: Property autoExpireState: The validity period after which the queue is automatically deleted. If the queue is not accessed within a specified period of time, it is automatically deleted.
:param dead_letter_exchange: Property deadLetterExchange: The dead-letter exchange. A dead-letter exchange is used to receive rejected messages. If a consumer rejects a message that cannot be retried, this message is routed to a specified dead-letter exchange. Then, the dead-letter exchange routes the message to the queue that is bound to the dead-letter exchange.
:param dead_letter_routing_key: Property deadLetterRoutingKey: The dead letter routing key.
:param exclusive_state: Property exclusiveState: Specifies whether the queue is an exclusive queue. Valid values: true: The queue is an exclusive queue. It can be used only for the connection that declares the exclusive queue. After the connection is closed, the exclusive queue is automatically deleted. false: The Auto Delete attribute is not configured.
:param maximum_priority: Property maximumPriority: The priority function is not supported.
:param max_length: Property maxLength: The maximum number of messages that can be stored in the queue. If this threshold is exceeded, the earliest messages that are routed to the queue are discarded.
:param message_ttl: Property messageTtl: The message TTL of the queue If a message is retained in the Queue longer than the configured message lifetime, the message expires. The value of message lifetime must be a non-negative integer, up to 1 day. The unit is milliseconds
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__473e552812e7548c2c24ddb5c55032eea64ec9ea594f6b63bbb998132838df17)
check_type(argname="argument instance_id", value=instance_id, expected_type=type_hints["instance_id"])
check_type(argname="argument queue_name", value=queue_name, expected_type=type_hints["queue_name"])
check_type(argname="argument virtual_host", value=virtual_host, expected_type=type_hints["virtual_host"])
check_type(argname="argument auto_delete_state", value=auto_delete_state, expected_type=type_hints["auto_delete_state"])
check_type(argname="argument auto_expire_state", value=auto_expire_state, expected_type=type_hints["auto_expire_state"])
check_type(argname="argument dead_letter_exchange", value=dead_letter_exchange, expected_type=type_hints["dead_letter_exchange"])
check_type(argname="argument dead_letter_routing_key", value=dead_letter_routing_key, expected_type=type_hints["dead_letter_routing_key"])
check_type(argname="argument exclusive_state", value=exclusive_state, expected_type=type_hints["exclusive_state"])
check_type(argname="argument maximum_priority", value=maximum_priority, expected_type=type_hints["maximum_priority"])
check_type(argname="argument max_length", value=max_length, expected_type=type_hints["max_length"])
check_type(argname="argument message_ttl", value=message_ttl, expected_type=type_hints["message_ttl"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"instance_id": instance_id,
"queue_name": queue_name,
"virtual_host": virtual_host,
}
if auto_delete_state is not None:
self._values["auto_delete_state"] = auto_delete_state
if auto_expire_state is not None:
self._values["auto_expire_state"] = auto_expire_state
if dead_letter_exchange is not None:
self._values["dead_letter_exchange"] = dead_letter_exchange
if dead_letter_routing_key is not None:
self._values["dead_letter_routing_key"] = dead_letter_routing_key
if exclusive_state is not None:
self._values["exclusive_state"] = exclusive_state
if maximum_priority is not None:
self._values["maximum_priority"] = maximum_priority
if max_length is not None:
self._values["max_length"] = max_length
if message_ttl is not None:
self._values["message_ttl"] = message_ttl
@builtins.property
def instance_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property instanceId: InstanceId.'''
result = self._values.get("instance_id")
assert result is not None, "Required property 'instance_id' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def queue_name(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property queueName: The name of the queue.'''
result = self._values.get("queue_name")
assert result is not None, "Required property 'queue_name' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def virtual_host(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property virtualHost: The name of the virtual host.'''
result = self._values.get("virtual_host")
assert result is not None, "Required property 'virtual_host' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def auto_delete_state(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property autoDeleteState: Specifies whether the Auto Delete attribute is configured.
Valid values:
true: The Auto Delete attribute is configured. The queue is automatically deleted after the last subscription from consumers to this queue is canceled.
false: The Auto Delete attribute is not configured.
'''
result = self._values.get("auto_delete_state")
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def auto_expire_state(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property autoExpireState: The validity period after which the queue is automatically deleted.
If the queue is not accessed within a specified period of time, it is automatically deleted.
'''
result = self._values.get("auto_expire_state")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def dead_letter_exchange(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property deadLetterExchange: The dead-letter exchange.
A dead-letter exchange is used to receive rejected messages.
If a consumer rejects a message that cannot be retried, this message is routed to a specified dead-letter exchange.
Then, the dead-letter exchange routes the message to the queue that is bound to the dead-letter exchange.
'''
result = self._values.get("dead_letter_exchange")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def dead_letter_routing_key(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property deadLetterRoutingKey: The dead letter routing key.'''
result = self._values.get("dead_letter_routing_key")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def exclusive_state(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property exclusiveState: Specifies whether the queue is an exclusive queue.
Valid values:
true: The queue is an exclusive queue. It can be used only for the connection that declares the exclusive queue. After the connection is closed, the exclusive queue is automatically deleted.
false: The Auto Delete attribute is not configured.
'''
result = self._values.get("exclusive_state")
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def maximum_priority(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property maximumPriority: The priority function is not supported.'''
result = self._values.get("maximum_priority")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def max_length(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property maxLength: The maximum number of messages that can be stored in the queue.
If this threshold is exceeded, the earliest messages that are routed to the queue are discarded.
'''
result = self._values.get("max_length")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def message_ttl(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property messageTtl: The message TTL of the queue If a message is retained in the Queue longer than the configured message lifetime, the message expires.
The value of message lifetime must be a non-negative integer, up to 1 day.
The unit is milliseconds
'''
result = self._values.get("message_ttl")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "QueueProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class RosBinding(
_ros_cdk_core_7adfd82f.RosResource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-amqp.RosBinding",
):
'''A ROS template type: ``ALIYUN::AMQP::Binding``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["RosBindingProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
'''Create a new ``ALIYUN::AMQP::Binding``.
:param scope: - scope in which this resource is defined.
:param id: - scoped id of the resource.
:param props: - resource properties.
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__515c5b6329890a64fb11d4788b0d43ba2001d77fb9e91692bcb62338a8c27b2e)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@jsii.member(jsii_name="renderProperties")
def _render_properties(
self,
props: typing.Mapping[builtins.str, typing.Any],
) -> typing.Mapping[builtins.str, typing.Any]:
'''
:param props: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__fef49eea9d4f92b3baeccd94ecee0594508ce5d15832d144beb42b5736eddded)
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))
@jsii.python.classproperty
@jsii.member(jsii_name="ROS_RESOURCE_TYPE_NAME")
def ROS_RESOURCE_TYPE_NAME(cls) -> builtins.str:
'''The resource type name for this resource class.'''
return typing.cast(builtins.str, jsii.sget(cls, "ROS_RESOURCE_TYPE_NAME"))
@builtins.property
@jsii.member(jsii_name="rosProperties")
def _ros_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "rosProperties"))
@builtins.property
@jsii.member(jsii_name="argument")
def argument(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
argument: X-match Attributes. Valid Values:
"x-match:all": Default Value, All the Message Header of Key-Value Pairs Stored in the Must Match.
"x-match:any": at Least One Pair of the Message Header of Key-Value Pairs Stored in the Must Match.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "argument"))
@argument.setter
def argument(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__9586a9cdc077a7037874628147e28d6dd3356d3286406b1bc717ffa116e0a429)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "argument", value)
@builtins.property
@jsii.member(jsii_name="bindingKey")
def binding_key(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: bindingKey: The Binding Key.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "bindingKey"))
@binding_key.setter
def binding_key(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__f0e50b149819d2af2d391f360bcfc444d3a9b7b5b163fe6c8a9607367e092227)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "bindingKey", value)
@builtins.property
@jsii.member(jsii_name="bindingType")
def binding_type(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: bindingType: The Target Binding Types. Valid values: EXCHANGE, QUEUE.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "bindingType"))
@binding_type.setter
def binding_type(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__172222ffdbb780b3710a6acde31a02193abcfe543bb326310e2780f4175e0829)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "bindingType", value)
@builtins.property
@jsii.member(jsii_name="destinationName")
def destination_name(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: destinationName: The Target Queue Or Exchange of the Name.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "destinationName"))
@destination_name.setter
def destination_name(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__ff257a88b733625ebb317b10692b64b2596f3dc3bccb8ae3cb97534230843cd8)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "destinationName", value)
@builtins.property
@jsii.member(jsii_name="enableResourcePropertyConstraint")
def enable_resource_property_constraint(self) -> builtins.bool:
'''A factory method that creates a new instance of this class from an object containing the properties of this ROS resource.'''
return typing.cast(builtins.bool, jsii.get(self, "enableResourcePropertyConstraint"))
@enable_resource_property_constraint.setter
def enable_resource_property_constraint(self, value: builtins.bool) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__dd5ddad755a0ddacd7a1f8d9ea7653a2f20767a7508339231210c8b93dcc0999)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "enableResourcePropertyConstraint", value)
@builtins.property
@jsii.member(jsii_name="instanceId")
def instance_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: instanceId: InstanceId
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "instanceId"))
@instance_id.setter
def instance_id(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__c23700fd901d460cd630f7099998b5699146c5a437ea3b1cdba82b74aa211618)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "instanceId", value)
@builtins.property
@jsii.member(jsii_name="sourceExchange")
def source_exchange(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: sourceExchange: The Source Exchange Name.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "sourceExchange"))
@source_exchange.setter
def source_exchange(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__465c988968222ecf1713471206eb5a14ac16c57659daab29f8322468de9458ca)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "sourceExchange", value)
@builtins.property
@jsii.member(jsii_name="virtualHost")
def virtual_host(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: virtualHost: The name of the virtual host.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "virtualHost"))
@virtual_host.setter
def virtual_host(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__86452d7ab94c0e89a75b623690c04ae8247c925cba134d31eedfa3e5a73e5f12)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "virtualHost", value)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-amqp.RosBindingProps",
jsii_struct_bases=[],
name_mapping={
"argument": "argument",
"binding_key": "bindingKey",
"binding_type": "bindingType",
"destination_name": "destinationName",
"instance_id": "instanceId",
"source_exchange": "sourceExchange",
"virtual_host": "virtualHost",
},
)
class RosBindingProps:
def __init__(
self,
*,
argument: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
binding_key: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
binding_type: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
destination_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
instance_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
source_exchange: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
virtual_host: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
'''Properties for defining a ``ALIYUN::AMQP::Binding``.
:param argument:
:param binding_key:
:param binding_type:
:param destination_name:
:param instance_id:
:param source_exchange:
:param virtual_host:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__857cb08d8bfeb4526bd1ea7f809e9ad66355021cb13ce6b693292c5b1ff83414)
check_type(argname="argument argument", value=argument, expected_type=type_hints["argument"])
check_type(argname="argument binding_key", value=binding_key, expected_type=type_hints["binding_key"])
check_type(argname="argument binding_type", value=binding_type, expected_type=type_hints["binding_type"])
check_type(argname="argument destination_name", value=destination_name, expected_type=type_hints["destination_name"])
check_type(argname="argument instance_id", value=instance_id, expected_type=type_hints["instance_id"])
check_type(argname="argument source_exchange", value=source_exchange, expected_type=type_hints["source_exchange"])
check_type(argname="argument virtual_host", value=virtual_host, expected_type=type_hints["virtual_host"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"argument": argument,
"binding_key": binding_key,
"binding_type": binding_type,
"destination_name": destination_name,
"instance_id": instance_id,
"source_exchange": source_exchange,
"virtual_host": virtual_host,
}
@builtins.property
def argument(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
argument: X-match Attributes. Valid Values:
"x-match:all": Default Value, All the Message Header of Key-Value Pairs Stored in the Must Match.
"x-match:any": at Least One Pair of the Message Header of Key-Value Pairs Stored in the Must Match.
'''
result = self._values.get("argument")
assert result is not None, "Required property 'argument' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def binding_key(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: bindingKey: The Binding Key.
'''
result = self._values.get("binding_key")
assert result is not None, "Required property 'binding_key' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def binding_type(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: bindingType: The Target Binding Types. Valid values: EXCHANGE, QUEUE.
'''
result = self._values.get("binding_type")
assert result is not None, "Required property 'binding_type' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def destination_name(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: destinationName: The Target Queue Or Exchange of the Name.
'''
result = self._values.get("destination_name")
assert result is not None, "Required property 'destination_name' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def instance_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: instanceId: InstanceId
'''
result = self._values.get("instance_id")
assert result is not None, "Required property 'instance_id' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def source_exchange(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: sourceExchange: The Source Exchange Name.
'''
result = self._values.get("source_exchange")
assert result is not None, "Required property 'source_exchange' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def virtual_host(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: virtualHost: The name of the virtual host.
'''
result = self._values.get("virtual_host")
assert result is not None, "Required property 'virtual_host' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "RosBindingProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class RosExchange(
_ros_cdk_core_7adfd82f.RosResource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-amqp.RosExchange",
):
'''A ROS template type: ``ALIYUN::AMQP::Exchange``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["RosExchangeProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
'''Create a new ``ALIYUN::AMQP::Exchange``.
:param scope: - scope in which this resource is defined.
:param id: - scoped id of the resource.
:param props: - resource properties.
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__20e15c172754b83d46e6db382896643b2f28d7d8324134f24b3c13f6c621c929)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@jsii.member(jsii_name="renderProperties")
def _render_properties(
self,
props: typing.Mapping[builtins.str, typing.Any],
) -> typing.Mapping[builtins.str, typing.Any]:
'''
:param props: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__d1783351c01422d922d0d9df4304c04732a0f1377a160c22c270bff30ca5fd12)
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))
@jsii.python.classproperty
@jsii.member(jsii_name="ROS_RESOURCE_TYPE_NAME")
def ROS_RESOURCE_TYPE_NAME(cls) -> builtins.str:
'''The resource type name for this resource class.'''
return typing.cast(builtins.str, jsii.sget(cls, "ROS_RESOURCE_TYPE_NAME"))
@builtins.property
@jsii.member(jsii_name="attrExchangeName")
def attr_exchange_name(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: ExchangeName: The name of the exchange.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrExchangeName"))
@builtins.property
@jsii.member(jsii_name="rosProperties")
def _ros_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "rosProperties"))
@builtins.property
@jsii.member(jsii_name="autoDeleteState")
def auto_delete_state(
self,
) -> typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
autoDeleteState: Specifies whether the Auto Delete attribute is configured. Valid values:
true: The Auto Delete attribute is configured. If the last queue that is bound to an exchange is unbound, the exchange is automatically deleted.
false: The Auto Delete attribute is not configured. If the last queue that is bound to an exchange is unbound, the exchange is not automatically deleted.
'''
return typing.cast(typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "autoDeleteState"))
@auto_delete_state.setter
def auto_delete_state(
self,
value: typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__7f6edc27baf249c0af28827f1ba1922dfb68d04b2d3c9749b8ce3ee8589af23c)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "autoDeleteState", value)
@builtins.property
@jsii.member(jsii_name="enableResourcePropertyConstraint")
def enable_resource_property_constraint(self) -> builtins.bool:
return typing.cast(builtins.bool, jsii.get(self, "enableResourcePropertyConstraint"))
@enable_resource_property_constraint.setter
def enable_resource_property_constraint(self, value: builtins.bool) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__1b4b0f8779336c9d717cc4828bc208a803eaf14615274a0113884d737502e8e9)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "enableResourcePropertyConstraint", value)
@builtins.property
@jsii.member(jsii_name="exchangeName")
def exchange_name(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: exchangeName: The name of the exchange.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "exchangeName"))
@exchange_name.setter
def exchange_name(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__2396a63bc058b60b4ce6cd9434dda404375d2bb6ddd3d1c6459db2e66ffb5d44)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "exchangeName", value)
@builtins.property
@jsii.member(jsii_name="exchangeType")
def exchange_type(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
exchangeType: The type of the exchange. Valid values:
FANOUT: An exchange of this type routes all the received messages to all the queues bound to this exchange. You can use a fanout exchange to broadcast messages.
DIRECT: An exchange of this type routes a message to the queue whose binding key is exactly the same as the routing key of the message.
TOPIC: This type is similar to the direct exchange type. An exchange of this type routes a message to one or more queues based on the fuzzy match or multi-condition match result between the routing key of the message and the binding keys of the current exchange.
HEADERS: Headers Exchange uses the Headers property instead of Routing Key for routing matching. When binding Headers Exchange and Queue, set the key-value pair of the binding property; when sending a message to the Headers Exchange, set the message's Headers property key-value pair and use the message Headers The message is routed to the bound Queue by comparing the attribute key-value pair and the bound attribute key-value pair.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "exchangeType"))
@exchange_type.setter
def exchange_type(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__7fcad664791f566a8c708d7b3a5218d3bd8a9392c06abcb4153bb55fc76f09ce)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "exchangeType", value)
@builtins.property
@jsii.member(jsii_name="instanceId")
def instance_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: instanceId: InstanceId
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "instanceId"))
@instance_id.setter
def instance_id(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__68efe9b2f00c196cedd797834468e3b201d90da884d4557c8fbad4c857671eb4)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "instanceId", value)
@builtins.property
@jsii.member(jsii_name="internal")
def internal(
self,
) -> typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
internal: Specifies whether an exchange is an internal exchange. Valid values:
false: The exchange is not an internal exchange.
true: The exchange is an internal exchange.
'''
return typing.cast(typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "internal"))
@internal.setter
def internal(
self,
value: typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__c0f77a658bfd752d4eb7e46a97333ccb0d9e8b07a74657e92d519c607e3846a5)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "internal", value)
@builtins.property
@jsii.member(jsii_name="virtualHost")
def virtual_host(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: virtualHost: The name of the virtual host.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "virtualHost"))
@virtual_host.setter
def virtual_host(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__1f977d577a90a666f554f873bb46c2fbf54fa28e56d57c80469465fd7bfcfb2c)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "virtualHost", value)
@builtins.property
@jsii.member(jsii_name="alternateExchange")
def alternate_exchange(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: alternateExchange: The alternate exchange. An alternate exchange is configured for an existing exchange. It is used to receive messages that fail to be routed to queues from the existing exchange.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "alternateExchange"))
@alternate_exchange.setter
def alternate_exchange(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__eb4a4ba6ccae100174cec0a12aee54faf9223bf82c0f0f460e05da1dab0097a7)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "alternateExchange", value)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-amqp.RosExchangeProps",
jsii_struct_bases=[],
name_mapping={
"auto_delete_state": "autoDeleteState",
"exchange_name": "exchangeName",
"exchange_type": "exchangeType",
"instance_id": "instanceId",
"internal": "internal",
"virtual_host": "virtualHost",
"alternate_exchange": "alternateExchange",
},
)
class RosExchangeProps:
def __init__(
self,
*,
auto_delete_state: typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable],
exchange_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
exchange_type: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
instance_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
internal: typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable],
virtual_host: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
alternate_exchange: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::AMQP::Exchange``.
:param auto_delete_state:
:param exchange_name:
:param exchange_type:
:param instance_id:
:param internal:
:param virtual_host:
:param alternate_exchange:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__e600aaa137316039c38ea4e70ee37098da16bbfa856bf837cef59e7bf8470653)
check_type(argname="argument auto_delete_state", value=auto_delete_state, expected_type=type_hints["auto_delete_state"])
check_type(argname="argument exchange_name", value=exchange_name, expected_type=type_hints["exchange_name"])
check_type(argname="argument exchange_type", value=exchange_type, expected_type=type_hints["exchange_type"])
check_type(argname="argument instance_id", value=instance_id, expected_type=type_hints["instance_id"])
check_type(argname="argument internal", value=internal, expected_type=type_hints["internal"])
check_type(argname="argument virtual_host", value=virtual_host, expected_type=type_hints["virtual_host"])
check_type(argname="argument alternate_exchange", value=alternate_exchange, expected_type=type_hints["alternate_exchange"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"auto_delete_state": auto_delete_state,
"exchange_name": exchange_name,
"exchange_type": exchange_type,
"instance_id": instance_id,
"internal": internal,
"virtual_host": virtual_host,
}
if alternate_exchange is not None:
self._values["alternate_exchange"] = alternate_exchange
@builtins.property
def auto_delete_state(
self,
) -> typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
autoDeleteState: Specifies whether the Auto Delete attribute is configured. Valid values:
true: The Auto Delete attribute is configured. If the last queue that is bound to an exchange is unbound, the exchange is automatically deleted.
false: The Auto Delete attribute is not configured. If the last queue that is bound to an exchange is unbound, the exchange is not automatically deleted.
'''
result = self._values.get("auto_delete_state")
assert result is not None, "Required property 'auto_delete_state' is missing"
return typing.cast(typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def exchange_name(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: exchangeName: The name of the exchange.
'''
result = self._values.get("exchange_name")
assert result is not None, "Required property 'exchange_name' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def exchange_type(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
exchangeType: The type of the exchange. Valid values:
FANOUT: An exchange of this type routes all the received messages to all the queues bound to this exchange. You can use a fanout exchange to broadcast messages.
DIRECT: An exchange of this type routes a message to the queue whose binding key is exactly the same as the routing key of the message.
TOPIC: This type is similar to the direct exchange type. An exchange of this type routes a message to one or more queues based on the fuzzy match or multi-condition match result between the routing key of the message and the binding keys of the current exchange.
HEADERS: Headers Exchange uses the Headers property instead of Routing Key for routing matching. When binding Headers Exchange and Queue, set the key-value pair of the binding property; when sending a message to the Headers Exchange, set the message's Headers property key-value pair and use the message Headers The message is routed to the bound Queue by comparing the attribute key-value pair and the bound attribute key-value pair.
'''
result = self._values.get("exchange_type")
assert result is not None, "Required property 'exchange_type' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def instance_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: instanceId: InstanceId
'''
result = self._values.get("instance_id")
assert result is not None, "Required property 'instance_id' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def internal(
self,
) -> typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
internal: Specifies whether an exchange is an internal exchange. Valid values:
false: The exchange is not an internal exchange.
true: The exchange is an internal exchange.
'''
result = self._values.get("internal")
assert result is not None, "Required property 'internal' is missing"
return typing.cast(typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def virtual_host(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: virtualHost: The name of the virtual host.
'''
result = self._values.get("virtual_host")
assert result is not None, "Required property 'virtual_host' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def alternate_exchange(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: alternateExchange: The alternate exchange. An alternate exchange is configured for an existing exchange. It is used to receive messages that fail to be routed to queues from the existing exchange.
'''
result = self._values.get("alternate_exchange")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "RosExchangeProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class RosInstance(
_ros_cdk_core_7adfd82f.RosResource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-amqp.RosInstance",
):
'''A ROS template type: ``ALIYUN::AMQP::Instance``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["RosInstanceProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
'''Create a new ``ALIYUN::AMQP::Instance``.
:param scope: - scope in which this resource is defined.
:param id: - scoped id of the resource.
:param props: - resource properties.
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__59d13a86673b81488d47380fcd1fab8edb09621d7a95599156c28229028a841c)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@jsii.member(jsii_name="renderProperties")
def _render_properties(
self,
props: typing.Mapping[builtins.str, typing.Any],
) -> typing.Mapping[builtins.str, typing.Any]:
'''
:param props: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__e7945edad00144d1523fe8daec5fe5405b3a76b8cb3ec926ed8afdea07649586)
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))
@jsii.python.classproperty
@jsii.member(jsii_name="ROS_RESOURCE_TYPE_NAME")
def ROS_RESOURCE_TYPE_NAME(cls) -> builtins.str:
'''The resource type name for this resource class.'''
return typing.cast(builtins.str, jsii.sget(cls, "ROS_RESOURCE_TYPE_NAME"))
@builtins.property
@jsii.member(jsii_name="attrClassicEndpoint")
def attr_classic_endpoint(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: ClassicEndpoint: The classic endpoint of the instance.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrClassicEndpoint"))
@builtins.property
@jsii.member(jsii_name="attrInstanceId")
def attr_instance_id(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: InstanceId: The ID of the instance.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrInstanceId"))
@builtins.property
@jsii.member(jsii_name="attrPrivateEndpoint")
def attr_private_endpoint(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: PrivateEndpoint: The private endpoint of the instance.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrPrivateEndpoint"))
@builtins.property
@jsii.member(jsii_name="rosProperties")
def _ros_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "rosProperties"))
@builtins.property
@jsii.member(jsii_name="enableResourcePropertyConstraint")
def enable_resource_property_constraint(self) -> builtins.bool:
return typing.cast(builtins.bool, jsii.get(self, "enableResourcePropertyConstraint"))
@enable_resource_property_constraint.setter
def enable_resource_property_constraint(self, value: builtins.bool) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__56194be6e45a9ae9e82c382ff2c688215deae47ab32085931a81c7e71515d7c5)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "enableResourcePropertyConstraint", value)
@builtins.property
@jsii.member(jsii_name="instanceType")
def instance_type(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: instanceType: The Instance Type. Valid values: professional, enterprise, vip.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "instanceType"))
@instance_type.setter
def instance_type(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__0c7401755ce8e56c793434d45f952048693ccef6e52c10110906eb072c896ec9)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "instanceType", value)
@builtins.property
@jsii.member(jsii_name="maxTps")
def max_tps(self) -> typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
maxTps: If instance type is professional, the valid value is [1000, 1500, 2000, 2500, 3000, 4000, 5000].
If instance type is enterprise, the valid value is [3000, 5000, 8000, 10000, 15000, 20000, 3000040000, 50000, 80000, 10000].
If instance type is vip, the valid value is [8000, 15000, 25000, 40000, 50000, 100000, 200000, 300000, 500000, 800000, 1000000].
'''
return typing.cast(typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "maxTps"))
@max_tps.setter
def max_tps(
self,
value: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__34a479c1bdd31f845ec49743bc9b7154ac5c3b1257ad80ebb2a79610583f1f71)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "maxTps", value)
@builtins.property
@jsii.member(jsii_name="queueCapacity")
def queue_capacity(
self,
) -> typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
queueCapacity: The queue capacity. If instance type is professional, the valid value is [50, 1000] with the step size 5.
If instance type is enterprise, the valid value is [200, 6000] with the step size 100
If instance type is vip, the valid value is [200, 80000] with the step size 100
'''
return typing.cast(typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "queueCapacity"))
@queue_capacity.setter
def queue_capacity(
self,
value: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__e72f5e8c8f97fca312ad601c646dbf9ec20847447c06d8367a84e50088190622)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "queueCapacity", value)
@builtins.property
@jsii.member(jsii_name="storageSize")
def storage_size(
self,
) -> typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
storageSize: The storage size. It is valid when instance_type is vip.
If instance type is professional or enterprise, the valid value is 0.If instance type is vip, the valid value is [700, 2800] with the step size 100
'''
return typing.cast(typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "storageSize"))
@storage_size.setter
def storage_size(
self,
value: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__b9c5678fe3bb89e4f422338260ea6b64d0ef0f810b39c8ee944722021ea415c6)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "storageSize", value)
@builtins.property
@jsii.member(jsii_name="instanceName")
def instance_name(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: instanceName: The instance name.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "instanceName"))
@instance_name.setter
def instance_name(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__b2bf1affffd2fc99de631273cced45ddd64911750a6f35b25232c2526fd7aa26)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "instanceName", value)
@builtins.property
@jsii.member(jsii_name="maxEipTps")
def max_eip_tps(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
maxEipTps: The max eip tps. It is valid when support_eip is true.
The minimum value is 128, with the step size 128.
'''
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "maxEipTps"))
@max_eip_tps.setter
def max_eip_tps(
self,
value: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__d018f46762415090436c86a8cc404f4a3a7b6eeebb1861ef6da2696eda2ae8b7)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "maxEipTps", value)
@builtins.property
@jsii.member(jsii_name="orderNum")
def order_num(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: orderNum: Set the number of instances to be created.
'''
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "orderNum"))
@order_num.setter
def order_num(
self,
value: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__8aef7a837201f190227aeb669b16260175a77846e7546137b85581a3036c7622)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "orderNum", value)
@builtins.property
@jsii.member(jsii_name="payType")
def pay_type(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
payType: The billing method of the instance. The Message Queue RabbitMQ version does not support new pay-as-you-go instances. Valid values:
PrePaid: subscription
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "payType"))
@pay_type.setter
def pay_type(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__71da045386111a12bb6eede9693245073c94016df837f962130e55dd6e2903cf)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "payType", value)
@builtins.property
@jsii.member(jsii_name="period")
def period(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: period: The period. Valid values: 1, 2, 3, 6, 12, 24, 36.
'''
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "period"))
@period.setter
def period(
self,
value: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__fb817fef1daf4fade64abf22eaedd0321274b60e062dfeea5aec8501921f9b5a)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "period", value)
@builtins.property
@jsii.member(jsii_name="periodUnit")
def period_unit(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
periodUnit: The unit of the subscription duration. Valid values:
Month
Year
Default value: Month.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "periodUnit"))
@period_unit.setter
def period_unit(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__ca40cb78e928e925193cd2a9423a350270a9912b6df51f7ef291d75b3c0dcf1d)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "periodUnit", value)
@builtins.property
@jsii.member(jsii_name="supportEip")
def support_eip(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: supportEip: Whether to support EIP. Valid values: true, false.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "supportEip"))
@support_eip.setter
def support_eip(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__25fa3f677db9f265fcc51893fd3c99d8e1be2e28a54df34c56ca1ca3a51c675d)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "supportEip", value)
@builtins.property
@jsii.member(jsii_name="supportTracing")
def support_tracing(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: supportTracing: Whether to support tracing. Valid values: true, false.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "supportTracing"))
@support_tracing.setter
def support_tracing(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__82f98cd9e6844333ad5727dfb3685165b1141032f56cad7ea24e86982838872a)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "supportTracing", value)
@builtins.property
@jsii.member(jsii_name="tracingStorageTime")
def tracing_storage_time(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
tracingStorageTime: The retention period of message traces was set. Valid values: 3, 7, 15.
If instance_type=vip, the valid values is 15.
If instance_type!=vip, the valid values is 3, 7, 15.
If support_tracing == tracing_false, the valid values is 0.
'''
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "tracingStorageTime"))
@tracing_storage_time.setter
def tracing_storage_time(
self,
value: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__94f0e15c7d2d13f833b8dc5b3beb7e74696fc3fa5ef58e4dd4b3c69f83f3e7c4)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "tracingStorageTime", value)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-amqp.RosInstanceProps",
jsii_struct_bases=[],
name_mapping={
"instance_type": "instanceType",
"max_tps": "maxTps",
"queue_capacity": "queueCapacity",
"storage_size": "storageSize",
"instance_name": "instanceName",
"max_eip_tps": "maxEipTps",
"order_num": "orderNum",
"pay_type": "payType",
"period": "period",
"period_unit": "periodUnit",
"support_eip": "supportEip",
"support_tracing": "supportTracing",
"tracing_storage_time": "tracingStorageTime",
},
)
class RosInstanceProps:
def __init__(
self,
*,
instance_type: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
max_tps: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
queue_capacity: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
storage_size: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
instance_name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
max_eip_tps: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
order_num: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
pay_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
period: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
period_unit: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
support_eip: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
support_tracing: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
tracing_storage_time: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::AMQP::Instance``.
:param instance_type:
:param max_tps:
:param queue_capacity:
:param storage_size:
:param instance_name:
:param max_eip_tps:
:param order_num:
:param pay_type:
:param period:
:param period_unit:
:param support_eip:
:param support_tracing:
:param tracing_storage_time:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__40cf30f8d3a546ede6c2fcaaa08669ee185021db0e49209a7bcef741dff23e81)
check_type(argname="argument instance_type", value=instance_type, expected_type=type_hints["instance_type"])
check_type(argname="argument max_tps", value=max_tps, expected_type=type_hints["max_tps"])
check_type(argname="argument queue_capacity", value=queue_capacity, expected_type=type_hints["queue_capacity"])
check_type(argname="argument storage_size", value=storage_size, expected_type=type_hints["storage_size"])
check_type(argname="argument instance_name", value=instance_name, expected_type=type_hints["instance_name"])
check_type(argname="argument max_eip_tps", value=max_eip_tps, expected_type=type_hints["max_eip_tps"])
check_type(argname="argument order_num", value=order_num, expected_type=type_hints["order_num"])
check_type(argname="argument pay_type", value=pay_type, expected_type=type_hints["pay_type"])
check_type(argname="argument period", value=period, expected_type=type_hints["period"])
check_type(argname="argument period_unit", value=period_unit, expected_type=type_hints["period_unit"])
check_type(argname="argument support_eip", value=support_eip, expected_type=type_hints["support_eip"])
check_type(argname="argument support_tracing", value=support_tracing, expected_type=type_hints["support_tracing"])
check_type(argname="argument tracing_storage_time", value=tracing_storage_time, expected_type=type_hints["tracing_storage_time"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"instance_type": instance_type,
"max_tps": max_tps,
"queue_capacity": queue_capacity,
"storage_size": storage_size,
}
if instance_name is not None:
self._values["instance_name"] = instance_name
if max_eip_tps is not None:
self._values["max_eip_tps"] = max_eip_tps
if order_num is not None:
self._values["order_num"] = order_num
if pay_type is not None:
self._values["pay_type"] = pay_type
if period is not None:
self._values["period"] = period
if period_unit is not None:
self._values["period_unit"] = period_unit
if support_eip is not None:
self._values["support_eip"] = support_eip
if support_tracing is not None:
self._values["support_tracing"] = support_tracing
if tracing_storage_time is not None:
self._values["tracing_storage_time"] = tracing_storage_time
@builtins.property
def instance_type(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: instanceType: The Instance Type. Valid values: professional, enterprise, vip.
'''
result = self._values.get("instance_type")
assert result is not None, "Required property 'instance_type' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def max_tps(self) -> typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
maxTps: If instance type is professional, the valid value is [1000, 1500, 2000, 2500, 3000, 4000, 5000].
If instance type is enterprise, the valid value is [3000, 5000, 8000, 10000, 15000, 20000, 3000040000, 50000, 80000, 10000].
If instance type is vip, the valid value is [8000, 15000, 25000, 40000, 50000, 100000, 200000, 300000, 500000, 800000, 1000000].
'''
result = self._values.get("max_tps")
assert result is not None, "Required property 'max_tps' is missing"
return typing.cast(typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def queue_capacity(
self,
) -> typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
queueCapacity: The queue capacity. If instance type is professional, the valid value is [50, 1000] with the step size 5.
If instance type is enterprise, the valid value is [200, 6000] with the step size 100
If instance type is vip, the valid value is [200, 80000] with the step size 100
'''
result = self._values.get("queue_capacity")
assert result is not None, "Required property 'queue_capacity' is missing"
return typing.cast(typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def storage_size(
self,
) -> typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
storageSize: The storage size. It is valid when instance_type is vip.
If instance type is professional or enterprise, the valid value is 0.If instance type is vip, the valid value is [700, 2800] with the step size 100
'''
result = self._values.get("storage_size")
assert result is not None, "Required property 'storage_size' is missing"
return typing.cast(typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def instance_name(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: instanceName: The instance name.
'''
result = self._values.get("instance_name")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def max_eip_tps(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
maxEipTps: The max eip tps. It is valid when support_eip is true.
The minimum value is 128, with the step size 128.
'''
result = self._values.get("max_eip_tps")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def order_num(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: orderNum: Set the number of instances to be created.
'''
result = self._values.get("order_num")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def pay_type(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
payType: The billing method of the instance. The Message Queue RabbitMQ version does not support new pay-as-you-go instances. Valid values:
PrePaid: subscription
'''
result = self._values.get("pay_type")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def period(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: period: The period. Valid values: 1, 2, 3, 6, 12, 24, 36.
'''
result = self._values.get("period")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def period_unit(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
periodUnit: The unit of the subscription duration. Valid values:
Month
Year
Default value: Month.
'''
result = self._values.get("period_unit")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def support_eip(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: supportEip: Whether to support EIP. Valid values: true, false.
'''
result = self._values.get("support_eip")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def support_tracing(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: supportTracing: Whether to support tracing. Valid values: true, false.
'''
result = self._values.get("support_tracing")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def tracing_storage_time(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
tracingStorageTime: The retention period of message traces was set. Valid values: 3, 7, 15.
If instance_type=vip, the valid values is 15.
If instance_type!=vip, the valid values is 3, 7, 15.
If support_tracing == tracing_false, the valid values is 0.
'''
result = self._values.get("tracing_storage_time")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "RosInstanceProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class RosQueue(
_ros_cdk_core_7adfd82f.RosResource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-amqp.RosQueue",
):
'''A ROS template type: ``ALIYUN::AMQP::Queue``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["RosQueueProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
'''Create a new ``ALIYUN::AMQP::Queue``.
:param scope: - scope in which this resource is defined.
:param id: - scoped id of the resource.
:param props: - resource properties.
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__6a64fad0d5dcb9992f0ca1bdc5a9055d5533e357133e731d60a4960fca863b11)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@jsii.member(jsii_name="renderProperties")
def _render_properties(
self,
props: typing.Mapping[builtins.str, typing.Any],
) -> typing.Mapping[builtins.str, typing.Any]:
'''
:param props: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__bd735fa7d22736762c4cdefa4ee5c9b7cbce2255b94857d405a1213a5e83c798)
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))
@jsii.python.classproperty
@jsii.member(jsii_name="ROS_RESOURCE_TYPE_NAME")
def ROS_RESOURCE_TYPE_NAME(cls) -> builtins.str:
'''The resource type name for this resource class.'''
return typing.cast(builtins.str, jsii.sget(cls, "ROS_RESOURCE_TYPE_NAME"))
@builtins.property
@jsii.member(jsii_name="attrQueueName")
def attr_queue_name(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: QueueName: The name of the queue.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrQueueName"))
@builtins.property
@jsii.member(jsii_name="rosProperties")
def _ros_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "rosProperties"))
@builtins.property
@jsii.member(jsii_name="enableResourcePropertyConstraint")
def enable_resource_property_constraint(self) -> builtins.bool:
return typing.cast(builtins.bool, jsii.get(self, "enableResourcePropertyConstraint"))
@enable_resource_property_constraint.setter
def enable_resource_property_constraint(self, value: builtins.bool) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__2df32e0c8229b5c87d308d7cf0689134fbd749997f13e6ca434aad9854f92a6c)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "enableResourcePropertyConstraint", value)
@builtins.property
@jsii.member(jsii_name="instanceId")
def instance_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: instanceId: InstanceId
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "instanceId"))
@instance_id.setter
def instance_id(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__d11b56151c3b299dc025f86a6e9eced65dfe275d3307ed7d702868566b4d8fe8)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "instanceId", value)
@builtins.property
@jsii.member(jsii_name="queueName")
def queue_name(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: queueName: The name of the queue.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "queueName"))
@queue_name.setter
def queue_name(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__d239cf4493e7f768d1b348f7f53bac05cf71515c7a9cff431b72beb13b36eb16)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "queueName", value)
@builtins.property
@jsii.member(jsii_name="virtualHost")
def virtual_host(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: virtualHost: The name of the virtual host.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "virtualHost"))
@virtual_host.setter
def virtual_host(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__c2380205b4b87e1858f9b88781971e09d99125395a987a5b96b52aef4ebb87b0)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "virtualHost", value)
@builtins.property
@jsii.member(jsii_name="autoDeleteState")
def auto_delete_state(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
autoDeleteState: Specifies whether the Auto Delete attribute is configured. Valid values:
true: The Auto Delete attribute is configured. The queue is automatically deleted after the last subscription from consumers to this queue is canceled.
false: The Auto Delete attribute is not configured.
'''
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "autoDeleteState"))
@auto_delete_state.setter
def auto_delete_state(
self,
value: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__f6ae908c2bdd28599ba60810597f5202fe76f56f461d036c1f2a09577dcc3c68)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "autoDeleteState", value)
@builtins.property
@jsii.member(jsii_name="autoExpireState")
def auto_expire_state(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
autoExpireState: The validity period after which the queue is automatically deleted.
If the queue is not accessed within a specified period of time, it is automatically deleted.
'''
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "autoExpireState"))
@auto_expire_state.setter
def auto_expire_state(
self,
value: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__9e04172e6d0db58a74c5b9fd5861bbc7c8a34bb21dc7b1c153ce6d00d1092812)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "autoExpireState", value)
@builtins.property
@jsii.member(jsii_name="deadLetterExchange")
def dead_letter_exchange(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
deadLetterExchange: The dead-letter exchange. A dead-letter exchange is used to receive rejected messages.
If a consumer rejects a message that cannot be retried, this message is routed to a specified dead-letter exchange.
Then, the dead-letter exchange routes the message to the queue that is bound to the dead-letter exchange.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "deadLetterExchange"))
@dead_letter_exchange.setter
def dead_letter_exchange(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__66fa18b4c3417ff802ad6adbca859a9765fdbc9a38cc35f8726b947e842b1040)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "deadLetterExchange", value)
@builtins.property
@jsii.member(jsii_name="deadLetterRoutingKey")
def dead_letter_routing_key(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: deadLetterRoutingKey: The dead letter routing key.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "deadLetterRoutingKey"))
@dead_letter_routing_key.setter
def dead_letter_routing_key(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__4ed3f29dd5ee2b181d5ba3416e246fd6358d279c25b1de075b6b97c26ac9f4e0)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "deadLetterRoutingKey", value)
@builtins.property
@jsii.member(jsii_name="exclusiveState")
def exclusive_state(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
exclusiveState: Specifies whether the queue is an exclusive queue. Valid values:
true: The queue is an exclusive queue. It can be used only for the connection that declares the exclusive queue. After the connection is closed, the exclusive queue is automatically deleted.
false: The Auto Delete attribute is not configured.
'''
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "exclusiveState"))
@exclusive_state.setter
def exclusive_state(
self,
value: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__beec4d76a6655e2cb0890323950028ea9bda0984b57b873f93b1d1192bcbefaa)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "exclusiveState", value)
@builtins.property
@jsii.member(jsii_name="maximumPriority")
def maximum_priority(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: maximumPriority: The priority function is not supported.
'''
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "maximumPriority"))
@maximum_priority.setter
def maximum_priority(
self,
value: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__827489977470af48a099dcf6cff77f8154be0435e6724ed3038af64403af3a22)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "maximumPriority", value)
@builtins.property
@jsii.member(jsii_name="maxLength")
def max_length(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
maxLength: The maximum number of messages that can be stored in the queue.
If this threshold is exceeded, the earliest messages that are routed to the queue are discarded.
'''
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "maxLength"))
@max_length.setter
def max_length(
self,
value: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__a546eb1415e347792d0982998f3841f042de58e85d7e180164a0bb44c7889cf9)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "maxLength", value)
@builtins.property
@jsii.member(jsii_name="messageTtl")
def message_ttl(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
messageTtl: The message TTL of the queue
If a message is retained in the Queue longer than the configured message lifetime, the message expires.
The value of message lifetime must be a non-negative integer, up to 1 day.
The unit is milliseconds
'''
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "messageTtl"))
@message_ttl.setter
def message_ttl(
self,
value: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__81ed71a7724f3d196eb2b8fd3127a712b00663a8466b55a72b94f5c63887c277)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "messageTtl", value)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-amqp.RosQueueProps",
jsii_struct_bases=[],
name_mapping={
"instance_id": "instanceId",
"queue_name": "queueName",
"virtual_host": "virtualHost",
"auto_delete_state": "autoDeleteState",
"auto_expire_state": "autoExpireState",
"dead_letter_exchange": "deadLetterExchange",
"dead_letter_routing_key": "deadLetterRoutingKey",
"exclusive_state": "exclusiveState",
"maximum_priority": "maximumPriority",
"max_length": "maxLength",
"message_ttl": "messageTtl",
},
)
class RosQueueProps:
def __init__(
self,
*,
instance_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
queue_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
virtual_host: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
auto_delete_state: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
auto_expire_state: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
dead_letter_exchange: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
dead_letter_routing_key: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
exclusive_state: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
maximum_priority: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
max_length: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
message_ttl: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::AMQP::Queue``.
:param instance_id:
:param queue_name:
:param virtual_host:
:param auto_delete_state:
:param auto_expire_state:
:param dead_letter_exchange:
:param dead_letter_routing_key:
:param exclusive_state:
:param maximum_priority:
:param max_length:
:param message_ttl:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__3270f4c2f520cce986bf1f2855f65915ad576e606a720ea3c88d084ced4e49f5)
check_type(argname="argument instance_id", value=instance_id, expected_type=type_hints["instance_id"])
check_type(argname="argument queue_name", value=queue_name, expected_type=type_hints["queue_name"])
check_type(argname="argument virtual_host", value=virtual_host, expected_type=type_hints["virtual_host"])
check_type(argname="argument auto_delete_state", value=auto_delete_state, expected_type=type_hints["auto_delete_state"])
check_type(argname="argument auto_expire_state", value=auto_expire_state, expected_type=type_hints["auto_expire_state"])
check_type(argname="argument dead_letter_exchange", value=dead_letter_exchange, expected_type=type_hints["dead_letter_exchange"])
check_type(argname="argument dead_letter_routing_key", value=dead_letter_routing_key, expected_type=type_hints["dead_letter_routing_key"])
check_type(argname="argument exclusive_state", value=exclusive_state, expected_type=type_hints["exclusive_state"])
check_type(argname="argument maximum_priority", value=maximum_priority, expected_type=type_hints["maximum_priority"])
check_type(argname="argument max_length", value=max_length, expected_type=type_hints["max_length"])
check_type(argname="argument message_ttl", value=message_ttl, expected_type=type_hints["message_ttl"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"instance_id": instance_id,
"queue_name": queue_name,
"virtual_host": virtual_host,
}
if auto_delete_state is not None:
self._values["auto_delete_state"] = auto_delete_state
if auto_expire_state is not None:
self._values["auto_expire_state"] = auto_expire_state
if dead_letter_exchange is not None:
self._values["dead_letter_exchange"] = dead_letter_exchange
if dead_letter_routing_key is not None:
self._values["dead_letter_routing_key"] = dead_letter_routing_key
if exclusive_state is not None:
self._values["exclusive_state"] = exclusive_state
if maximum_priority is not None:
self._values["maximum_priority"] = maximum_priority
if max_length is not None:
self._values["max_length"] = max_length
if message_ttl is not None:
self._values["message_ttl"] = message_ttl
@builtins.property
def instance_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: instanceId: InstanceId
'''
result = self._values.get("instance_id")
assert result is not None, "Required property 'instance_id' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def queue_name(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: queueName: The name of the queue.
'''
result = self._values.get("queue_name")
assert result is not None, "Required property 'queue_name' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def virtual_host(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: virtualHost: The name of the virtual host.
'''
result = self._values.get("virtual_host")
assert result is not None, "Required property 'virtual_host' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def auto_delete_state(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
autoDeleteState: Specifies whether the Auto Delete attribute is configured. Valid values:
true: The Auto Delete attribute is configured. The queue is automatically deleted after the last subscription from consumers to this queue is canceled.
false: The Auto Delete attribute is not configured.
'''
result = self._values.get("auto_delete_state")
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def auto_expire_state(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
autoExpireState: The validity period after which the queue is automatically deleted.
If the queue is not accessed within a specified period of time, it is automatically deleted.
'''
result = self._values.get("auto_expire_state")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def dead_letter_exchange(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
deadLetterExchange: The dead-letter exchange. A dead-letter exchange is used to receive rejected messages.
If a consumer rejects a message that cannot be retried, this message is routed to a specified dead-letter exchange.
Then, the dead-letter exchange routes the message to the queue that is bound to the dead-letter exchange.
'''
result = self._values.get("dead_letter_exchange")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def dead_letter_routing_key(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: deadLetterRoutingKey: The dead letter routing key.
'''
result = self._values.get("dead_letter_routing_key")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def exclusive_state(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
exclusiveState: Specifies whether the queue is an exclusive queue. Valid values:
true: The queue is an exclusive queue. It can be used only for the connection that declares the exclusive queue. After the connection is closed, the exclusive queue is automatically deleted.
false: The Auto Delete attribute is not configured.
'''
result = self._values.get("exclusive_state")
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def maximum_priority(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: maximumPriority: The priority function is not supported.
'''
result = self._values.get("maximum_priority")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def max_length(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
maxLength: The maximum number of messages that can be stored in the queue.
If this threshold is exceeded, the earliest messages that are routed to the queue are discarded.
'''
result = self._values.get("max_length")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def message_ttl(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
messageTtl: The message TTL of the queue
If a message is retained in the Queue longer than the configured message lifetime, the message expires.
The value of message lifetime must be a non-negative integer, up to 1 day.
The unit is milliseconds
'''
result = self._values.get("message_ttl")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "RosQueueProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class RosVirtualHost(
_ros_cdk_core_7adfd82f.RosResource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-amqp.RosVirtualHost",
):
'''A ROS template type: ``ALIYUN::AMQP::VirtualHost``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["RosVirtualHostProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
'''Create a new ``ALIYUN::AMQP::VirtualHost``.
:param scope: - scope in which this resource is defined.
:param id: - scoped id of the resource.
:param props: - resource properties.
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__4ce76417b6966890d92e73e35cbc32181fc61d852e394bff74a3c2e0110568e9)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@jsii.member(jsii_name="renderProperties")
def _render_properties(
self,
props: typing.Mapping[builtins.str, typing.Any],
) -> typing.Mapping[builtins.str, typing.Any]:
'''
:param props: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__fbfafd12aee372823335d9255af68466b5a5f9fa6277a8148f864412b0988357)
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))
@jsii.python.classproperty
@jsii.member(jsii_name="ROS_RESOURCE_TYPE_NAME")
def ROS_RESOURCE_TYPE_NAME(cls) -> builtins.str:
'''The resource type name for this resource class.'''
return typing.cast(builtins.str, jsii.sget(cls, "ROS_RESOURCE_TYPE_NAME"))
@builtins.property
@jsii.member(jsii_name="attrVirtualHost")
def attr_virtual_host(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: VirtualHost: The name of the virtual host.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrVirtualHost"))
@builtins.property
@jsii.member(jsii_name="rosProperties")
def _ros_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "rosProperties"))
@builtins.property
@jsii.member(jsii_name="enableResourcePropertyConstraint")
def enable_resource_property_constraint(self) -> builtins.bool:
return typing.cast(builtins.bool, jsii.get(self, "enableResourcePropertyConstraint"))
@enable_resource_property_constraint.setter
def enable_resource_property_constraint(self, value: builtins.bool) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__7e394c127731aaeb76d81b14daebfee45f12784240a2592f588f491d0c419780)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "enableResourcePropertyConstraint", value)
@builtins.property
@jsii.member(jsii_name="instanceId")
def instance_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: instanceId: InstanceId
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "instanceId"))
@instance_id.setter
def instance_id(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__d681877fcbaee1cee00cbfefe5bda7f63f33be2e4557c01abc8be9647e59a6c5)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "instanceId", value)
@builtins.property
@jsii.member(jsii_name="virtualHost")
def virtual_host(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: virtualHost: The name of the virtual host.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "virtualHost"))
@virtual_host.setter
def virtual_host(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__a958ede83e909b3134628fde50791d33394b1942a93311ce74d1d673fe211f54)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "virtualHost", value)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-amqp.RosVirtualHostProps",
jsii_struct_bases=[],
name_mapping={"instance_id": "instanceId", "virtual_host": "virtualHost"},
)
class RosVirtualHostProps:
def __init__(
self,
*,
instance_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
virtual_host: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
'''Properties for defining a ``ALIYUN::AMQP::VirtualHost``.
:param instance_id:
:param virtual_host:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__6ce0e00abe0c0314a7d0dd3d3f32cc1300b03add30daba1a7e6a3ec855d17288)
check_type(argname="argument instance_id", value=instance_id, expected_type=type_hints["instance_id"])
check_type(argname="argument virtual_host", value=virtual_host, expected_type=type_hints["virtual_host"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"instance_id": instance_id,
"virtual_host": virtual_host,
}
@builtins.property
def instance_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: instanceId: InstanceId
'''
result = self._values.get("instance_id")
assert result is not None, "Required property 'instance_id' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def virtual_host(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: virtualHost: The name of the virtual host.
'''
result = self._values.get("virtual_host")
assert result is not None, "Required property 'virtual_host' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "RosVirtualHostProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class VirtualHost(
_ros_cdk_core_7adfd82f.Resource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-amqp.VirtualHost",
):
'''A ROS resource type: ``ALIYUN::AMQP::VirtualHost``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["VirtualHostProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
'''Create a new ``ALIYUN::AMQP::VirtualHost``.
Param scope - scope in which this resource is defined
Param id - scoped id of the resource
Param props - resource properties
:param scope: -
:param id: -
:param props: -
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__845049ec643884c9d780ffea18df1424b85642a4d6d59ee856d8c1cdc98000dc)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@builtins.property
@jsii.member(jsii_name="attrVirtualHost")
def attr_virtual_host(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute VirtualHost: The name of the virtual host.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrVirtualHost"))
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-amqp.VirtualHostProps",
jsii_struct_bases=[],
name_mapping={"instance_id": "instanceId", "virtual_host": "virtualHost"},
)
class VirtualHostProps:
def __init__(
self,
*,
instance_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
virtual_host: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
'''Properties for defining a ``ALIYUN::AMQP::VirtualHost``.
:param instance_id: Property instanceId: InstanceId.
:param virtual_host: Property virtualHost: The name of the virtual host.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__38d2e68d9fe7589d24f70a039243e955029118303e5930f13a6a94f4373c08f4)
check_type(argname="argument instance_id", value=instance_id, expected_type=type_hints["instance_id"])
check_type(argname="argument virtual_host", value=virtual_host, expected_type=type_hints["virtual_host"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"instance_id": instance_id,
"virtual_host": virtual_host,
}
@builtins.property
def instance_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property instanceId: InstanceId.'''
result = self._values.get("instance_id")
assert result is not None, "Required property 'instance_id' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def virtual_host(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property virtualHost: The name of the virtual host.'''
result = self._values.get("virtual_host")
assert result is not None, "Required property 'virtual_host' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "VirtualHostProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
__all__ = [
"Binding",
"BindingProps",
"Exchange",
"ExchangeProps",
"Instance",
"InstanceProps",
"Queue",
"QueueProps",
"RosBinding",
"RosBindingProps",
"RosExchange",
"RosExchangeProps",
"RosInstance",
"RosInstanceProps",
"RosQueue",
"RosQueueProps",
"RosVirtualHost",
"RosVirtualHostProps",
"VirtualHost",
"VirtualHostProps",
]
publication.publish()
def _typecheckingstub__1f96cf7feb719b7dcc39c3887d52562dc4b869b04056e71ea317c8eaca2aaf16(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[BindingProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__4ec832c41eef681036d776a88f7dc25ff8e59e26e8c2c36265909f992b0d36ab(
*,
argument: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
binding_key: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
binding_type: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
destination_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
instance_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
source_exchange: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
virtual_host: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__f8c6e87cf9126804e85d1ecfaa618cb1b498fe41673b7dd64c457d90433cc6dd(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[ExchangeProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__66b29f6f99deeea992894b8b19f481b61c01856e82c8638f15d1793fb5d0b5cb(
*,
auto_delete_state: typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable],
exchange_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
exchange_type: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
instance_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
internal: typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable],
virtual_host: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
alternate_exchange: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__a32dc2c966a2a552cdf163bdce55a85ff7666fa905e7370ecc125ec13bf0aa87(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[InstanceProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__bfa0d0cf813d8350bb8c8ba9c9cdb1de65d694c183a32ea439e1e7e39cf5263c(
*,
instance_type: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
max_tps: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
queue_capacity: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
storage_size: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
instance_name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
max_eip_tps: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
order_num: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
pay_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
period: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
period_unit: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
support_eip: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
support_tracing: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
tracing_storage_time: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__ae7cdfc0213132c213a6e1fb9057e398631f350d9405ffd584b7164eb8df15ac(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[QueueProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__473e552812e7548c2c24ddb5c55032eea64ec9ea594f6b63bbb998132838df17(
*,
instance_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
queue_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
virtual_host: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
auto_delete_state: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
auto_expire_state: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
dead_letter_exchange: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
dead_letter_routing_key: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
exclusive_state: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
maximum_priority: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
max_length: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
message_ttl: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__515c5b6329890a64fb11d4788b0d43ba2001d77fb9e91692bcb62338a8c27b2e(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[RosBindingProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__fef49eea9d4f92b3baeccd94ecee0594508ce5d15832d144beb42b5736eddded(
props: typing.Mapping[builtins.str, typing.Any],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__9586a9cdc077a7037874628147e28d6dd3356d3286406b1bc717ffa116e0a429(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__f0e50b149819d2af2d391f360bcfc444d3a9b7b5b163fe6c8a9607367e092227(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__172222ffdbb780b3710a6acde31a02193abcfe543bb326310e2780f4175e0829(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__ff257a88b733625ebb317b10692b64b2596f3dc3bccb8ae3cb97534230843cd8(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__dd5ddad755a0ddacd7a1f8d9ea7653a2f20767a7508339231210c8b93dcc0999(
value: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__c23700fd901d460cd630f7099998b5699146c5a437ea3b1cdba82b74aa211618(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__465c988968222ecf1713471206eb5a14ac16c57659daab29f8322468de9458ca(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__86452d7ab94c0e89a75b623690c04ae8247c925cba134d31eedfa3e5a73e5f12(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__857cb08d8bfeb4526bd1ea7f809e9ad66355021cb13ce6b693292c5b1ff83414(
*,
argument: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
binding_key: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
binding_type: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
destination_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
instance_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
source_exchange: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
virtual_host: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__20e15c172754b83d46e6db382896643b2f28d7d8324134f24b3c13f6c621c929(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[RosExchangeProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__d1783351c01422d922d0d9df4304c04732a0f1377a160c22c270bff30ca5fd12(
props: typing.Mapping[builtins.str, typing.Any],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__7f6edc27baf249c0af28827f1ba1922dfb68d04b2d3c9749b8ce3ee8589af23c(
value: typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__1b4b0f8779336c9d717cc4828bc208a803eaf14615274a0113884d737502e8e9(
value: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__2396a63bc058b60b4ce6cd9434dda404375d2bb6ddd3d1c6459db2e66ffb5d44(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__7fcad664791f566a8c708d7b3a5218d3bd8a9392c06abcb4153bb55fc76f09ce(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__68efe9b2f00c196cedd797834468e3b201d90da884d4557c8fbad4c857671eb4(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__c0f77a658bfd752d4eb7e46a97333ccb0d9e8b07a74657e92d519c607e3846a5(
value: typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__1f977d577a90a666f554f873bb46c2fbf54fa28e56d57c80469465fd7bfcfb2c(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__eb4a4ba6ccae100174cec0a12aee54faf9223bf82c0f0f460e05da1dab0097a7(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__e600aaa137316039c38ea4e70ee37098da16bbfa856bf837cef59e7bf8470653(
*,
auto_delete_state: typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable],
exchange_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
exchange_type: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
instance_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
internal: typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable],
virtual_host: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
alternate_exchange: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__59d13a86673b81488d47380fcd1fab8edb09621d7a95599156c28229028a841c(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[RosInstanceProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__e7945edad00144d1523fe8daec5fe5405b3a76b8cb3ec926ed8afdea07649586(
props: typing.Mapping[builtins.str, typing.Any],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__56194be6e45a9ae9e82c382ff2c688215deae47ab32085931a81c7e71515d7c5(
value: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__0c7401755ce8e56c793434d45f952048693ccef6e52c10110906eb072c896ec9(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__34a479c1bdd31f845ec49743bc9b7154ac5c3b1257ad80ebb2a79610583f1f71(
value: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__e72f5e8c8f97fca312ad601c646dbf9ec20847447c06d8367a84e50088190622(
value: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__b9c5678fe3bb89e4f422338260ea6b64d0ef0f810b39c8ee944722021ea415c6(
value: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__b2bf1affffd2fc99de631273cced45ddd64911750a6f35b25232c2526fd7aa26(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__d018f46762415090436c86a8cc404f4a3a7b6eeebb1861ef6da2696eda2ae8b7(
value: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__8aef7a837201f190227aeb669b16260175a77846e7546137b85581a3036c7622(
value: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__71da045386111a12bb6eede9693245073c94016df837f962130e55dd6e2903cf(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__fb817fef1daf4fade64abf22eaedd0321274b60e062dfeea5aec8501921f9b5a(
value: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__ca40cb78e928e925193cd2a9423a350270a9912b6df51f7ef291d75b3c0dcf1d(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__25fa3f677db9f265fcc51893fd3c99d8e1be2e28a54df34c56ca1ca3a51c675d(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__82f98cd9e6844333ad5727dfb3685165b1141032f56cad7ea24e86982838872a(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__94f0e15c7d2d13f833b8dc5b3beb7e74696fc3fa5ef58e4dd4b3c69f83f3e7c4(
value: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__40cf30f8d3a546ede6c2fcaaa08669ee185021db0e49209a7bcef741dff23e81(
*,
instance_type: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
max_tps: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
queue_capacity: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
storage_size: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
instance_name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
max_eip_tps: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
order_num: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
pay_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
period: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
period_unit: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
support_eip: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
support_tracing: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
tracing_storage_time: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__6a64fad0d5dcb9992f0ca1bdc5a9055d5533e357133e731d60a4960fca863b11(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[RosQueueProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__bd735fa7d22736762c4cdefa4ee5c9b7cbce2255b94857d405a1213a5e83c798(
props: typing.Mapping[builtins.str, typing.Any],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__2df32e0c8229b5c87d308d7cf0689134fbd749997f13e6ca434aad9854f92a6c(
value: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__d11b56151c3b299dc025f86a6e9eced65dfe275d3307ed7d702868566b4d8fe8(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__d239cf4493e7f768d1b348f7f53bac05cf71515c7a9cff431b72beb13b36eb16(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__c2380205b4b87e1858f9b88781971e09d99125395a987a5b96b52aef4ebb87b0(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__f6ae908c2bdd28599ba60810597f5202fe76f56f461d036c1f2a09577dcc3c68(
value: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__9e04172e6d0db58a74c5b9fd5861bbc7c8a34bb21dc7b1c153ce6d00d1092812(
value: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__66fa18b4c3417ff802ad6adbca859a9765fdbc9a38cc35f8726b947e842b1040(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__4ed3f29dd5ee2b181d5ba3416e246fd6358d279c25b1de075b6b97c26ac9f4e0(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__beec4d76a6655e2cb0890323950028ea9bda0984b57b873f93b1d1192bcbefaa(
value: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__827489977470af48a099dcf6cff77f8154be0435e6724ed3038af64403af3a22(
value: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__a546eb1415e347792d0982998f3841f042de58e85d7e180164a0bb44c7889cf9(
value: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__81ed71a7724f3d196eb2b8fd3127a712b00663a8466b55a72b94f5c63887c277(
value: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__3270f4c2f520cce986bf1f2855f65915ad576e606a720ea3c88d084ced4e49f5(
*,
instance_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
queue_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
virtual_host: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
auto_delete_state: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
auto_expire_state: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
dead_letter_exchange: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
dead_letter_routing_key: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
exclusive_state: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
maximum_priority: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
max_length: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
message_ttl: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__4ce76417b6966890d92e73e35cbc32181fc61d852e394bff74a3c2e0110568e9(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[RosVirtualHostProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__fbfafd12aee372823335d9255af68466b5a5f9fa6277a8148f864412b0988357(
props: typing.Mapping[builtins.str, typing.Any],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__7e394c127731aaeb76d81b14daebfee45f12784240a2592f588f491d0c419780(
value: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__d681877fcbaee1cee00cbfefe5bda7f63f33be2e4557c01abc8be9647e59a6c5(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__a958ede83e909b3134628fde50791d33394b1942a93311ce74d1d673fe211f54(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__6ce0e00abe0c0314a7d0dd3d3f32cc1300b03add30daba1a7e6a3ec855d17288(
*,
instance_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
virtual_host: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__845049ec643884c9d780ffea18df1424b85642a4d6d59ee856d8c1cdc98000dc(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[VirtualHostProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__38d2e68d9fe7589d24f70a039243e955029118303e5930f13a6a94f4373c08f4(
*,
instance_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
virtual_host: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass | /ros-cdk-amqp-1.0.17.tar.gz/ros-cdk-amqp-1.0.17/src/ros_cdk_amqp/__init__.py | 0.692226 | 0.181971 | __init__.py | pypi |
import abc
import builtins
import datetime
import enum
import typing
import jsii
import publication
import typing_extensions
from typeguard import check_type
from .._jsii import *
import ros_cdk_core as _ros_cdk_core_7adfd82f
class Apis(
_ros_cdk_core_7adfd82f.Resource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-apigateway.datasource.Apis",
):
'''A ROS resource type: ``DATASOURCE::ApiGateway::Apis``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Optional[typing.Union["ApisProps", typing.Dict[builtins.str, typing.Any]]] = None,
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
'''Create a new ``DATASOURCE::ApiGateway::Apis``.
Param scope - scope in which this resource is defined
Param id - scoped id of the resource
Param props - resource properties
:param scope: -
:param id: -
:param props: -
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__75f7c6d2d7f1baa67ef1bf057aeb20d862e0dbe559e5eac248898466f17dcd3d)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@builtins.property
@jsii.member(jsii_name="attrApiIds")
def attr_api_ids(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute ApiIds: The list of The ApiGateway api ids.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrApiIds"))
@builtins.property
@jsii.member(jsii_name="attrApis")
def attr_apis(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute Apis: The information about ApiGateway apis.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrApis"))
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-apigateway.datasource.ApisProps",
jsii_struct_bases=[],
name_mapping={
"api_id": "apiId",
"api_name": "apiName",
"catalog_id": "catalogId",
"enable_tag_auth": "enableTagAuth",
"group_id": "groupId",
"visibility": "visibility",
},
)
class ApisProps:
def __init__(
self,
*,
api_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
api_name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
catalog_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
enable_tag_auth: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
group_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
visibility: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``DATASOURCE::ApiGateway::Apis``.
:param api_id: Property apiId: ID of the specified API.
:param api_name: Property apiName: API name (fuzzy matching).
:param catalog_id: Property catalogId: Catalog number.
:param enable_tag_auth: Property enableTagAuth: Enable label validation.
:param group_id: Property groupId: ID of the specified group.
:param visibility: Property visibility: Whether the API is public.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__54b0bf96cbf53062dc1eb1d9eb3438334e7258d8cf94b7407e50e6392d9c0667)
check_type(argname="argument api_id", value=api_id, expected_type=type_hints["api_id"])
check_type(argname="argument api_name", value=api_name, expected_type=type_hints["api_name"])
check_type(argname="argument catalog_id", value=catalog_id, expected_type=type_hints["catalog_id"])
check_type(argname="argument enable_tag_auth", value=enable_tag_auth, expected_type=type_hints["enable_tag_auth"])
check_type(argname="argument group_id", value=group_id, expected_type=type_hints["group_id"])
check_type(argname="argument visibility", value=visibility, expected_type=type_hints["visibility"])
self._values: typing.Dict[builtins.str, typing.Any] = {}
if api_id is not None:
self._values["api_id"] = api_id
if api_name is not None:
self._values["api_name"] = api_name
if catalog_id is not None:
self._values["catalog_id"] = catalog_id
if enable_tag_auth is not None:
self._values["enable_tag_auth"] = enable_tag_auth
if group_id is not None:
self._values["group_id"] = group_id
if visibility is not None:
self._values["visibility"] = visibility
@builtins.property
def api_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property apiId: ID of the specified API.'''
result = self._values.get("api_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def api_name(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property apiName: API name (fuzzy matching).'''
result = self._values.get("api_name")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def catalog_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property catalogId: Catalog number.'''
result = self._values.get("catalog_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def enable_tag_auth(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property enableTagAuth: Enable label validation.'''
result = self._values.get("enable_tag_auth")
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def group_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property groupId: ID of the specified group.'''
result = self._values.get("group_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def visibility(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property visibility: Whether the API is public.'''
result = self._values.get("visibility")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "ApisProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class Apps(
_ros_cdk_core_7adfd82f.Resource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-apigateway.datasource.Apps",
):
'''A ROS resource type: ``DATASOURCE::ApiGateway::Apps``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Optional[typing.Union["AppsProps", typing.Dict[builtins.str, typing.Any]]] = None,
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
'''Create a new ``DATASOURCE::ApiGateway::Apps``.
Param scope - scope in which this resource is defined
Param id - scoped id of the resource
Param props - resource properties
:param scope: -
:param id: -
:param props: -
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__d4dfb74b8bee8189bd10f5ce6356133cd98de6bd337fd3fb3ba7d78c627d3659)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@builtins.property
@jsii.member(jsii_name="attrAppIds")
def attr_app_ids(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute AppIds: The list of The ApiGateway app ids.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrAppIds"))
@builtins.property
@jsii.member(jsii_name="attrApps")
def attr_apps(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute Apps: The information about ApiGateway apps.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrApps"))
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-apigateway.datasource.AppsProps",
jsii_struct_bases=[],
name_mapping={"app_id": "appId", "app_owner": "appOwner"},
)
class AppsProps:
def __init__(
self,
*,
app_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
app_owner: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``DATASOURCE::ApiGateway::Apps``.
:param app_id: Property appId: Unique ID of the app.
:param app_owner: Property appOwner: Alibaba Cloud account ID of the app owner.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__3943db5d718722304df85f606c71c4b482007f8511a913c134c6e977190c27ac)
check_type(argname="argument app_id", value=app_id, expected_type=type_hints["app_id"])
check_type(argname="argument app_owner", value=app_owner, expected_type=type_hints["app_owner"])
self._values: typing.Dict[builtins.str, typing.Any] = {}
if app_id is not None:
self._values["app_id"] = app_id
if app_owner is not None:
self._values["app_owner"] = app_owner
@builtins.property
def app_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property appId: Unique ID of the app.'''
result = self._values.get("app_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def app_owner(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property appOwner: Alibaba Cloud account ID of the app owner.'''
result = self._values.get("app_owner")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "AppsProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class Groups(
_ros_cdk_core_7adfd82f.Resource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-apigateway.datasource.Groups",
):
'''A ROS resource type: ``DATASOURCE::ApiGateway::Groups``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Optional[typing.Union["GroupsProps", typing.Dict[builtins.str, typing.Any]]] = None,
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
'''Create a new ``DATASOURCE::ApiGateway::Groups``.
Param scope - scope in which this resource is defined
Param id - scoped id of the resource
Param props - resource properties
:param scope: -
:param id: -
:param props: -
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__39c3b2a6c406e3cb486800c3bbcefc80f6a3dbd33c4d873ef5e16a9ebedc0f33)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@builtins.property
@jsii.member(jsii_name="attrApiGroupIds")
def attr_api_group_ids(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute ApiGroupIds: The list of The ApiGateway group ids.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrApiGroupIds"))
@builtins.property
@jsii.member(jsii_name="attrApiGroups")
def attr_api_groups(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute ApiGroups: The information about ApiGateway groups.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrApiGroups"))
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-apigateway.datasource.GroupsProps",
jsii_struct_bases=[],
name_mapping={
"group_id": "groupId",
"group_name": "groupName",
"instance_id": "instanceId",
"sort": "sort",
},
)
class GroupsProps:
def __init__(
self,
*,
group_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
group_name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
instance_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
sort: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``DATASOURCE::ApiGateway::Groups``.
:param group_id: Property groupId: API group ID.
:param group_name: Property groupName: Specified keyword of the API group name.
:param instance_id: Property instanceId: API Gateway Instance ID.
:param sort: Property sort: Sort.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__1a4c18455871acd6c8b3563592670fcef377052e29e2be8a43e8bfe5e365fda9)
check_type(argname="argument group_id", value=group_id, expected_type=type_hints["group_id"])
check_type(argname="argument group_name", value=group_name, expected_type=type_hints["group_name"])
check_type(argname="argument instance_id", value=instance_id, expected_type=type_hints["instance_id"])
check_type(argname="argument sort", value=sort, expected_type=type_hints["sort"])
self._values: typing.Dict[builtins.str, typing.Any] = {}
if group_id is not None:
self._values["group_id"] = group_id
if group_name is not None:
self._values["group_name"] = group_name
if instance_id is not None:
self._values["instance_id"] = instance_id
if sort is not None:
self._values["sort"] = sort
@builtins.property
def group_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property groupId: API group ID.'''
result = self._values.get("group_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def group_name(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property groupName: Specified keyword of the API group name.'''
result = self._values.get("group_name")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def instance_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property instanceId: API Gateway Instance ID.'''
result = self._values.get("instance_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def sort(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property sort: Sort.'''
result = self._values.get("sort")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "GroupsProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class Instances(
_ros_cdk_core_7adfd82f.Resource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-apigateway.datasource.Instances",
):
'''A ROS resource type: ``DATASOURCE::ApiGateway::Instances``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Optional[typing.Union["InstancesProps", typing.Dict[builtins.str, typing.Any]]] = None,
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
'''Create a new ``DATASOURCE::ApiGateway::Instances``.
Param scope - scope in which this resource is defined
Param id - scoped id of the resource
Param props - resource properties
:param scope: -
:param id: -
:param props: -
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__98b4551fa3e2c90c6962e67d9e55a8c550a41125e599afac13d0fde3c8818739)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@builtins.property
@jsii.member(jsii_name="attrApiGatewayInstanceIds")
def attr_api_gateway_instance_ids(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute ApiGatewayInstanceIds: The list of The ApiGateway group ids.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrApiGatewayInstanceIds"))
@builtins.property
@jsii.member(jsii_name="attrApiGatewayInstances")
def attr_api_gateway_instances(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute ApiGatewayInstances: The information about ApiGateway groups.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrApiGatewayInstances"))
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-apigateway.datasource.InstancesProps",
jsii_struct_bases=[],
name_mapping={"instance_id": "instanceId", "language": "language"},
)
class InstancesProps:
def __init__(
self,
*,
instance_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
language: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``DATASOURCE::ApiGateway::Instances``.
:param instance_id: Property instanceId: API Gateway Instance ID.
:param language: Property language: Language Type.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__695868e6d8de21e39d1920ad3579a68fd88c6af229302ed7648dbc0dfcd66427)
check_type(argname="argument instance_id", value=instance_id, expected_type=type_hints["instance_id"])
check_type(argname="argument language", value=language, expected_type=type_hints["language"])
self._values: typing.Dict[builtins.str, typing.Any] = {}
if instance_id is not None:
self._values["instance_id"] = instance_id
if language is not None:
self._values["language"] = language
@builtins.property
def instance_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property instanceId: API Gateway Instance ID.'''
result = self._values.get("instance_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def language(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property language: Language Type.'''
result = self._values.get("language")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "InstancesProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class RosApis(
_ros_cdk_core_7adfd82f.RosResource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-apigateway.datasource.RosApis",
):
'''A ROS template type: ``DATASOURCE::ApiGateway::Apis``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["RosApisProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
'''Create a new ``DATASOURCE::ApiGateway::Apis``.
:param scope: - scope in which this resource is defined.
:param id: - scoped id of the resource.
:param props: - resource properties.
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__93264959b44284e5ba3fa35aec073b82f47bdc4a207e3c35eb591e1ac531923c)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@jsii.member(jsii_name="renderProperties")
def _render_properties(
self,
props: typing.Mapping[builtins.str, typing.Any],
) -> typing.Mapping[builtins.str, typing.Any]:
'''
:param props: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__09e5d117954878c0cf5712532d7875613634785857cf031ea883b80b3cc7fde5)
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))
@jsii.python.classproperty
@jsii.member(jsii_name="ROS_RESOURCE_TYPE_NAME")
def ROS_RESOURCE_TYPE_NAME(cls) -> builtins.str:
'''The resource type name for this resource class.'''
return typing.cast(builtins.str, jsii.sget(cls, "ROS_RESOURCE_TYPE_NAME"))
@builtins.property
@jsii.member(jsii_name="attrApiIds")
def attr_api_ids(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: ApiIds: The list of The ApiGateway api ids.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrApiIds"))
@builtins.property
@jsii.member(jsii_name="attrApis")
def attr_apis(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: Apis: The information about ApiGateway apis.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrApis"))
@builtins.property
@jsii.member(jsii_name="rosProperties")
def _ros_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "rosProperties"))
@builtins.property
@jsii.member(jsii_name="enableResourcePropertyConstraint")
def enable_resource_property_constraint(self) -> builtins.bool:
return typing.cast(builtins.bool, jsii.get(self, "enableResourcePropertyConstraint"))
@enable_resource_property_constraint.setter
def enable_resource_property_constraint(self, value: builtins.bool) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__029aa2f22b6b5175fada1fe9e8cb927e6d116ce7c4c3371b2ec45a0284867b67)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "enableResourcePropertyConstraint", value)
@builtins.property
@jsii.member(jsii_name="apiId")
def api_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: apiId: ID of the specified API.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "apiId"))
@api_id.setter
def api_id(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__25335f142a21874a1efe1d3e5dec37522bf9c495c1de8404b541b896f2fde8f3)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "apiId", value)
@builtins.property
@jsii.member(jsii_name="apiName")
def api_name(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: apiName: API name (fuzzy matching).
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "apiName"))
@api_name.setter
def api_name(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__0aa5fb954ac3dfa1bac43cf6282fc5c6665857b5333cf8b4e921ea8553d4bf93)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "apiName", value)
@builtins.property
@jsii.member(jsii_name="catalogId")
def catalog_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: catalogId: Catalog number.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "catalogId"))
@catalog_id.setter
def catalog_id(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__38613789b4e889fc71f20be65ceedea0d31a3c9028b0b610f0b7ad5341abc098)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "catalogId", value)
@builtins.property
@jsii.member(jsii_name="enableTagAuth")
def enable_tag_auth(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: enableTagAuth: Enable label validation.
'''
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "enableTagAuth"))
@enable_tag_auth.setter
def enable_tag_auth(
self,
value: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__f131ce4df9d12a71923111a1797447bb5df37a2fc5f647d098f0e7fc06276a56)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "enableTagAuth", value)
@builtins.property
@jsii.member(jsii_name="groupId")
def group_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: groupId: ID of the specified group.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "groupId"))
@group_id.setter
def group_id(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__61390830de230e0fd5190982e9f615be58c2ff7793d41a08b22324095927930c)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "groupId", value)
@builtins.property
@jsii.member(jsii_name="visibility")
def visibility(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: visibility: Whether the API is public.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "visibility"))
@visibility.setter
def visibility(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__e3c44c80f298f6328ad8ec35dbc7e845e6b9760ef0e5a8d21526388a867dd841)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "visibility", value)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-apigateway.datasource.RosApisProps",
jsii_struct_bases=[],
name_mapping={
"api_id": "apiId",
"api_name": "apiName",
"catalog_id": "catalogId",
"enable_tag_auth": "enableTagAuth",
"group_id": "groupId",
"visibility": "visibility",
},
)
class RosApisProps:
def __init__(
self,
*,
api_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
api_name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
catalog_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
enable_tag_auth: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
group_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
visibility: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``DATASOURCE::ApiGateway::Apis``.
:param api_id:
:param api_name:
:param catalog_id:
:param enable_tag_auth:
:param group_id:
:param visibility:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__acdab5bbb00ad7cde94458123eed70bbb97bb0795dae2a1a732ecf5970212906)
check_type(argname="argument api_id", value=api_id, expected_type=type_hints["api_id"])
check_type(argname="argument api_name", value=api_name, expected_type=type_hints["api_name"])
check_type(argname="argument catalog_id", value=catalog_id, expected_type=type_hints["catalog_id"])
check_type(argname="argument enable_tag_auth", value=enable_tag_auth, expected_type=type_hints["enable_tag_auth"])
check_type(argname="argument group_id", value=group_id, expected_type=type_hints["group_id"])
check_type(argname="argument visibility", value=visibility, expected_type=type_hints["visibility"])
self._values: typing.Dict[builtins.str, typing.Any] = {}
if api_id is not None:
self._values["api_id"] = api_id
if api_name is not None:
self._values["api_name"] = api_name
if catalog_id is not None:
self._values["catalog_id"] = catalog_id
if enable_tag_auth is not None:
self._values["enable_tag_auth"] = enable_tag_auth
if group_id is not None:
self._values["group_id"] = group_id
if visibility is not None:
self._values["visibility"] = visibility
@builtins.property
def api_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: apiId: ID of the specified API.
'''
result = self._values.get("api_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def api_name(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: apiName: API name (fuzzy matching).
'''
result = self._values.get("api_name")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def catalog_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: catalogId: Catalog number.
'''
result = self._values.get("catalog_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def enable_tag_auth(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: enableTagAuth: Enable label validation.
'''
result = self._values.get("enable_tag_auth")
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def group_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: groupId: ID of the specified group.
'''
result = self._values.get("group_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def visibility(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: visibility: Whether the API is public.
'''
result = self._values.get("visibility")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "RosApisProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class RosApps(
_ros_cdk_core_7adfd82f.RosResource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-apigateway.datasource.RosApps",
):
'''A ROS template type: ``DATASOURCE::ApiGateway::Apps``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["RosAppsProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
'''Create a new ``DATASOURCE::ApiGateway::Apps``.
:param scope: - scope in which this resource is defined.
:param id: - scoped id of the resource.
:param props: - resource properties.
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__7ec17926328936ae8d82a0a8ef965ef9ad2ad0fab09d139d1768fc1798199087)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@jsii.member(jsii_name="renderProperties")
def _render_properties(
self,
props: typing.Mapping[builtins.str, typing.Any],
) -> typing.Mapping[builtins.str, typing.Any]:
'''
:param props: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__2718f94ca585dd891671c24ecddb3d1ebbe5615648cc6adcfd823506c808a5be)
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))
@jsii.python.classproperty
@jsii.member(jsii_name="ROS_RESOURCE_TYPE_NAME")
def ROS_RESOURCE_TYPE_NAME(cls) -> builtins.str:
'''The resource type name for this resource class.'''
return typing.cast(builtins.str, jsii.sget(cls, "ROS_RESOURCE_TYPE_NAME"))
@builtins.property
@jsii.member(jsii_name="attrAppIds")
def attr_app_ids(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: AppIds: The list of The ApiGateway app ids.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrAppIds"))
@builtins.property
@jsii.member(jsii_name="attrApps")
def attr_apps(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: Apps: The information about ApiGateway apps.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrApps"))
@builtins.property
@jsii.member(jsii_name="rosProperties")
def _ros_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "rosProperties"))
@builtins.property
@jsii.member(jsii_name="enableResourcePropertyConstraint")
def enable_resource_property_constraint(self) -> builtins.bool:
return typing.cast(builtins.bool, jsii.get(self, "enableResourcePropertyConstraint"))
@enable_resource_property_constraint.setter
def enable_resource_property_constraint(self, value: builtins.bool) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__fa72c8ae69a74809894bbc3a8c7d9852611385091d65462454188a5547dd50c4)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "enableResourcePropertyConstraint", value)
@builtins.property
@jsii.member(jsii_name="appId")
def app_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: appId: Unique ID of the app.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "appId"))
@app_id.setter
def app_id(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__577c4b0694ee735ee25c5aed0ef5ab2e9bc15791027497d688ac2671ecc65347)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "appId", value)
@builtins.property
@jsii.member(jsii_name="appOwner")
def app_owner(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: appOwner: Alibaba Cloud account ID of the app owner.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "appOwner"))
@app_owner.setter
def app_owner(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__3a45037dd13c52c3236744efa1efbc3c047032f2d5093972ce70600418b503fc)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "appOwner", value)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-apigateway.datasource.RosAppsProps",
jsii_struct_bases=[],
name_mapping={"app_id": "appId", "app_owner": "appOwner"},
)
class RosAppsProps:
def __init__(
self,
*,
app_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
app_owner: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``DATASOURCE::ApiGateway::Apps``.
:param app_id:
:param app_owner:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__08135308dfa5a81fa4b1cbac0758d0fb6ab386d3579797a0a310823467a374d8)
check_type(argname="argument app_id", value=app_id, expected_type=type_hints["app_id"])
check_type(argname="argument app_owner", value=app_owner, expected_type=type_hints["app_owner"])
self._values: typing.Dict[builtins.str, typing.Any] = {}
if app_id is not None:
self._values["app_id"] = app_id
if app_owner is not None:
self._values["app_owner"] = app_owner
@builtins.property
def app_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: appId: Unique ID of the app.
'''
result = self._values.get("app_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def app_owner(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: appOwner: Alibaba Cloud account ID of the app owner.
'''
result = self._values.get("app_owner")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "RosAppsProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class RosGroups(
_ros_cdk_core_7adfd82f.RosResource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-apigateway.datasource.RosGroups",
):
'''A ROS template type: ``DATASOURCE::ApiGateway::Groups``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["RosGroupsProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
'''Create a new ``DATASOURCE::ApiGateway::Groups``.
:param scope: - scope in which this resource is defined.
:param id: - scoped id of the resource.
:param props: - resource properties.
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__069d727a309bd0c5ef80d3693bdd3780b81eec44626e2bf5693c6da22d430c39)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@jsii.member(jsii_name="renderProperties")
def _render_properties(
self,
props: typing.Mapping[builtins.str, typing.Any],
) -> typing.Mapping[builtins.str, typing.Any]:
'''
:param props: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__ebe3962eb3a7d5cb32cbadeaa69fd3110f769217e8e57f7f16c2d190e6814f38)
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))
@jsii.python.classproperty
@jsii.member(jsii_name="ROS_RESOURCE_TYPE_NAME")
def ROS_RESOURCE_TYPE_NAME(cls) -> builtins.str:
'''The resource type name for this resource class.'''
return typing.cast(builtins.str, jsii.sget(cls, "ROS_RESOURCE_TYPE_NAME"))
@builtins.property
@jsii.member(jsii_name="attrApiGroupIds")
def attr_api_group_ids(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: ApiGroupIds: The list of The ApiGateway group ids.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrApiGroupIds"))
@builtins.property
@jsii.member(jsii_name="attrApiGroups")
def attr_api_groups(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: ApiGroups: The information about ApiGateway groups.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrApiGroups"))
@builtins.property
@jsii.member(jsii_name="rosProperties")
def _ros_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "rosProperties"))
@builtins.property
@jsii.member(jsii_name="enableResourcePropertyConstraint")
def enable_resource_property_constraint(self) -> builtins.bool:
return typing.cast(builtins.bool, jsii.get(self, "enableResourcePropertyConstraint"))
@enable_resource_property_constraint.setter
def enable_resource_property_constraint(self, value: builtins.bool) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__91633f1929ad12bf61c96e13e8a6f11651cff14b10dd6a450e09ffa2be79dc84)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "enableResourcePropertyConstraint", value)
@builtins.property
@jsii.member(jsii_name="groupId")
def group_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: groupId: API group ID.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "groupId"))
@group_id.setter
def group_id(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__af96d4d65241fc1ca254e01195a33e5c80370ecbe8c2d512b427501e6acbc9c2)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "groupId", value)
@builtins.property
@jsii.member(jsii_name="groupName")
def group_name(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: groupName: Specified keyword of the API group name.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "groupName"))
@group_name.setter
def group_name(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__0344095bcc9119369b19536f079e1b039ab2e4039086ffcd6c78ee0d7c186788)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "groupName", value)
@builtins.property
@jsii.member(jsii_name="instanceId")
def instance_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: instanceId: API Gateway Instance ID.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "instanceId"))
@instance_id.setter
def instance_id(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__4e3f788f99b8ba906228a6335c2f4c46b9739cd2f1d9c21d01ae0c743485ce57)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "instanceId", value)
@builtins.property
@jsii.member(jsii_name="sort")
def sort(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: sort: Sort.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "sort"))
@sort.setter
def sort(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__f2278ea5581543b5fb6f4277a71e6331e58ccfab33516c8bc509bd67fa3881cf)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "sort", value)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-apigateway.datasource.RosGroupsProps",
jsii_struct_bases=[],
name_mapping={
"group_id": "groupId",
"group_name": "groupName",
"instance_id": "instanceId",
"sort": "sort",
},
)
class RosGroupsProps:
def __init__(
self,
*,
group_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
group_name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
instance_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
sort: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``DATASOURCE::ApiGateway::Groups``.
:param group_id:
:param group_name:
:param instance_id:
:param sort:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__4c0b994bf4c49f6ddf85ebc417a7cc003876bde493f5e5b4342fddc2f2a0455b)
check_type(argname="argument group_id", value=group_id, expected_type=type_hints["group_id"])
check_type(argname="argument group_name", value=group_name, expected_type=type_hints["group_name"])
check_type(argname="argument instance_id", value=instance_id, expected_type=type_hints["instance_id"])
check_type(argname="argument sort", value=sort, expected_type=type_hints["sort"])
self._values: typing.Dict[builtins.str, typing.Any] = {}
if group_id is not None:
self._values["group_id"] = group_id
if group_name is not None:
self._values["group_name"] = group_name
if instance_id is not None:
self._values["instance_id"] = instance_id
if sort is not None:
self._values["sort"] = sort
@builtins.property
def group_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: groupId: API group ID.
'''
result = self._values.get("group_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def group_name(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: groupName: Specified keyword of the API group name.
'''
result = self._values.get("group_name")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def instance_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: instanceId: API Gateway Instance ID.
'''
result = self._values.get("instance_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def sort(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: sort: Sort.
'''
result = self._values.get("sort")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "RosGroupsProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class RosInstances(
_ros_cdk_core_7adfd82f.RosResource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-apigateway.datasource.RosInstances",
):
'''A ROS template type: ``DATASOURCE::ApiGateway::Instances``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["RosInstancesProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
'''Create a new ``DATASOURCE::ApiGateway::Instances``.
:param scope: - scope in which this resource is defined.
:param id: - scoped id of the resource.
:param props: - resource properties.
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__98195a24f229c92198f3f5928459aea2b20ccef3708c5a9783d645be3e129275)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@jsii.member(jsii_name="renderProperties")
def _render_properties(
self,
props: typing.Mapping[builtins.str, typing.Any],
) -> typing.Mapping[builtins.str, typing.Any]:
'''
:param props: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__4f506bb48d6f830f53d126fde2eb3df853b67cdcf1f6baa4e36f08c174b4149a)
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))
@jsii.python.classproperty
@jsii.member(jsii_name="ROS_RESOURCE_TYPE_NAME")
def ROS_RESOURCE_TYPE_NAME(cls) -> builtins.str:
'''The resource type name for this resource class.'''
return typing.cast(builtins.str, jsii.sget(cls, "ROS_RESOURCE_TYPE_NAME"))
@builtins.property
@jsii.member(jsii_name="attrApiGatewayInstanceIds")
def attr_api_gateway_instance_ids(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: ApiGatewayInstanceIds: The list of The ApiGateway group ids.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrApiGatewayInstanceIds"))
@builtins.property
@jsii.member(jsii_name="attrApiGatewayInstances")
def attr_api_gateway_instances(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: ApiGatewayInstances: The information about ApiGateway groups.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrApiGatewayInstances"))
@builtins.property
@jsii.member(jsii_name="rosProperties")
def _ros_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "rosProperties"))
@builtins.property
@jsii.member(jsii_name="enableResourcePropertyConstraint")
def enable_resource_property_constraint(self) -> builtins.bool:
return typing.cast(builtins.bool, jsii.get(self, "enableResourcePropertyConstraint"))
@enable_resource_property_constraint.setter
def enable_resource_property_constraint(self, value: builtins.bool) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__b969eec0f8ce9ef2033b056046cad252e1d9f177dd9084e18ab39882bc68ac47)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "enableResourcePropertyConstraint", value)
@builtins.property
@jsii.member(jsii_name="instanceId")
def instance_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: instanceId: API Gateway Instance ID.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "instanceId"))
@instance_id.setter
def instance_id(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__788ae852d0fcd00a1386d6979d6a399703b0c048eee69b5f2d7e8c490da3c1bd)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "instanceId", value)
@builtins.property
@jsii.member(jsii_name="language")
def language(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: language: Language Type.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "language"))
@language.setter
def language(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__dbfbad24979fb53ede10b04a0fd6ae2c2841e6486f61447951a73f812f5549b0)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "language", value)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-apigateway.datasource.RosInstancesProps",
jsii_struct_bases=[],
name_mapping={"instance_id": "instanceId", "language": "language"},
)
class RosInstancesProps:
def __init__(
self,
*,
instance_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
language: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``DATASOURCE::ApiGateway::Instances``.
:param instance_id:
:param language:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__d4a87303f079720f42dfe1e4afd2f7e8ad5f5cdad8477387de19aa606c6c37a8)
check_type(argname="argument instance_id", value=instance_id, expected_type=type_hints["instance_id"])
check_type(argname="argument language", value=language, expected_type=type_hints["language"])
self._values: typing.Dict[builtins.str, typing.Any] = {}
if instance_id is not None:
self._values["instance_id"] = instance_id
if language is not None:
self._values["language"] = language
@builtins.property
def instance_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: instanceId: API Gateway Instance ID.
'''
result = self._values.get("instance_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def language(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: language: Language Type.
'''
result = self._values.get("language")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "RosInstancesProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
__all__ = [
"Apis",
"ApisProps",
"Apps",
"AppsProps",
"Groups",
"GroupsProps",
"Instances",
"InstancesProps",
"RosApis",
"RosApisProps",
"RosApps",
"RosAppsProps",
"RosGroups",
"RosGroupsProps",
"RosInstances",
"RosInstancesProps",
]
publication.publish()
def _typecheckingstub__75f7c6d2d7f1baa67ef1bf057aeb20d862e0dbe559e5eac248898466f17dcd3d(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Optional[typing.Union[ApisProps, typing.Dict[builtins.str, typing.Any]]] = None,
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__54b0bf96cbf53062dc1eb1d9eb3438334e7258d8cf94b7407e50e6392d9c0667(
*,
api_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
api_name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
catalog_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
enable_tag_auth: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
group_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
visibility: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__d4dfb74b8bee8189bd10f5ce6356133cd98de6bd337fd3fb3ba7d78c627d3659(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Optional[typing.Union[AppsProps, typing.Dict[builtins.str, typing.Any]]] = None,
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__3943db5d718722304df85f606c71c4b482007f8511a913c134c6e977190c27ac(
*,
app_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
app_owner: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__39c3b2a6c406e3cb486800c3bbcefc80f6a3dbd33c4d873ef5e16a9ebedc0f33(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Optional[typing.Union[GroupsProps, typing.Dict[builtins.str, typing.Any]]] = None,
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__1a4c18455871acd6c8b3563592670fcef377052e29e2be8a43e8bfe5e365fda9(
*,
group_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
group_name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
instance_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
sort: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__98b4551fa3e2c90c6962e67d9e55a8c550a41125e599afac13d0fde3c8818739(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Optional[typing.Union[InstancesProps, typing.Dict[builtins.str, typing.Any]]] = None,
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__695868e6d8de21e39d1920ad3579a68fd88c6af229302ed7648dbc0dfcd66427(
*,
instance_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
language: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__93264959b44284e5ba3fa35aec073b82f47bdc4a207e3c35eb591e1ac531923c(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[RosApisProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__09e5d117954878c0cf5712532d7875613634785857cf031ea883b80b3cc7fde5(
props: typing.Mapping[builtins.str, typing.Any],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__029aa2f22b6b5175fada1fe9e8cb927e6d116ce7c4c3371b2ec45a0284867b67(
value: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__25335f142a21874a1efe1d3e5dec37522bf9c495c1de8404b541b896f2fde8f3(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__0aa5fb954ac3dfa1bac43cf6282fc5c6665857b5333cf8b4e921ea8553d4bf93(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__38613789b4e889fc71f20be65ceedea0d31a3c9028b0b610f0b7ad5341abc098(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__f131ce4df9d12a71923111a1797447bb5df37a2fc5f647d098f0e7fc06276a56(
value: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__61390830de230e0fd5190982e9f615be58c2ff7793d41a08b22324095927930c(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__e3c44c80f298f6328ad8ec35dbc7e845e6b9760ef0e5a8d21526388a867dd841(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__acdab5bbb00ad7cde94458123eed70bbb97bb0795dae2a1a732ecf5970212906(
*,
api_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
api_name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
catalog_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
enable_tag_auth: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
group_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
visibility: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__7ec17926328936ae8d82a0a8ef965ef9ad2ad0fab09d139d1768fc1798199087(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[RosAppsProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__2718f94ca585dd891671c24ecddb3d1ebbe5615648cc6adcfd823506c808a5be(
props: typing.Mapping[builtins.str, typing.Any],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__fa72c8ae69a74809894bbc3a8c7d9852611385091d65462454188a5547dd50c4(
value: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__577c4b0694ee735ee25c5aed0ef5ab2e9bc15791027497d688ac2671ecc65347(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__3a45037dd13c52c3236744efa1efbc3c047032f2d5093972ce70600418b503fc(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__08135308dfa5a81fa4b1cbac0758d0fb6ab386d3579797a0a310823467a374d8(
*,
app_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
app_owner: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__069d727a309bd0c5ef80d3693bdd3780b81eec44626e2bf5693c6da22d430c39(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[RosGroupsProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__ebe3962eb3a7d5cb32cbadeaa69fd3110f769217e8e57f7f16c2d190e6814f38(
props: typing.Mapping[builtins.str, typing.Any],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__91633f1929ad12bf61c96e13e8a6f11651cff14b10dd6a450e09ffa2be79dc84(
value: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__af96d4d65241fc1ca254e01195a33e5c80370ecbe8c2d512b427501e6acbc9c2(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__0344095bcc9119369b19536f079e1b039ab2e4039086ffcd6c78ee0d7c186788(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__4e3f788f99b8ba906228a6335c2f4c46b9739cd2f1d9c21d01ae0c743485ce57(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__f2278ea5581543b5fb6f4277a71e6331e58ccfab33516c8bc509bd67fa3881cf(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__4c0b994bf4c49f6ddf85ebc417a7cc003876bde493f5e5b4342fddc2f2a0455b(
*,
group_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
group_name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
instance_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
sort: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__98195a24f229c92198f3f5928459aea2b20ccef3708c5a9783d645be3e129275(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[RosInstancesProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__4f506bb48d6f830f53d126fde2eb3df853b67cdcf1f6baa4e36f08c174b4149a(
props: typing.Mapping[builtins.str, typing.Any],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__b969eec0f8ce9ef2033b056046cad252e1d9f177dd9084e18ab39882bc68ac47(
value: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__788ae852d0fcd00a1386d6979d6a399703b0c048eee69b5f2d7e8c490da3c1bd(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__dbfbad24979fb53ede10b04a0fd6ae2c2841e6486f61447951a73f812f5549b0(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__d4a87303f079720f42dfe1e4afd2f7e8ad5f5cdad8477387de19aa606c6c37a8(
*,
instance_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
language: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass | /ros-cdk-apigateway-1.0.17.tar.gz/ros-cdk-apigateway-1.0.17/src/ros_cdk_apigateway/datasource/__init__.py | 0.597256 | 0.150809 | __init__.py | pypi |
import abc
import builtins
import datetime
import enum
import typing
import jsii
import publication
import typing_extensions
from typeguard import check_type
from ._jsii import *
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-assembly-schema.AliyunRosStackProperties",
jsii_struct_bases=[],
name_mapping={
"template_file": "templateFile",
"parameters": "parameters",
"stack_name": "stackName",
"tags": "tags",
},
)
class AliyunRosStackProperties:
def __init__(
self,
*,
template_file: builtins.str,
parameters: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
stack_name: typing.Optional[builtins.str] = None,
tags: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
) -> None:
'''Artifact properties for ROS stacks.
:param template_file: A file relative to the assembly root which contains the ROS template for this stack.
:param parameters: Values for ROS stack parameters that should be passed when the stack is deployed. Default: - No parameters
:param stack_name: The name to use for the ROS stack. Default: - name derived from artifact ID
:param tags: Values for ROS stack tags that should be passed when the stack is deployed. Default: - No tags
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__50db4a4408e92654c48d87ed0677ec40f604c7be253310fca5ce2f70f07f8b10)
check_type(argname="argument template_file", value=template_file, expected_type=type_hints["template_file"])
check_type(argname="argument parameters", value=parameters, expected_type=type_hints["parameters"])
check_type(argname="argument stack_name", value=stack_name, expected_type=type_hints["stack_name"])
check_type(argname="argument tags", value=tags, expected_type=type_hints["tags"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"template_file": template_file,
}
if parameters is not None:
self._values["parameters"] = parameters
if stack_name is not None:
self._values["stack_name"] = stack_name
if tags is not None:
self._values["tags"] = tags
@builtins.property
def template_file(self) -> builtins.str:
'''A file relative to the assembly root which contains the ROS template for this stack.'''
result = self._values.get("template_file")
assert result is not None, "Required property 'template_file' is missing"
return typing.cast(builtins.str, result)
@builtins.property
def parameters(self) -> typing.Optional[typing.Mapping[builtins.str, builtins.str]]:
'''Values for ROS stack parameters that should be passed when the stack is deployed.
:default: - No parameters
'''
result = self._values.get("parameters")
return typing.cast(typing.Optional[typing.Mapping[builtins.str, builtins.str]], result)
@builtins.property
def stack_name(self) -> typing.Optional[builtins.str]:
'''The name to use for the ROS stack.
:default: - name derived from artifact ID
'''
result = self._values.get("stack_name")
return typing.cast(typing.Optional[builtins.str], result)
@builtins.property
def tags(self) -> typing.Optional[typing.Mapping[builtins.str, builtins.str]]:
'''Values for ROS stack tags that should be passed when the stack is deployed.
:default: - No tags
'''
result = self._values.get("tags")
return typing.cast(typing.Optional[typing.Mapping[builtins.str, builtins.str]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "AliyunRosStackProperties(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-assembly-schema.AmiContextQuery",
jsii_struct_bases=[],
name_mapping={
"account": "account",
"filters": "filters",
"region": "region",
"owners": "owners",
},
)
class AmiContextQuery:
def __init__(
self,
*,
account: builtins.str,
filters: typing.Mapping[builtins.str, typing.Sequence[builtins.str]],
region: builtins.str,
owners: typing.Optional[typing.Sequence[builtins.str]] = None,
) -> None:
'''Query to AMI context provider.
:param account: Account to query.
:param filters: Filters to DescribeImages call.
:param region: Region to query.
:param owners: Owners to DescribeImages call. Default: - All owners
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__4da5c94286713a25f11bbf84fc0fa807019391853bda290dd844c4f8f34e8978)
check_type(argname="argument account", value=account, expected_type=type_hints["account"])
check_type(argname="argument filters", value=filters, expected_type=type_hints["filters"])
check_type(argname="argument region", value=region, expected_type=type_hints["region"])
check_type(argname="argument owners", value=owners, expected_type=type_hints["owners"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"account": account,
"filters": filters,
"region": region,
}
if owners is not None:
self._values["owners"] = owners
@builtins.property
def account(self) -> builtins.str:
'''Account to query.'''
result = self._values.get("account")
assert result is not None, "Required property 'account' is missing"
return typing.cast(builtins.str, result)
@builtins.property
def filters(self) -> typing.Mapping[builtins.str, typing.List[builtins.str]]:
'''Filters to DescribeImages call.'''
result = self._values.get("filters")
assert result is not None, "Required property 'filters' is missing"
return typing.cast(typing.Mapping[builtins.str, typing.List[builtins.str]], result)
@builtins.property
def region(self) -> builtins.str:
'''Region to query.'''
result = self._values.get("region")
assert result is not None, "Required property 'region' is missing"
return typing.cast(builtins.str, result)
@builtins.property
def owners(self) -> typing.Optional[typing.List[builtins.str]]:
'''Owners to DescribeImages call.
:default: - All owners
'''
result = self._values.get("owners")
return typing.cast(typing.Optional[typing.List[builtins.str]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "AmiContextQuery(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-assembly-schema.ArtifactManifest",
jsii_struct_bases=[],
name_mapping={
"type": "type",
"dependencies": "dependencies",
"metadata": "metadata",
"properties": "properties",
},
)
class ArtifactManifest:
def __init__(
self,
*,
type: "ArtifactType",
dependencies: typing.Optional[typing.Sequence[builtins.str]] = None,
metadata: typing.Optional[typing.Mapping[builtins.str, typing.Sequence[typing.Union["MetadataEntry", typing.Dict[builtins.str, typing.Any]]]]] = None,
properties: typing.Optional[typing.Union[typing.Union[AliyunRosStackProperties, typing.Dict[builtins.str, typing.Any]], typing.Union["TreeArtifactProperties", typing.Dict[builtins.str, typing.Any]], typing.Union["NestedCloudAssemblyProperties", typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
'''A manifest for a single artifact within the cloud assembly.
:param type: The type of artifact.
:param dependencies: IDs of artifacts that must be deployed before this artifact. Default: - no dependencies.
:param metadata: Associated metadata. Default: - no metadata.
:param properties: The set of properties for this artifact (depends on type). Default: - no properties.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__b23c064aa8a7a12940601a4c031f5909112530123fae3b281b473992e6c98422)
check_type(argname="argument type", value=type, expected_type=type_hints["type"])
check_type(argname="argument dependencies", value=dependencies, expected_type=type_hints["dependencies"])
check_type(argname="argument metadata", value=metadata, expected_type=type_hints["metadata"])
check_type(argname="argument properties", value=properties, expected_type=type_hints["properties"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"type": type,
}
if dependencies is not None:
self._values["dependencies"] = dependencies
if metadata is not None:
self._values["metadata"] = metadata
if properties is not None:
self._values["properties"] = properties
@builtins.property
def type(self) -> "ArtifactType":
'''The type of artifact.'''
result = self._values.get("type")
assert result is not None, "Required property 'type' is missing"
return typing.cast("ArtifactType", result)
@builtins.property
def dependencies(self) -> typing.Optional[typing.List[builtins.str]]:
'''IDs of artifacts that must be deployed before this artifact.
:default: - no dependencies.
'''
result = self._values.get("dependencies")
return typing.cast(typing.Optional[typing.List[builtins.str]], result)
@builtins.property
def metadata(
self,
) -> typing.Optional[typing.Mapping[builtins.str, typing.List["MetadataEntry"]]]:
'''Associated metadata.
:default: - no metadata.
'''
result = self._values.get("metadata")
return typing.cast(typing.Optional[typing.Mapping[builtins.str, typing.List["MetadataEntry"]]], result)
@builtins.property
def properties(
self,
) -> typing.Optional[typing.Union[AliyunRosStackProperties, "TreeArtifactProperties", "NestedCloudAssemblyProperties"]]:
'''The set of properties for this artifact (depends on type).
:default: - no properties.
'''
result = self._values.get("properties")
return typing.cast(typing.Optional[typing.Union[AliyunRosStackProperties, "TreeArtifactProperties", "NestedCloudAssemblyProperties"]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "ArtifactManifest(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
@jsii.enum(jsii_type="@alicloud/ros-cdk-assembly-schema.ArtifactMetadataEntryType")
class ArtifactMetadataEntryType(enum.Enum):
'''Type of artifact metadata entry.'''
INFO = "INFO"
'''Metadata key used to print INFO-level messages by the toolkit when an app is syntheized.'''
WARN = "WARN"
'''Metadata key used to print WARNING-level messages by the toolkit when an app is syntheized.'''
ERROR = "ERROR"
'''Metadata key used to print ERROR-level messages by the toolkit when an app is syntheized.'''
LOGICAL_ID = "LOGICAL_ID"
'''Represents the ROS logical ID of a resource at a certain path.'''
STACK_TAGS = "STACK_TAGS"
'''Represents tags of a stack.'''
@jsii.enum(jsii_type="@alicloud/ros-cdk-assembly-schema.ArtifactType")
class ArtifactType(enum.Enum):
'''Type of cloud artifact.'''
NONE = "NONE"
'''Stub required because of JSII.'''
ALIYUN_ROS_STACK = "ALIYUN_ROS_STACK"
'''The artifact is an ROS stack.'''
CDK_TREE = "CDK_TREE"
'''The artifact contains the CDK application's construct tree.'''
ASSET_MANIFEST = "ASSET_MANIFEST"
'''Manifest for all assets in the Cloud Assembly.'''
NESTED_CLOUD_ASSEMBLY = "NESTED_CLOUD_ASSEMBLY"
'''Nested Cloud Assembly.'''
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-assembly-schema.AssemblyManifest",
jsii_struct_bases=[],
name_mapping={
"version": "version",
"artifacts": "artifacts",
"missing": "missing",
"runtime": "runtime",
},
)
class AssemblyManifest:
def __init__(
self,
*,
version: builtins.str,
artifacts: typing.Optional[typing.Mapping[builtins.str, typing.Union[ArtifactManifest, typing.Dict[builtins.str, typing.Any]]]] = None,
missing: typing.Optional[typing.Sequence[typing.Union["MissingContext", typing.Dict[builtins.str, typing.Any]]]] = None,
runtime: typing.Optional[typing.Union["RuntimeInfo", typing.Dict[builtins.str, typing.Any]]] = None,
) -> None:
'''A manifest which describes the cloud assembly.
:param version: Protocol version.
:param artifacts: The set of artifacts in this assembly. Default: - no artifacts.
:param missing: Missing context information. If this field has values, it means that the cloud assembly is not complete and should not be deployed. Default: - no missing context.
:param runtime: Runtime information. Default: - no info.
'''
if isinstance(runtime, dict):
runtime = RuntimeInfo(**runtime)
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__b6b194e83c34230d0742619fe13b220ec6ccf3e707ed53bb1f8153e7fa375a5f)
check_type(argname="argument version", value=version, expected_type=type_hints["version"])
check_type(argname="argument artifacts", value=artifacts, expected_type=type_hints["artifacts"])
check_type(argname="argument missing", value=missing, expected_type=type_hints["missing"])
check_type(argname="argument runtime", value=runtime, expected_type=type_hints["runtime"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"version": version,
}
if artifacts is not None:
self._values["artifacts"] = artifacts
if missing is not None:
self._values["missing"] = missing
if runtime is not None:
self._values["runtime"] = runtime
@builtins.property
def version(self) -> builtins.str:
'''Protocol version.'''
result = self._values.get("version")
assert result is not None, "Required property 'version' is missing"
return typing.cast(builtins.str, result)
@builtins.property
def artifacts(
self,
) -> typing.Optional[typing.Mapping[builtins.str, ArtifactManifest]]:
'''The set of artifacts in this assembly.
:default: - no artifacts.
'''
result = self._values.get("artifacts")
return typing.cast(typing.Optional[typing.Mapping[builtins.str, ArtifactManifest]], result)
@builtins.property
def missing(self) -> typing.Optional[typing.List["MissingContext"]]:
'''Missing context information.
If this field has values, it means that the
cloud assembly is not complete and should not be deployed.
:default: - no missing context.
'''
result = self._values.get("missing")
return typing.cast(typing.Optional[typing.List["MissingContext"]], result)
@builtins.property
def runtime(self) -> typing.Optional["RuntimeInfo"]:
'''Runtime information.
:default: - no info.
'''
result = self._values.get("runtime")
return typing.cast(typing.Optional["RuntimeInfo"], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "AssemblyManifest(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-assembly-schema.AvailabilityZonesContextQuery",
jsii_struct_bases=[],
name_mapping={"account": "account", "region": "region"},
)
class AvailabilityZonesContextQuery:
def __init__(self, *, account: builtins.str, region: builtins.str) -> None:
'''Query to availability zone context provider.
:param account: Query account.
:param region: Query region.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__85e5f6837358a10c72d3f9dd17a950563028b27c1bf2cd274fb3941b7a77f604)
check_type(argname="argument account", value=account, expected_type=type_hints["account"])
check_type(argname="argument region", value=region, expected_type=type_hints["region"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"account": account,
"region": region,
}
@builtins.property
def account(self) -> builtins.str:
'''Query account.'''
result = self._values.get("account")
assert result is not None, "Required property 'account' is missing"
return typing.cast(builtins.str, result)
@builtins.property
def region(self) -> builtins.str:
'''Query region.'''
result = self._values.get("region")
assert result is not None, "Required property 'region' is missing"
return typing.cast(builtins.str, result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "AvailabilityZonesContextQuery(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
@jsii.enum(jsii_type="@alicloud/ros-cdk-assembly-schema.ContextProvider")
class ContextProvider(enum.Enum):
'''Identifier for the context provider.'''
AMI_PROVIDER = "AMI_PROVIDER"
'''AMI provider.'''
AVAILABILITY_ZONE_PROVIDER = "AVAILABILITY_ZONE_PROVIDER"
'''AZ provider.'''
HOSTED_ZONE_PROVIDER = "HOSTED_ZONE_PROVIDER"
'''Route53 Hosted Zone provider.'''
SSM_PARAMETER_PROVIDER = "SSM_PARAMETER_PROVIDER"
'''SSM Parameter Provider.'''
VPC_PROVIDER = "VPC_PROVIDER"
'''VPC Provider.'''
ENDPOINT_SERVICE_AVAILABILITY_ZONE_PROVIDER = "ENDPOINT_SERVICE_AVAILABILITY_ZONE_PROVIDER"
'''VPC Endpoint Service AZ Provider.'''
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-assembly-schema.EndpointServiceAvailabilityZonesContextQuery",
jsii_struct_bases=[],
name_mapping={
"account": "account",
"region": "region",
"service_name": "serviceName",
},
)
class EndpointServiceAvailabilityZonesContextQuery:
def __init__(
self,
*,
account: builtins.str,
region: builtins.str,
service_name: builtins.str,
) -> None:
'''Query to endpoint service context provider.
:param account: Query account.
:param region: Query region.
:param service_name: Query service name.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__a078309ccccfdfd1ee77a351debeb8fe6685655ce70244eee67dc0e18b60914d)
check_type(argname="argument account", value=account, expected_type=type_hints["account"])
check_type(argname="argument region", value=region, expected_type=type_hints["region"])
check_type(argname="argument service_name", value=service_name, expected_type=type_hints["service_name"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"account": account,
"region": region,
"service_name": service_name,
}
@builtins.property
def account(self) -> builtins.str:
'''Query account.'''
result = self._values.get("account")
assert result is not None, "Required property 'account' is missing"
return typing.cast(builtins.str, result)
@builtins.property
def region(self) -> builtins.str:
'''Query region.'''
result = self._values.get("region")
assert result is not None, "Required property 'region' is missing"
return typing.cast(builtins.str, result)
@builtins.property
def service_name(self) -> builtins.str:
'''Query service name.'''
result = self._values.get("service_name")
assert result is not None, "Required property 'service_name' is missing"
return typing.cast(builtins.str, result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "EndpointServiceAvailabilityZonesContextQuery(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-assembly-schema.HostedZoneContextQuery",
jsii_struct_bases=[],
name_mapping={
"account": "account",
"domain_name": "domainName",
"region": "region",
"private_zone": "privateZone",
"vpc_id": "vpcId",
},
)
class HostedZoneContextQuery:
def __init__(
self,
*,
account: builtins.str,
domain_name: builtins.str,
region: builtins.str,
private_zone: typing.Optional[builtins.bool] = None,
vpc_id: typing.Optional[builtins.str] = None,
) -> None:
'''Query to hosted zone context provider.
:param account: Query account.
:param domain_name: The domain name e.g. example.com to lookup.
:param region: Query region.
:param private_zone: True if the zone you want to find is a private hosted zone. Default: false
:param vpc_id: The VPC ID to that the private zone must be associated with. If you provide VPC ID and privateZone is false, this will return no results and raise an error. Default: - Required if privateZone=true
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__04d17b4b9ff55746c3bcd55def770548977d06817af547bba2a854fa19f03584)
check_type(argname="argument account", value=account, expected_type=type_hints["account"])
check_type(argname="argument domain_name", value=domain_name, expected_type=type_hints["domain_name"])
check_type(argname="argument region", value=region, expected_type=type_hints["region"])
check_type(argname="argument private_zone", value=private_zone, expected_type=type_hints["private_zone"])
check_type(argname="argument vpc_id", value=vpc_id, expected_type=type_hints["vpc_id"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"account": account,
"domain_name": domain_name,
"region": region,
}
if private_zone is not None:
self._values["private_zone"] = private_zone
if vpc_id is not None:
self._values["vpc_id"] = vpc_id
@builtins.property
def account(self) -> builtins.str:
'''Query account.'''
result = self._values.get("account")
assert result is not None, "Required property 'account' is missing"
return typing.cast(builtins.str, result)
@builtins.property
def domain_name(self) -> builtins.str:
'''The domain name e.g. example.com to lookup.'''
result = self._values.get("domain_name")
assert result is not None, "Required property 'domain_name' is missing"
return typing.cast(builtins.str, result)
@builtins.property
def region(self) -> builtins.str:
'''Query region.'''
result = self._values.get("region")
assert result is not None, "Required property 'region' is missing"
return typing.cast(builtins.str, result)
@builtins.property
def private_zone(self) -> typing.Optional[builtins.bool]:
'''True if the zone you want to find is a private hosted zone.
:default: false
'''
result = self._values.get("private_zone")
return typing.cast(typing.Optional[builtins.bool], result)
@builtins.property
def vpc_id(self) -> typing.Optional[builtins.str]:
'''The VPC ID to that the private zone must be associated with.
If you provide VPC ID and privateZone is false, this will return no results
and raise an error.
:default: - Required if privateZone=true
'''
result = self._values.get("vpc_id")
return typing.cast(typing.Optional[builtins.str], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "HostedZoneContextQuery(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class Manifest(
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-assembly-schema.Manifest",
):
'''Protocol utility class.'''
@jsii.member(jsii_name="load")
@builtins.classmethod
def load(cls, file_path: builtins.str) -> AssemblyManifest:
'''(deprecated) Deprecated.
:param file_path: -
:deprecated: use ``loadAssemblyManifest()``
:stability: deprecated
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__4420e1fb15ea773f97ce770a8940f33e8c3711b7430b0840422e0f5ab6ec6643)
check_type(argname="argument file_path", value=file_path, expected_type=type_hints["file_path"])
return typing.cast(AssemblyManifest, jsii.sinvoke(cls, "load", [file_path]))
@jsii.member(jsii_name="loadAssemblyManifest")
@builtins.classmethod
def load_assembly_manifest(cls, file_path: builtins.str) -> AssemblyManifest:
'''Load and validates the cloud assembly manifest from file.
:param file_path: - path to the manifest file.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__17c1b7476293f37e48eba72cfcad6b50e4f15bb6b2241cb555a0c48e55f9e946)
check_type(argname="argument file_path", value=file_path, expected_type=type_hints["file_path"])
return typing.cast(AssemblyManifest, jsii.sinvoke(cls, "loadAssemblyManifest", [file_path]))
@jsii.member(jsii_name="save")
@builtins.classmethod
def save(
cls,
manifest: typing.Union[AssemblyManifest, typing.Dict[builtins.str, typing.Any]],
file_path: builtins.str,
) -> None:
'''(deprecated) Deprecated.
:param manifest: -
:param file_path: -
:deprecated: use ``saveAssemblyManifest()``
:stability: deprecated
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__dd1fca2945793b04838a4a50a2995f16fc16a14004ac3e439e3718ee76d660b1)
check_type(argname="argument manifest", value=manifest, expected_type=type_hints["manifest"])
check_type(argname="argument file_path", value=file_path, expected_type=type_hints["file_path"])
return typing.cast(None, jsii.sinvoke(cls, "save", [manifest, file_path]))
@jsii.member(jsii_name="saveAssemblyManifest")
@builtins.classmethod
def save_assembly_manifest(
cls,
manifest: typing.Union[AssemblyManifest, typing.Dict[builtins.str, typing.Any]],
file_path: builtins.str,
) -> None:
'''Validates and saves the cloud assembly manifest to file.
:param manifest: - manifest.
:param file_path: - output file path.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__1b07952bceb7b5dbdad81bfbf6b876483f428fb8e4cc90dacd947272038ed2ef)
check_type(argname="argument manifest", value=manifest, expected_type=type_hints["manifest"])
check_type(argname="argument file_path", value=file_path, expected_type=type_hints["file_path"])
return typing.cast(None, jsii.sinvoke(cls, "saveAssemblyManifest", [manifest, file_path]))
@jsii.member(jsii_name="version")
@builtins.classmethod
def version(cls) -> builtins.str:
'''Fetch the current schema version number.'''
return typing.cast(builtins.str, jsii.sinvoke(cls, "version", []))
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-assembly-schema.MetadataEntry",
jsii_struct_bases=[],
name_mapping={"type": "type", "data": "data", "trace": "trace"},
)
class MetadataEntry:
def __init__(
self,
*,
type: builtins.str,
data: typing.Optional[typing.Union[builtins.str, typing.Sequence[typing.Union["Tag", typing.Dict[builtins.str, typing.Any]]]]] = None,
trace: typing.Optional[typing.Sequence[builtins.str]] = None,
) -> None:
'''A metadata entry in a cloud assembly artifact.
:param type: The type of the metadata entry.
:param data: The data. Default: - no data.
:param trace: A stack trace for when the entry was created. Default: - no trace.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__3019f66821df35df8528c8c05491120941f8ea312aac91790b449549012331d1)
check_type(argname="argument type", value=type, expected_type=type_hints["type"])
check_type(argname="argument data", value=data, expected_type=type_hints["data"])
check_type(argname="argument trace", value=trace, expected_type=type_hints["trace"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"type": type,
}
if data is not None:
self._values["data"] = data
if trace is not None:
self._values["trace"] = trace
@builtins.property
def type(self) -> builtins.str:
'''The type of the metadata entry.'''
result = self._values.get("type")
assert result is not None, "Required property 'type' is missing"
return typing.cast(builtins.str, result)
@builtins.property
def data(self) -> typing.Optional[typing.Union[builtins.str, typing.List["Tag"]]]:
'''The data.
:default: - no data.
'''
result = self._values.get("data")
return typing.cast(typing.Optional[typing.Union[builtins.str, typing.List["Tag"]]], result)
@builtins.property
def trace(self) -> typing.Optional[typing.List[builtins.str]]:
'''A stack trace for when the entry was created.
:default: - no trace.
'''
result = self._values.get("trace")
return typing.cast(typing.Optional[typing.List[builtins.str]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "MetadataEntry(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-assembly-schema.MissingContext",
jsii_struct_bases=[],
name_mapping={"key": "key", "props": "props", "provider": "provider"},
)
class MissingContext:
def __init__(
self,
*,
key: builtins.str,
props: typing.Union[typing.Union[AmiContextQuery, typing.Dict[builtins.str, typing.Any]], typing.Union[AvailabilityZonesContextQuery, typing.Dict[builtins.str, typing.Any]], typing.Union[HostedZoneContextQuery, typing.Dict[builtins.str, typing.Any]], typing.Union["SSMParameterContextQuery", typing.Dict[builtins.str, typing.Any]], typing.Union["VpcContextQuery", typing.Dict[builtins.str, typing.Any]], typing.Union[EndpointServiceAvailabilityZonesContextQuery, typing.Dict[builtins.str, typing.Any]]],
provider: ContextProvider,
) -> None:
'''Represents a missing piece of context.
:param key: The missing context key.
:param props: A set of provider-specific options.
:param provider: The provider from which we expect this context key to be obtained.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__cd208c8ef5bda641b030f2924e2a6961d665850446cf2b575436ba665db0842a)
check_type(argname="argument key", value=key, expected_type=type_hints["key"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument provider", value=provider, expected_type=type_hints["provider"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"key": key,
"props": props,
"provider": provider,
}
@builtins.property
def key(self) -> builtins.str:
'''The missing context key.'''
result = self._values.get("key")
assert result is not None, "Required property 'key' is missing"
return typing.cast(builtins.str, result)
@builtins.property
def props(
self,
) -> typing.Union[AmiContextQuery, AvailabilityZonesContextQuery, HostedZoneContextQuery, "SSMParameterContextQuery", "VpcContextQuery", EndpointServiceAvailabilityZonesContextQuery]:
'''A set of provider-specific options.'''
result = self._values.get("props")
assert result is not None, "Required property 'props' is missing"
return typing.cast(typing.Union[AmiContextQuery, AvailabilityZonesContextQuery, HostedZoneContextQuery, "SSMParameterContextQuery", "VpcContextQuery", EndpointServiceAvailabilityZonesContextQuery], result)
@builtins.property
def provider(self) -> ContextProvider:
'''The provider from which we expect this context key to be obtained.'''
result = self._values.get("provider")
assert result is not None, "Required property 'provider' is missing"
return typing.cast(ContextProvider, result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "MissingContext(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-assembly-schema.NestedCloudAssemblyProperties",
jsii_struct_bases=[],
name_mapping={"directory_name": "directoryName", "display_name": "displayName"},
)
class NestedCloudAssemblyProperties:
def __init__(
self,
*,
directory_name: builtins.str,
display_name: typing.Optional[builtins.str] = None,
) -> None:
'''Artifact properties for nested cloud assemblies.
:param directory_name: Relative path to the nested cloud assembly.
:param display_name: Display name for the cloud assembly. Default: - The artifact ID
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__bfa16176adeadd12b83b59121710d14bc1c3b6815c3542e63501e57721b229ce)
check_type(argname="argument directory_name", value=directory_name, expected_type=type_hints["directory_name"])
check_type(argname="argument display_name", value=display_name, expected_type=type_hints["display_name"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"directory_name": directory_name,
}
if display_name is not None:
self._values["display_name"] = display_name
@builtins.property
def directory_name(self) -> builtins.str:
'''Relative path to the nested cloud assembly.'''
result = self._values.get("directory_name")
assert result is not None, "Required property 'directory_name' is missing"
return typing.cast(builtins.str, result)
@builtins.property
def display_name(self) -> typing.Optional[builtins.str]:
'''Display name for the cloud assembly.
:default: - The artifact ID
'''
result = self._values.get("display_name")
return typing.cast(typing.Optional[builtins.str], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "NestedCloudAssemblyProperties(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-assembly-schema.RuntimeInfo",
jsii_struct_bases=[],
name_mapping={"libraries": "libraries"},
)
class RuntimeInfo:
def __init__(
self,
*,
libraries: typing.Mapping[builtins.str, builtins.str],
) -> None:
'''Information about the application's runtime components.
:param libraries: The list of libraries loaded in the application, associated with their versions.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__b9c8536bbfca4e3700cf843c7f2382568dd7ce259dbe2cbd93e61074e87ab48f)
check_type(argname="argument libraries", value=libraries, expected_type=type_hints["libraries"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"libraries": libraries,
}
@builtins.property
def libraries(self) -> typing.Mapping[builtins.str, builtins.str]:
'''The list of libraries loaded in the application, associated with their versions.'''
result = self._values.get("libraries")
assert result is not None, "Required property 'libraries' is missing"
return typing.cast(typing.Mapping[builtins.str, builtins.str], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "RuntimeInfo(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-assembly-schema.SSMParameterContextQuery",
jsii_struct_bases=[],
name_mapping={
"account": "account",
"parameter_name": "parameterName",
"region": "region",
},
)
class SSMParameterContextQuery:
def __init__(
self,
*,
account: builtins.str,
parameter_name: builtins.str,
region: builtins.str,
) -> None:
'''Query to SSM Parameter Context Provider.
:param account: Query account.
:param parameter_name: Parameter name to query.
:param region: Query region.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__67b5a36a6922de48a7b300011d383adbc506ec15c6bb7cd6aec32e3614f52477)
check_type(argname="argument account", value=account, expected_type=type_hints["account"])
check_type(argname="argument parameter_name", value=parameter_name, expected_type=type_hints["parameter_name"])
check_type(argname="argument region", value=region, expected_type=type_hints["region"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"account": account,
"parameter_name": parameter_name,
"region": region,
}
@builtins.property
def account(self) -> builtins.str:
'''Query account.'''
result = self._values.get("account")
assert result is not None, "Required property 'account' is missing"
return typing.cast(builtins.str, result)
@builtins.property
def parameter_name(self) -> builtins.str:
'''Parameter name to query.'''
result = self._values.get("parameter_name")
assert result is not None, "Required property 'parameter_name' is missing"
return typing.cast(builtins.str, result)
@builtins.property
def region(self) -> builtins.str:
'''Query region.'''
result = self._values.get("region")
assert result is not None, "Required property 'region' is missing"
return typing.cast(builtins.str, result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "SSMParameterContextQuery(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-assembly-schema.Tag",
jsii_struct_bases=[],
name_mapping={"key": "key", "value": "value"},
)
class Tag:
def __init__(self, *, key: builtins.str, value: builtins.str) -> None:
'''Metadata Entry spec for stack tag.
:param key: Tag key.
:param value: Tag value.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__a29ec2f54aa330d0f09779198bd6fb009ae14982497dcd42a9093f160c08173d)
check_type(argname="argument key", value=key, expected_type=type_hints["key"])
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"key": key,
"value": value,
}
@builtins.property
def key(self) -> builtins.str:
'''Tag key.'''
result = self._values.get("key")
assert result is not None, "Required property 'key' is missing"
return typing.cast(builtins.str, result)
@builtins.property
def value(self) -> builtins.str:
'''Tag value.'''
result = self._values.get("value")
assert result is not None, "Required property 'value' is missing"
return typing.cast(builtins.str, result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "Tag(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-assembly-schema.TreeArtifactProperties",
jsii_struct_bases=[],
name_mapping={"file": "file"},
)
class TreeArtifactProperties:
def __init__(self, *, file: builtins.str) -> None:
'''Artifact properties for the Construct Tree Artifact.
:param file: Filename of the tree artifact.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__c9b3874b02e6b59d07063e4307b8e38df0808c88c5a641829f794e1ceede1933)
check_type(argname="argument file", value=file, expected_type=type_hints["file"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"file": file,
}
@builtins.property
def file(self) -> builtins.str:
'''Filename of the tree artifact.'''
result = self._values.get("file")
assert result is not None, "Required property 'file' is missing"
return typing.cast(builtins.str, result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "TreeArtifactProperties(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-assembly-schema.VpcContextQuery",
jsii_struct_bases=[],
name_mapping={
"account": "account",
"filter": "filter",
"region": "region",
"return_asymmetric_subnets": "returnAsymmetricSubnets",
"subnet_group_name_tag": "subnetGroupNameTag",
},
)
class VpcContextQuery:
def __init__(
self,
*,
account: builtins.str,
filter: typing.Mapping[builtins.str, builtins.str],
region: builtins.str,
return_asymmetric_subnets: typing.Optional[builtins.bool] = None,
subnet_group_name_tag: typing.Optional[builtins.str] = None,
) -> None:
'''Query input for looking up a VPC.
:param account: Query account.
:param filter: Filters to apply to the VPC. Filter parameters are the same as passed to DescribeVpcs.
:param region: Query region.
:param return_asymmetric_subnets: Whether to populate the subnetGroups field of the {@link VpcContextResponse}, which contains potentially asymmetric subnet groups. Default: false
:param subnet_group_name_tag: Optional tag for subnet group name. If not provided, we'll look at the ros-cdk:subnet-name tag. If the subnet does not have the specified tag, we'll use its type as the name. Default: 'ros-cdk:subnet-name'
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__ecf79a3d9511e8c24f1f7fb3852689dd1fbf7976dcee2b048887b0491a8d7994)
check_type(argname="argument account", value=account, expected_type=type_hints["account"])
check_type(argname="argument filter", value=filter, expected_type=type_hints["filter"])
check_type(argname="argument region", value=region, expected_type=type_hints["region"])
check_type(argname="argument return_asymmetric_subnets", value=return_asymmetric_subnets, expected_type=type_hints["return_asymmetric_subnets"])
check_type(argname="argument subnet_group_name_tag", value=subnet_group_name_tag, expected_type=type_hints["subnet_group_name_tag"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"account": account,
"filter": filter,
"region": region,
}
if return_asymmetric_subnets is not None:
self._values["return_asymmetric_subnets"] = return_asymmetric_subnets
if subnet_group_name_tag is not None:
self._values["subnet_group_name_tag"] = subnet_group_name_tag
@builtins.property
def account(self) -> builtins.str:
'''Query account.'''
result = self._values.get("account")
assert result is not None, "Required property 'account' is missing"
return typing.cast(builtins.str, result)
@builtins.property
def filter(self) -> typing.Mapping[builtins.str, builtins.str]:
'''Filters to apply to the VPC.
Filter parameters are the same as passed to DescribeVpcs.
'''
result = self._values.get("filter")
assert result is not None, "Required property 'filter' is missing"
return typing.cast(typing.Mapping[builtins.str, builtins.str], result)
@builtins.property
def region(self) -> builtins.str:
'''Query region.'''
result = self._values.get("region")
assert result is not None, "Required property 'region' is missing"
return typing.cast(builtins.str, result)
@builtins.property
def return_asymmetric_subnets(self) -> typing.Optional[builtins.bool]:
'''Whether to populate the subnetGroups field of the {@link VpcContextResponse}, which contains potentially asymmetric subnet groups.
:default: false
'''
result = self._values.get("return_asymmetric_subnets")
return typing.cast(typing.Optional[builtins.bool], result)
@builtins.property
def subnet_group_name_tag(self) -> typing.Optional[builtins.str]:
'''Optional tag for subnet group name.
If not provided, we'll look at the ros-cdk:subnet-name tag.
If the subnet does not have the specified tag,
we'll use its type as the name.
:default: 'ros-cdk:subnet-name'
'''
result = self._values.get("subnet_group_name_tag")
return typing.cast(typing.Optional[builtins.str], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "VpcContextQuery(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
__all__ = [
"AliyunRosStackProperties",
"AmiContextQuery",
"ArtifactManifest",
"ArtifactMetadataEntryType",
"ArtifactType",
"AssemblyManifest",
"AvailabilityZonesContextQuery",
"ContextProvider",
"EndpointServiceAvailabilityZonesContextQuery",
"HostedZoneContextQuery",
"Manifest",
"MetadataEntry",
"MissingContext",
"NestedCloudAssemblyProperties",
"RuntimeInfo",
"SSMParameterContextQuery",
"Tag",
"TreeArtifactProperties",
"VpcContextQuery",
]
publication.publish()
def _typecheckingstub__50db4a4408e92654c48d87ed0677ec40f604c7be253310fca5ce2f70f07f8b10(
*,
template_file: builtins.str,
parameters: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
stack_name: typing.Optional[builtins.str] = None,
tags: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__4da5c94286713a25f11bbf84fc0fa807019391853bda290dd844c4f8f34e8978(
*,
account: builtins.str,
filters: typing.Mapping[builtins.str, typing.Sequence[builtins.str]],
region: builtins.str,
owners: typing.Optional[typing.Sequence[builtins.str]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__b23c064aa8a7a12940601a4c031f5909112530123fae3b281b473992e6c98422(
*,
type: ArtifactType,
dependencies: typing.Optional[typing.Sequence[builtins.str]] = None,
metadata: typing.Optional[typing.Mapping[builtins.str, typing.Sequence[typing.Union[MetadataEntry, typing.Dict[builtins.str, typing.Any]]]]] = None,
properties: typing.Optional[typing.Union[typing.Union[AliyunRosStackProperties, typing.Dict[builtins.str, typing.Any]], typing.Union[TreeArtifactProperties, typing.Dict[builtins.str, typing.Any]], typing.Union[NestedCloudAssemblyProperties, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__b6b194e83c34230d0742619fe13b220ec6ccf3e707ed53bb1f8153e7fa375a5f(
*,
version: builtins.str,
artifacts: typing.Optional[typing.Mapping[builtins.str, typing.Union[ArtifactManifest, typing.Dict[builtins.str, typing.Any]]]] = None,
missing: typing.Optional[typing.Sequence[typing.Union[MissingContext, typing.Dict[builtins.str, typing.Any]]]] = None,
runtime: typing.Optional[typing.Union[RuntimeInfo, typing.Dict[builtins.str, typing.Any]]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__85e5f6837358a10c72d3f9dd17a950563028b27c1bf2cd274fb3941b7a77f604(
*,
account: builtins.str,
region: builtins.str,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__a078309ccccfdfd1ee77a351debeb8fe6685655ce70244eee67dc0e18b60914d(
*,
account: builtins.str,
region: builtins.str,
service_name: builtins.str,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__04d17b4b9ff55746c3bcd55def770548977d06817af547bba2a854fa19f03584(
*,
account: builtins.str,
domain_name: builtins.str,
region: builtins.str,
private_zone: typing.Optional[builtins.bool] = None,
vpc_id: typing.Optional[builtins.str] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__4420e1fb15ea773f97ce770a8940f33e8c3711b7430b0840422e0f5ab6ec6643(
file_path: builtins.str,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__17c1b7476293f37e48eba72cfcad6b50e4f15bb6b2241cb555a0c48e55f9e946(
file_path: builtins.str,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__dd1fca2945793b04838a4a50a2995f16fc16a14004ac3e439e3718ee76d660b1(
manifest: typing.Union[AssemblyManifest, typing.Dict[builtins.str, typing.Any]],
file_path: builtins.str,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__1b07952bceb7b5dbdad81bfbf6b876483f428fb8e4cc90dacd947272038ed2ef(
manifest: typing.Union[AssemblyManifest, typing.Dict[builtins.str, typing.Any]],
file_path: builtins.str,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__3019f66821df35df8528c8c05491120941f8ea312aac91790b449549012331d1(
*,
type: builtins.str,
data: typing.Optional[typing.Union[builtins.str, typing.Sequence[typing.Union[Tag, typing.Dict[builtins.str, typing.Any]]]]] = None,
trace: typing.Optional[typing.Sequence[builtins.str]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__cd208c8ef5bda641b030f2924e2a6961d665850446cf2b575436ba665db0842a(
*,
key: builtins.str,
props: typing.Union[typing.Union[AmiContextQuery, typing.Dict[builtins.str, typing.Any]], typing.Union[AvailabilityZonesContextQuery, typing.Dict[builtins.str, typing.Any]], typing.Union[HostedZoneContextQuery, typing.Dict[builtins.str, typing.Any]], typing.Union[SSMParameterContextQuery, typing.Dict[builtins.str, typing.Any]], typing.Union[VpcContextQuery, typing.Dict[builtins.str, typing.Any]], typing.Union[EndpointServiceAvailabilityZonesContextQuery, typing.Dict[builtins.str, typing.Any]]],
provider: ContextProvider,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__bfa16176adeadd12b83b59121710d14bc1c3b6815c3542e63501e57721b229ce(
*,
directory_name: builtins.str,
display_name: typing.Optional[builtins.str] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__b9c8536bbfca4e3700cf843c7f2382568dd7ce259dbe2cbd93e61074e87ab48f(
*,
libraries: typing.Mapping[builtins.str, builtins.str],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__67b5a36a6922de48a7b300011d383adbc506ec15c6bb7cd6aec32e3614f52477(
*,
account: builtins.str,
parameter_name: builtins.str,
region: builtins.str,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__a29ec2f54aa330d0f09779198bd6fb009ae14982497dcd42a9093f160c08173d(
*,
key: builtins.str,
value: builtins.str,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__c9b3874b02e6b59d07063e4307b8e38df0808c88c5a641829f794e1ceede1933(
*,
file: builtins.str,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__ecf79a3d9511e8c24f1f7fb3852689dd1fbf7976dcee2b048887b0491a8d7994(
*,
account: builtins.str,
filter: typing.Mapping[builtins.str, builtins.str],
region: builtins.str,
return_asymmetric_subnets: typing.Optional[builtins.bool] = None,
subnet_group_name_tag: typing.Optional[builtins.str] = None,
) -> None:
"""Type checking stubs"""
pass | /ros-cdk-assembly-schema-1.0.19.tar.gz/ros-cdk-assembly-schema-1.0.19/src/ros_cdk_assembly_schema/__init__.py | 0.680242 | 0.299779 | __init__.py | pypi |
import abc
import builtins
import datetime
import enum
import typing
import jsii
import publication
import typing_extensions
from typeguard import check_type
from ._jsii import *
import ros_cdk_core as _ros_cdk_core_7adfd82f
class ResourcePackage(
_ros_cdk_core_7adfd82f.Resource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-bss.ResourcePackage",
):
'''A ROS resource type: ``ALIYUN::BSS::ResourcePackage``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["ResourcePackageProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
'''Create a new ``ALIYUN::BSS::ResourcePackage``.
Param scope - scope in which this resource is defined
Param id - scoped id of the resource
Param props - resource properties
:param scope: -
:param id: -
:param props: -
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__4556252a24e6571d9038641222c679da064c616259b74a0623cbc1e989ed3e67)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@builtins.property
@jsii.member(jsii_name="attrInstanceId")
def attr_instance_id(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute InstanceId: The ID of the specified instance.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrInstanceId"))
@builtins.property
@jsii.member(jsii_name="attrOrderId")
def attr_order_id(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute OrderId: The ID of the specified order.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrOrderId"))
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-bss.ResourcePackageProps",
jsii_struct_bases=[],
name_mapping={
"duration": "duration",
"package_type": "packageType",
"product_code": "productCode",
"specification": "specification",
"effective_date": "effectiveDate",
"pricing_cycle": "pricingCycle",
},
)
class ResourcePackageProps:
def __init__(
self,
*,
duration: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
package_type: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
product_code: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
specification: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
effective_date: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
pricing_cycle: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::BSS::ResourcePackage``.
:param duration: Property duration: The validity of the specified resource package. The value is the same as the Value of AvailableDuration returned by DescribeResourcePackageProduct.
:param package_type: Property packageType: The type of the specified resource package. The value is the same as the value of the Code value of the ResourcePackage object returned by DescribeResourcePackageProduct.
:param product_code: Property productCode: The code of the specified product. The value is the same as the value of ProductType returned by QueryProductList.
:param specification: Property specification: The size of the specified resource package. The value is the same as the Value of Specification returned by DescribeResourcePackageProduct.
:param effective_date: Property effectiveDate: The effective date of the specified resource package. The resource package will take effect immediately if the effective date is unspecified. The date format follows the ISO8601 standard and uses UTC time. Format: yyyy-MM-ddTHH:mm:ssZ
:param pricing_cycle: Property pricingCycle: The validity of the specified resource package. Default value: Month. Valid values: Month, Year
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__d776edf40b265146361a737f36e012b290b731d353df3797b4c184228b9021c7)
check_type(argname="argument duration", value=duration, expected_type=type_hints["duration"])
check_type(argname="argument package_type", value=package_type, expected_type=type_hints["package_type"])
check_type(argname="argument product_code", value=product_code, expected_type=type_hints["product_code"])
check_type(argname="argument specification", value=specification, expected_type=type_hints["specification"])
check_type(argname="argument effective_date", value=effective_date, expected_type=type_hints["effective_date"])
check_type(argname="argument pricing_cycle", value=pricing_cycle, expected_type=type_hints["pricing_cycle"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"duration": duration,
"package_type": package_type,
"product_code": product_code,
"specification": specification,
}
if effective_date is not None:
self._values["effective_date"] = effective_date
if pricing_cycle is not None:
self._values["pricing_cycle"] = pricing_cycle
@builtins.property
def duration(self) -> typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property duration: The validity of the specified resource package.
The value is the same as the Value of AvailableDuration returned by DescribeResourcePackageProduct.
'''
result = self._values.get("duration")
assert result is not None, "Required property 'duration' is missing"
return typing.cast(typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def package_type(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property packageType: The type of the specified resource package.
The value is the same as the value of the Code value of the ResourcePackage object returned by DescribeResourcePackageProduct.
'''
result = self._values.get("package_type")
assert result is not None, "Required property 'package_type' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def product_code(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property productCode: The code of the specified product.
The value is the same as the value of ProductType returned by QueryProductList.
'''
result = self._values.get("product_code")
assert result is not None, "Required property 'product_code' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def specification(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property specification: The size of the specified resource package.
The value is the same as the Value of Specification returned by DescribeResourcePackageProduct.
'''
result = self._values.get("specification")
assert result is not None, "Required property 'specification' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def effective_date(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property effectiveDate: The effective date of the specified resource package.
The resource package will take effect immediately if the effective date is unspecified. The date format follows the ISO8601 standard and uses UTC time. Format: yyyy-MM-ddTHH:mm:ssZ
'''
result = self._values.get("effective_date")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def pricing_cycle(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property pricingCycle: The validity of the specified resource package.
Default value: Month. Valid values: Month, Year
'''
result = self._values.get("pricing_cycle")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "ResourcePackageProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class RosResourcePackage(
_ros_cdk_core_7adfd82f.RosResource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-bss.RosResourcePackage",
):
'''A ROS template type: ``ALIYUN::BSS::ResourcePackage``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["RosResourcePackageProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
'''Create a new ``ALIYUN::BSS::ResourcePackage``.
:param scope: - scope in which this resource is defined.
:param id: - scoped id of the resource.
:param props: - resource properties.
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__8abb9f6277a47b2064b4c71afd619eb4964c05ffb2545db77e9f49c5ccbc990b)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@jsii.member(jsii_name="renderProperties")
def _render_properties(
self,
props: typing.Mapping[builtins.str, typing.Any],
) -> typing.Mapping[builtins.str, typing.Any]:
'''
:param props: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__f3f3d5ccb39e39312e340535a4404e327e980ee11a6f91b1db24e5379976bc24)
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))
@jsii.python.classproperty
@jsii.member(jsii_name="ROS_RESOURCE_TYPE_NAME")
def ROS_RESOURCE_TYPE_NAME(cls) -> builtins.str:
'''The resource type name for this resource class.'''
return typing.cast(builtins.str, jsii.sget(cls, "ROS_RESOURCE_TYPE_NAME"))
@builtins.property
@jsii.member(jsii_name="attrInstanceId")
def attr_instance_id(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: InstanceId: The ID of the specified instance.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrInstanceId"))
@builtins.property
@jsii.member(jsii_name="attrOrderId")
def attr_order_id(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: OrderId: The ID of the specified order.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrOrderId"))
@builtins.property
@jsii.member(jsii_name="rosProperties")
def _ros_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "rosProperties"))
@builtins.property
@jsii.member(jsii_name="duration")
def duration(self) -> typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: duration: The validity of the specified resource package. The value is the same as the Value of AvailableDuration returned by DescribeResourcePackageProduct.
'''
return typing.cast(typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "duration"))
@duration.setter
def duration(
self,
value: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__d020f2dcb966b37d7b70468ceb1c7d2ee6a0fa784752efef932067a41a85a882)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "duration", value)
@builtins.property
@jsii.member(jsii_name="enableResourcePropertyConstraint")
def enable_resource_property_constraint(self) -> builtins.bool:
return typing.cast(builtins.bool, jsii.get(self, "enableResourcePropertyConstraint"))
@enable_resource_property_constraint.setter
def enable_resource_property_constraint(self, value: builtins.bool) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__190ad1893b74dd666cab266cb27eb1af42fe78bb72022f5599c5ef786c292b4d)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "enableResourcePropertyConstraint", value)
@builtins.property
@jsii.member(jsii_name="packageType")
def package_type(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: packageType: The type of the specified resource package. The value is the same as the value of the Code value of the ResourcePackage object returned by DescribeResourcePackageProduct.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "packageType"))
@package_type.setter
def package_type(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__924961f7f6a74a947cc6d1f457d285bce2f179f4e7395556e42912b0fb63583b)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "packageType", value)
@builtins.property
@jsii.member(jsii_name="productCode")
def product_code(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: productCode: The code of the specified product. The value is the same as the value of ProductType returned by QueryProductList.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "productCode"))
@product_code.setter
def product_code(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__c42494620bfdf8cbb1fbbdd4f3521876fd018de3dbdcf8c5397cfdfee2dcd109)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "productCode", value)
@builtins.property
@jsii.member(jsii_name="specification")
def specification(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: specification: The size of the specified resource package. The value is the same as the Value of Specification returned by DescribeResourcePackageProduct.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "specification"))
@specification.setter
def specification(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__d3f5bd2441faf37ff5ccd4c9e59948f4ed20f69455c48662908f6d82bf2a460a)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "specification", value)
@builtins.property
@jsii.member(jsii_name="effectiveDate")
def effective_date(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: effectiveDate: The effective date of the specified resource package. The resource package will take effect immediately if the effective date is unspecified. The date format follows the ISO8601 standard and uses UTC time. Format: yyyy-MM-ddTHH:mm:ssZ
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "effectiveDate"))
@effective_date.setter
def effective_date(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__50212e616c2d15b4159b54e7d6bcf3fb9b300048619ce809656307857c766cbc)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "effectiveDate", value)
@builtins.property
@jsii.member(jsii_name="pricingCycle")
def pricing_cycle(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: pricingCycle: The validity of the specified resource package. Default value: Month. Valid values: Month, Year
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "pricingCycle"))
@pricing_cycle.setter
def pricing_cycle(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__80eaf78e233c38d39adfdd58fcaf5b8169d3f425027325df5c418c2c80b781d3)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "pricingCycle", value)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-bss.RosResourcePackageProps",
jsii_struct_bases=[],
name_mapping={
"duration": "duration",
"package_type": "packageType",
"product_code": "productCode",
"specification": "specification",
"effective_date": "effectiveDate",
"pricing_cycle": "pricingCycle",
},
)
class RosResourcePackageProps:
def __init__(
self,
*,
duration: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
package_type: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
product_code: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
specification: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
effective_date: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
pricing_cycle: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::BSS::ResourcePackage``.
:param duration:
:param package_type:
:param product_code:
:param specification:
:param effective_date:
:param pricing_cycle:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__47b49e529d279e26202d69cef5aea2e98969d20331c8cc8eed68c6b2cfb9f531)
check_type(argname="argument duration", value=duration, expected_type=type_hints["duration"])
check_type(argname="argument package_type", value=package_type, expected_type=type_hints["package_type"])
check_type(argname="argument product_code", value=product_code, expected_type=type_hints["product_code"])
check_type(argname="argument specification", value=specification, expected_type=type_hints["specification"])
check_type(argname="argument effective_date", value=effective_date, expected_type=type_hints["effective_date"])
check_type(argname="argument pricing_cycle", value=pricing_cycle, expected_type=type_hints["pricing_cycle"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"duration": duration,
"package_type": package_type,
"product_code": product_code,
"specification": specification,
}
if effective_date is not None:
self._values["effective_date"] = effective_date
if pricing_cycle is not None:
self._values["pricing_cycle"] = pricing_cycle
@builtins.property
def duration(self) -> typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: duration: The validity of the specified resource package. The value is the same as the Value of AvailableDuration returned by DescribeResourcePackageProduct.
'''
result = self._values.get("duration")
assert result is not None, "Required property 'duration' is missing"
return typing.cast(typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def package_type(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: packageType: The type of the specified resource package. The value is the same as the value of the Code value of the ResourcePackage object returned by DescribeResourcePackageProduct.
'''
result = self._values.get("package_type")
assert result is not None, "Required property 'package_type' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def product_code(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: productCode: The code of the specified product. The value is the same as the value of ProductType returned by QueryProductList.
'''
result = self._values.get("product_code")
assert result is not None, "Required property 'product_code' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def specification(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: specification: The size of the specified resource package. The value is the same as the Value of Specification returned by DescribeResourcePackageProduct.
'''
result = self._values.get("specification")
assert result is not None, "Required property 'specification' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def effective_date(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: effectiveDate: The effective date of the specified resource package. The resource package will take effect immediately if the effective date is unspecified. The date format follows the ISO8601 standard and uses UTC time. Format: yyyy-MM-ddTHH:mm:ssZ
'''
result = self._values.get("effective_date")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def pricing_cycle(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: pricingCycle: The validity of the specified resource package. Default value: Month. Valid values: Month, Year
'''
result = self._values.get("pricing_cycle")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "RosResourcePackageProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class RosWaitOrder(
_ros_cdk_core_7adfd82f.RosResource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-bss.RosWaitOrder",
):
'''A ROS template type: ``ALIYUN::BSS::WaitOrder``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["RosWaitOrderProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
'''Create a new ``ALIYUN::BSS::WaitOrder``.
:param scope: - scope in which this resource is defined.
:param id: - scoped id of the resource.
:param props: - resource properties.
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__a8edf84f8e46e1eb3f1bd5b23cf812f310dc97832e781d497fa52ed925359375)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@jsii.member(jsii_name="renderProperties")
def _render_properties(
self,
props: typing.Mapping[builtins.str, typing.Any],
) -> typing.Mapping[builtins.str, typing.Any]:
'''
:param props: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__b4053cc7d534107f4a44271c004627de4e91c0a3930d927df3b115ff096633db)
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))
@jsii.python.classproperty
@jsii.member(jsii_name="ROS_RESOURCE_TYPE_NAME")
def ROS_RESOURCE_TYPE_NAME(cls) -> builtins.str:
'''The resource type name for this resource class.'''
return typing.cast(builtins.str, jsii.sget(cls, "ROS_RESOURCE_TYPE_NAME"))
@builtins.property
@jsii.member(jsii_name="rosProperties")
def _ros_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "rosProperties"))
@builtins.property
@jsii.member(jsii_name="enableResourcePropertyConstraint")
def enable_resource_property_constraint(self) -> builtins.bool:
'''A factory method that creates a new instance of this class from an object containing the properties of this ROS resource.'''
return typing.cast(builtins.bool, jsii.get(self, "enableResourcePropertyConstraint"))
@enable_resource_property_constraint.setter
def enable_resource_property_constraint(self, value: builtins.bool) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__76f9a760688b347cc614f6090665a9653069a5e745b5af877ae7ebed4146f7ba)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "enableResourcePropertyConstraint", value)
@builtins.property
@jsii.member(jsii_name="orderIds")
def order_ids(
self,
) -> typing.Union[typing.List[typing.Any], _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: orderIds: A list of order ids.
'''
return typing.cast(typing.Union[typing.List[typing.Any], _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "orderIds"))
@order_ids.setter
def order_ids(
self,
value: typing.Union[typing.List[typing.Any], _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__1d355df593fe7895ebb5aa6a565bdc20a500e6d7f72ab87c1c687ead1b3c6957)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "orderIds", value)
@builtins.property
@jsii.member(jsii_name="cancelOnDelete")
def cancel_on_delete(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: cancelOnDelete: Cancel order where delete the resource. Ignore the paid order. Default true
'''
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "cancelOnDelete"))
@cancel_on_delete.setter
def cancel_on_delete(
self,
value: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__1ecbe5a4061946d85b832ce5cfcd4b78f289267ee502d79749734c447528d72d)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "cancelOnDelete", value)
@builtins.property
@jsii.member(jsii_name="waitForOrderProduced")
def wait_for_order_produced(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
waitForOrderProduced: Wait util all orders related ROS resources are produced.
Support ALIYUN::ECS::PrepayInstance, ALIYUN::RDS::PrepayDBInstance, ALIYUN::REDIS::PrepayInstance, ALIYUN::SLB::LoadBalancer, ALIYUN::VPC::EIP, ALIYUN::VPC::VpnGateway.
'''
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "waitForOrderProduced"))
@wait_for_order_produced.setter
def wait_for_order_produced(
self,
value: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__fa80ee8ae3d4804d4fd278b62c4066671b3b6ec1403358b8b0818c7f81ca122c)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "waitForOrderProduced", value)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-bss.RosWaitOrderProps",
jsii_struct_bases=[],
name_mapping={
"order_ids": "orderIds",
"cancel_on_delete": "cancelOnDelete",
"wait_for_order_produced": "waitForOrderProduced",
},
)
class RosWaitOrderProps:
def __init__(
self,
*,
order_ids: typing.Union[typing.Sequence[typing.Any], _ros_cdk_core_7adfd82f.IResolvable],
cancel_on_delete: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
wait_for_order_produced: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::BSS::WaitOrder``.
:param order_ids:
:param cancel_on_delete:
:param wait_for_order_produced:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__4b09626cb3bccbdcb4a77f4417c88b7b8393c27a2781b96dc4867b16778597e2)
check_type(argname="argument order_ids", value=order_ids, expected_type=type_hints["order_ids"])
check_type(argname="argument cancel_on_delete", value=cancel_on_delete, expected_type=type_hints["cancel_on_delete"])
check_type(argname="argument wait_for_order_produced", value=wait_for_order_produced, expected_type=type_hints["wait_for_order_produced"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"order_ids": order_ids,
}
if cancel_on_delete is not None:
self._values["cancel_on_delete"] = cancel_on_delete
if wait_for_order_produced is not None:
self._values["wait_for_order_produced"] = wait_for_order_produced
@builtins.property
def order_ids(
self,
) -> typing.Union[typing.List[typing.Any], _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: orderIds: A list of order ids.
'''
result = self._values.get("order_ids")
assert result is not None, "Required property 'order_ids' is missing"
return typing.cast(typing.Union[typing.List[typing.Any], _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def cancel_on_delete(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: cancelOnDelete: Cancel order where delete the resource. Ignore the paid order. Default true
'''
result = self._values.get("cancel_on_delete")
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def wait_for_order_produced(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
waitForOrderProduced: Wait util all orders related ROS resources are produced.
Support ALIYUN::ECS::PrepayInstance, ALIYUN::RDS::PrepayDBInstance, ALIYUN::REDIS::PrepayInstance, ALIYUN::SLB::LoadBalancer, ALIYUN::VPC::EIP, ALIYUN::VPC::VpnGateway.
'''
result = self._values.get("wait_for_order_produced")
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "RosWaitOrderProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class WaitOrder(
_ros_cdk_core_7adfd82f.Resource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-bss.WaitOrder",
):
'''A ROS resource type: ``ALIYUN::BSS::WaitOrder``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["WaitOrderProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
'''Create a new ``ALIYUN::BSS::WaitOrder``.
Param scope - scope in which this resource is defined
Param id - scoped id of the resource
Param props - resource properties
:param scope: -
:param id: -
:param props: -
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__53486ba28136b5e5d82ed7073e44c0c7e3cfef2ca6533d0d717ee0d3dc41d28c)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-bss.WaitOrderProps",
jsii_struct_bases=[],
name_mapping={
"order_ids": "orderIds",
"cancel_on_delete": "cancelOnDelete",
"wait_for_order_produced": "waitForOrderProduced",
},
)
class WaitOrderProps:
def __init__(
self,
*,
order_ids: typing.Union[typing.Sequence[typing.Any], _ros_cdk_core_7adfd82f.IResolvable],
cancel_on_delete: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
wait_for_order_produced: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::BSS::WaitOrder``.
:param order_ids: Property orderIds: A list of order ids.
:param cancel_on_delete: Property cancelOnDelete: Cancel order where delete the resource. Ignore the paid order. Default true
:param wait_for_order_produced: Property waitForOrderProduced: Wait util all orders related ROS resources are produced. Support ALIYUN::ECS::PrepayInstance, ALIYUN::RDS::PrepayDBInstance, ALIYUN::REDIS::PrepayInstance, ALIYUN::SLB::LoadBalancer, ALIYUN::VPC::EIP, ALIYUN::VPC::VpnGateway.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__8f117bc8c7a25c09f00d0e1fd5d7ed40e3a161e66949f35f571df5ec5951db5e)
check_type(argname="argument order_ids", value=order_ids, expected_type=type_hints["order_ids"])
check_type(argname="argument cancel_on_delete", value=cancel_on_delete, expected_type=type_hints["cancel_on_delete"])
check_type(argname="argument wait_for_order_produced", value=wait_for_order_produced, expected_type=type_hints["wait_for_order_produced"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"order_ids": order_ids,
}
if cancel_on_delete is not None:
self._values["cancel_on_delete"] = cancel_on_delete
if wait_for_order_produced is not None:
self._values["wait_for_order_produced"] = wait_for_order_produced
@builtins.property
def order_ids(
self,
) -> typing.Union[typing.List[typing.Any], _ros_cdk_core_7adfd82f.IResolvable]:
'''Property orderIds: A list of order ids.'''
result = self._values.get("order_ids")
assert result is not None, "Required property 'order_ids' is missing"
return typing.cast(typing.Union[typing.List[typing.Any], _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def cancel_on_delete(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property cancelOnDelete: Cancel order where delete the resource.
Ignore the paid order. Default true
'''
result = self._values.get("cancel_on_delete")
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def wait_for_order_produced(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property waitForOrderProduced: Wait util all orders related ROS resources are produced.
Support ALIYUN::ECS::PrepayInstance, ALIYUN::RDS::PrepayDBInstance, ALIYUN::REDIS::PrepayInstance, ALIYUN::SLB::LoadBalancer, ALIYUN::VPC::EIP, ALIYUN::VPC::VpnGateway.
'''
result = self._values.get("wait_for_order_produced")
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "WaitOrderProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
__all__ = [
"ResourcePackage",
"ResourcePackageProps",
"RosResourcePackage",
"RosResourcePackageProps",
"RosWaitOrder",
"RosWaitOrderProps",
"WaitOrder",
"WaitOrderProps",
]
publication.publish()
def _typecheckingstub__4556252a24e6571d9038641222c679da064c616259b74a0623cbc1e989ed3e67(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[ResourcePackageProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__d776edf40b265146361a737f36e012b290b731d353df3797b4c184228b9021c7(
*,
duration: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
package_type: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
product_code: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
specification: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
effective_date: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
pricing_cycle: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__8abb9f6277a47b2064b4c71afd619eb4964c05ffb2545db77e9f49c5ccbc990b(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[RosResourcePackageProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__f3f3d5ccb39e39312e340535a4404e327e980ee11a6f91b1db24e5379976bc24(
props: typing.Mapping[builtins.str, typing.Any],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__d020f2dcb966b37d7b70468ceb1c7d2ee6a0fa784752efef932067a41a85a882(
value: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__190ad1893b74dd666cab266cb27eb1af42fe78bb72022f5599c5ef786c292b4d(
value: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__924961f7f6a74a947cc6d1f457d285bce2f179f4e7395556e42912b0fb63583b(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__c42494620bfdf8cbb1fbbdd4f3521876fd018de3dbdcf8c5397cfdfee2dcd109(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__d3f5bd2441faf37ff5ccd4c9e59948f4ed20f69455c48662908f6d82bf2a460a(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__50212e616c2d15b4159b54e7d6bcf3fb9b300048619ce809656307857c766cbc(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__80eaf78e233c38d39adfdd58fcaf5b8169d3f425027325df5c418c2c80b781d3(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__47b49e529d279e26202d69cef5aea2e98969d20331c8cc8eed68c6b2cfb9f531(
*,
duration: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
package_type: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
product_code: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
specification: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
effective_date: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
pricing_cycle: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__a8edf84f8e46e1eb3f1bd5b23cf812f310dc97832e781d497fa52ed925359375(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[RosWaitOrderProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__b4053cc7d534107f4a44271c004627de4e91c0a3930d927df3b115ff096633db(
props: typing.Mapping[builtins.str, typing.Any],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__76f9a760688b347cc614f6090665a9653069a5e745b5af877ae7ebed4146f7ba(
value: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__1d355df593fe7895ebb5aa6a565bdc20a500e6d7f72ab87c1c687ead1b3c6957(
value: typing.Union[typing.List[typing.Any], _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__1ecbe5a4061946d85b832ce5cfcd4b78f289267ee502d79749734c447528d72d(
value: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__fa80ee8ae3d4804d4fd278b62c4066671b3b6ec1403358b8b0818c7f81ca122c(
value: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__4b09626cb3bccbdcb4a77f4417c88b7b8393c27a2781b96dc4867b16778597e2(
*,
order_ids: typing.Union[typing.Sequence[typing.Any], _ros_cdk_core_7adfd82f.IResolvable],
cancel_on_delete: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
wait_for_order_produced: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__53486ba28136b5e5d82ed7073e44c0c7e3cfef2ca6533d0d717ee0d3dc41d28c(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[WaitOrderProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__8f117bc8c7a25c09f00d0e1fd5d7ed40e3a161e66949f35f571df5ec5951db5e(
*,
order_ids: typing.Union[typing.Sequence[typing.Any], _ros_cdk_core_7adfd82f.IResolvable],
cancel_on_delete: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
wait_for_order_produced: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass | /ros-cdk-bss-1.0.17.tar.gz/ros-cdk-bss-1.0.17/src/ros_cdk_bss/__init__.py | 0.701917 | 0.196248 | __init__.py | pypi |
import abc
import builtins
import datetime
import enum
import typing
import jsii
import publication
import typing_extensions
from typeguard import check_type
from ._jsii import *
import ros_cdk_core as _ros_cdk_core_7adfd82f
class Certificate(
_ros_cdk_core_7adfd82f.Resource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-cas.Certificate",
):
'''A ROS resource type: ``ALIYUN::CAS::Certificate``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["CertificateProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
'''Create a new ``ALIYUN::CAS::Certificate``.
Param scope - scope in which this resource is defined
Param id - scoped id of the resource
Param props - resource properties
:param scope: -
:param id: -
:param props: -
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__b234d46789e8c2016fcf32b39f570e7d2a9ab6c0bd7e26c709d41b68738956a3)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@builtins.property
@jsii.member(jsii_name="attrCertId")
def attr_cert_id(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute CertId: Certificate ID.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrCertId"))
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-cas.CertificateProps",
jsii_struct_bases=[],
name_mapping={
"cert": "cert",
"key": "key",
"name": "name",
"lang": "lang",
"source_ip": "sourceIp",
},
)
class CertificateProps:
def __init__(
self,
*,
cert: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
key: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
lang: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
source_ip: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::CAS::Certificate``.
:param cert: Property cert: Specify the content of the certificate. To use the PEM encoding format.
:param key: Property key: Specify the certificate private key content. To use the PEM encoding format.
:param name: Property name: Custom certificate name. The certificate name under a user cannot be duplicated.
:param lang: Property lang: Specifies the language type for requesting and receiving messages.
:param source_ip: Property sourceIp: Specifies the source IP address of the request.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__07e0a2ae254f018b4c89dd3f7f79bcc2272bc543adacd01e9c591a9f9e589493)
check_type(argname="argument cert", value=cert, expected_type=type_hints["cert"])
check_type(argname="argument key", value=key, expected_type=type_hints["key"])
check_type(argname="argument name", value=name, expected_type=type_hints["name"])
check_type(argname="argument lang", value=lang, expected_type=type_hints["lang"])
check_type(argname="argument source_ip", value=source_ip, expected_type=type_hints["source_ip"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"cert": cert,
"key": key,
"name": name,
}
if lang is not None:
self._values["lang"] = lang
if source_ip is not None:
self._values["source_ip"] = source_ip
@builtins.property
def cert(self) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property cert: Specify the content of the certificate.
To use the PEM encoding format.
'''
result = self._values.get("cert")
assert result is not None, "Required property 'cert' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def key(self) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property key: Specify the certificate private key content.
To use the PEM encoding format.
'''
result = self._values.get("key")
assert result is not None, "Required property 'key' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def name(self) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property name: Custom certificate name.
The certificate name under a user cannot be duplicated.
'''
result = self._values.get("name")
assert result is not None, "Required property 'name' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def lang(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property lang: Specifies the language type for requesting and receiving messages.'''
result = self._values.get("lang")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def source_ip(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property sourceIp: Specifies the source IP address of the request.'''
result = self._values.get("source_ip")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "CertificateProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class RosCertificate(
_ros_cdk_core_7adfd82f.RosResource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-cas.RosCertificate",
):
'''A ROS template type: ``ALIYUN::CAS::Certificate``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["RosCertificateProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
'''Create a new ``ALIYUN::CAS::Certificate``.
:param scope: - scope in which this resource is defined.
:param id: - scoped id of the resource.
:param props: - resource properties.
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__8810f552d9ea1a7b2e94b1f7b6e7382fee697cf796c7ca9dd1b936f486b6dcbc)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@jsii.member(jsii_name="renderProperties")
def _render_properties(
self,
props: typing.Mapping[builtins.str, typing.Any],
) -> typing.Mapping[builtins.str, typing.Any]:
'''
:param props: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__536b746d585cb4253afbf99ba729eea3b43a4cfe97ab1df64168beda75a14a53)
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))
@jsii.python.classproperty
@jsii.member(jsii_name="ROS_RESOURCE_TYPE_NAME")
def ROS_RESOURCE_TYPE_NAME(cls) -> builtins.str:
'''The resource type name for this resource class.'''
return typing.cast(builtins.str, jsii.sget(cls, "ROS_RESOURCE_TYPE_NAME"))
@builtins.property
@jsii.member(jsii_name="attrCertId")
def attr_cert_id(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: CertId: Certificate ID.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrCertId"))
@builtins.property
@jsii.member(jsii_name="rosProperties")
def _ros_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "rosProperties"))
@builtins.property
@jsii.member(jsii_name="cert")
def cert(self) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: cert: Specify the content of the certificate. To use the PEM encoding format.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "cert"))
@cert.setter
def cert(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__f2354cf030ed10aa7c0accbe6ddec0c6e653f40430c22226c0f125318742b45b)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "cert", value)
@builtins.property
@jsii.member(jsii_name="enableResourcePropertyConstraint")
def enable_resource_property_constraint(self) -> builtins.bool:
return typing.cast(builtins.bool, jsii.get(self, "enableResourcePropertyConstraint"))
@enable_resource_property_constraint.setter
def enable_resource_property_constraint(self, value: builtins.bool) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__71db2b31a9e51fe92b0cb684a0fb906fd653cbc00ccb08c09eb445a2a4b767a4)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "enableResourcePropertyConstraint", value)
@builtins.property
@jsii.member(jsii_name="key")
def key(self) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: key: Specify the certificate private key content. To use the PEM encoding format.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "key"))
@key.setter
def key(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__d90d80db51c7504011d35ce24be1b5c0fed275078cf00686bcf3005c94217c59)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "key", value)
@builtins.property
@jsii.member(jsii_name="name")
def name(self) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: name: Custom certificate name. The certificate name under a user cannot be duplicated.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "name"))
@name.setter
def name(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__84c67126c949c0a38caf260021375fbb5ea65427af261cb29eafdcb2a182c9af)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "name", value)
@builtins.property
@jsii.member(jsii_name="lang")
def lang(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: lang: Specifies the language type for requesting and receiving messages.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "lang"))
@lang.setter
def lang(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__2b80787f6c95cde7755ed275da224e1264dfb3f62abe3b73e984f1d9f240ba2f)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "lang", value)
@builtins.property
@jsii.member(jsii_name="sourceIp")
def source_ip(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: sourceIp: Specifies the source IP address of the request.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "sourceIp"))
@source_ip.setter
def source_ip(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__67a982d45319e32cd72f9f23c0ced9265141968b5f935eb4ac8e8a97e1f46cf6)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "sourceIp", value)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-cas.RosCertificateProps",
jsii_struct_bases=[],
name_mapping={
"cert": "cert",
"key": "key",
"name": "name",
"lang": "lang",
"source_ip": "sourceIp",
},
)
class RosCertificateProps:
def __init__(
self,
*,
cert: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
key: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
lang: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
source_ip: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::CAS::Certificate``.
:param cert:
:param key:
:param name:
:param lang:
:param source_ip:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__5ff148f63432986b50f253a72db70c1105e107f3da35b2b6ff541dfd30de675e)
check_type(argname="argument cert", value=cert, expected_type=type_hints["cert"])
check_type(argname="argument key", value=key, expected_type=type_hints["key"])
check_type(argname="argument name", value=name, expected_type=type_hints["name"])
check_type(argname="argument lang", value=lang, expected_type=type_hints["lang"])
check_type(argname="argument source_ip", value=source_ip, expected_type=type_hints["source_ip"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"cert": cert,
"key": key,
"name": name,
}
if lang is not None:
self._values["lang"] = lang
if source_ip is not None:
self._values["source_ip"] = source_ip
@builtins.property
def cert(self) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: cert: Specify the content of the certificate. To use the PEM encoding format.
'''
result = self._values.get("cert")
assert result is not None, "Required property 'cert' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def key(self) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: key: Specify the certificate private key content. To use the PEM encoding format.
'''
result = self._values.get("key")
assert result is not None, "Required property 'key' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def name(self) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: name: Custom certificate name. The certificate name under a user cannot be duplicated.
'''
result = self._values.get("name")
assert result is not None, "Required property 'name' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def lang(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: lang: Specifies the language type for requesting and receiving messages.
'''
result = self._values.get("lang")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def source_ip(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: sourceIp: Specifies the source IP address of the request.
'''
result = self._values.get("source_ip")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "RosCertificateProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
__all__ = [
"Certificate",
"CertificateProps",
"RosCertificate",
"RosCertificateProps",
]
publication.publish()
def _typecheckingstub__b234d46789e8c2016fcf32b39f570e7d2a9ab6c0bd7e26c709d41b68738956a3(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[CertificateProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__07e0a2ae254f018b4c89dd3f7f79bcc2272bc543adacd01e9c591a9f9e589493(
*,
cert: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
key: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
lang: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
source_ip: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__8810f552d9ea1a7b2e94b1f7b6e7382fee697cf796c7ca9dd1b936f486b6dcbc(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[RosCertificateProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__536b746d585cb4253afbf99ba729eea3b43a4cfe97ab1df64168beda75a14a53(
props: typing.Mapping[builtins.str, typing.Any],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__f2354cf030ed10aa7c0accbe6ddec0c6e653f40430c22226c0f125318742b45b(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__71db2b31a9e51fe92b0cb684a0fb906fd653cbc00ccb08c09eb445a2a4b767a4(
value: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__d90d80db51c7504011d35ce24be1b5c0fed275078cf00686bcf3005c94217c59(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__84c67126c949c0a38caf260021375fbb5ea65427af261cb29eafdcb2a182c9af(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__2b80787f6c95cde7755ed275da224e1264dfb3f62abe3b73e984f1d9f240ba2f(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__67a982d45319e32cd72f9f23c0ced9265141968b5f935eb4ac8e8a97e1f46cf6(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__5ff148f63432986b50f253a72db70c1105e107f3da35b2b6ff541dfd30de675e(
*,
cert: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
key: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
lang: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
source_ip: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass | /ros-cdk-cas-1.0.17.tar.gz/ros-cdk-cas-1.0.17/src/ros_cdk_cas/__init__.py | 0.651909 | 0.17266 | __init__.py | pypi |
import abc
import builtins
import datetime
import enum
import typing
import jsii
import publication
import typing_extensions
from typeguard import check_type
from ._jsii import *
import ros_cdk_core as _ros_cdk_core_7adfd82f
class Domain(
_ros_cdk_core_7adfd82f.Resource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-cdn.Domain",
):
'''A ROS resource type: ``ALIYUN::CDN::Domain``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["DomainProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
'''Create a new ``ALIYUN::CDN::Domain``.
Param scope - scope in which this resource is defined
Param id - scoped id of the resource
Param props - resource properties
:param scope: -
:param id: -
:param props: -
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__0a504257e802fc47414fd60396440a38b3d8189c7c8a055e12b18472b4c55304)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@builtins.property
@jsii.member(jsii_name="attrCname")
def attr_cname(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute Cname: The CNAME generated for the CDN domain.You must add a CNAME record with your DNS provider to map the CDN domain name to the CNAME.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrCname"))
@builtins.property
@jsii.member(jsii_name="attrDomainName")
def attr_domain_name(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute DomainName: The CDN domain name.
Wildcard domain names that start with periods (.) are supported. For example, .a.com.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrDomainName"))
class DomainConfig(
_ros_cdk_core_7adfd82f.Resource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-cdn.DomainConfig",
):
'''A ROS resource type: ``ALIYUN::CDN::DomainConfig``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["DomainConfigProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
'''Create a new ``ALIYUN::CDN::DomainConfig``.
Param scope - scope in which this resource is defined
Param id - scoped id of the resource
Param props - resource properties
:param scope: -
:param id: -
:param props: -
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__9d139905fcc664b63d2cff155fa704af5f61d6ebcc4806131782109feb8baef5)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-cdn.DomainConfigProps",
jsii_struct_bases=[],
name_mapping={"domain_names": "domainNames", "functions": "functions"},
)
class DomainConfigProps:
def __init__(
self,
*,
domain_names: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
functions: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
'''Properties for defining a ``ALIYUN::CDN::DomainConfig``.
:param domain_names: Property domainNames: Your accelerated domain name, separated by commas in English.
:param functions: Property functions: function list, please refer to the CDN documentation for details.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__8b24d05b17dce3dd66e25492982b9174726df2150f56400c0ff3f98b1647d6e2)
check_type(argname="argument domain_names", value=domain_names, expected_type=type_hints["domain_names"])
check_type(argname="argument functions", value=functions, expected_type=type_hints["functions"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"domain_names": domain_names,
"functions": functions,
}
@builtins.property
def domain_names(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property domainNames: Your accelerated domain name, separated by commas in English.'''
result = self._values.get("domain_names")
assert result is not None, "Required property 'domain_names' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def functions(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property functions: function list, please refer to the CDN documentation for details.'''
result = self._values.get("functions")
assert result is not None, "Required property 'functions' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "DomainConfigProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-cdn.DomainProps",
jsii_struct_bases=[],
name_mapping={
"cdn_type": "cdnType",
"domain_name": "domainName",
"check_url": "checkUrl",
"resource_group_id": "resourceGroupId",
"scope": "scope",
"sources": "sources",
"tags": "tags",
"top_level_domain": "topLevelDomain",
},
)
class DomainProps:
def __init__(
self,
*,
cdn_type: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
domain_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
check_url: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
resource_group_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
scope: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
sources: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
tags: typing.Optional[typing.Sequence[typing.Union["RosDomain.TagsProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
top_level_domain: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::CDN::Domain``.
:param cdn_type: Property cdnType: The business type. Valid values: web, download, video, livestream, and httpsdelivery. web: acceleration of images and small files download. download: acceleration of large file downloads. video: live streaming acceleration. httpsdelivery: SSL acceleration for HTTPS.
:param domain_name: Property domainName: The CDN domain name. Wildcard domain names that start with periods (.) are supported. For example, .a.com.
:param check_url: Property checkUrl: The validation of the origin.
:param resource_group_id: Property resourceGroupId: The ID of the resource group. If this is left blank, the system automatically fills in the ID of the default resource group.
:param scope: Property scope: Valid values: domestic, overseas, and global. Default value: domestic. The setting is supported for users outside mainland China, users in mainland China of level 3 or above.
:param sources: Property sources: The list of origin URLs.
:param tags: Property tags: Tags to attach to instance. Max support 20 tags to add during create instance. Each tag with two properties Key and Value, and Key is required.
:param top_level_domain: Property topLevelDomain: The top-level domain, which can only be configured by users on the whitelist.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__fbe00986bb9c4069fc1841fb168ef8d26854ded68bdfa55db3b8b5ef48e19d2e)
check_type(argname="argument cdn_type", value=cdn_type, expected_type=type_hints["cdn_type"])
check_type(argname="argument domain_name", value=domain_name, expected_type=type_hints["domain_name"])
check_type(argname="argument check_url", value=check_url, expected_type=type_hints["check_url"])
check_type(argname="argument resource_group_id", value=resource_group_id, expected_type=type_hints["resource_group_id"])
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument sources", value=sources, expected_type=type_hints["sources"])
check_type(argname="argument tags", value=tags, expected_type=type_hints["tags"])
check_type(argname="argument top_level_domain", value=top_level_domain, expected_type=type_hints["top_level_domain"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"cdn_type": cdn_type,
"domain_name": domain_name,
}
if check_url is not None:
self._values["check_url"] = check_url
if resource_group_id is not None:
self._values["resource_group_id"] = resource_group_id
if scope is not None:
self._values["scope"] = scope
if sources is not None:
self._values["sources"] = sources
if tags is not None:
self._values["tags"] = tags
if top_level_domain is not None:
self._values["top_level_domain"] = top_level_domain
@builtins.property
def cdn_type(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property cdnType: The business type.
Valid values: web, download, video, livestream, and httpsdelivery. web: acceleration of images and small files download. download: acceleration of large file downloads. video: live streaming acceleration. httpsdelivery: SSL acceleration for HTTPS.
'''
result = self._values.get("cdn_type")
assert result is not None, "Required property 'cdn_type' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def domain_name(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property domainName: The CDN domain name.
Wildcard domain names that start with periods (.) are supported. For example, .a.com.
'''
result = self._values.get("domain_name")
assert result is not None, "Required property 'domain_name' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def check_url(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property checkUrl: The validation of the origin.'''
result = self._values.get("check_url")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def resource_group_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property resourceGroupId: The ID of the resource group.
If this is left blank, the system automatically fills in the ID of the default resource group.
'''
result = self._values.get("resource_group_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def scope(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property scope: Valid values: domestic, overseas, and global.
Default value: domestic. The setting is supported for users outside mainland China, users in mainland China of level 3 or above.
'''
result = self._values.get("scope")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def sources(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property sources: The list of origin URLs.'''
result = self._values.get("sources")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def tags(self) -> typing.Optional[typing.List["RosDomain.TagsProperty"]]:
'''Property tags: Tags to attach to instance.
Max support 20 tags to add during create instance. Each tag with two properties Key and Value, and Key is required.
'''
result = self._values.get("tags")
return typing.cast(typing.Optional[typing.List["RosDomain.TagsProperty"]], result)
@builtins.property
def top_level_domain(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property topLevelDomain: The top-level domain, which can only be configured by users on the whitelist.'''
result = self._values.get("top_level_domain")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "DomainProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class RosDomain(
_ros_cdk_core_7adfd82f.RosResource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-cdn.RosDomain",
):
'''A ROS template type: ``ALIYUN::CDN::Domain``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["RosDomainProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
'''Create a new ``ALIYUN::CDN::Domain``.
:param scope: - scope in which this resource is defined.
:param id: - scoped id of the resource.
:param props: - resource properties.
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__64a983aed56f99ff7184768286362700ca2ec8836351eb971116e15f739cd78f)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@jsii.member(jsii_name="renderProperties")
def _render_properties(
self,
props: typing.Mapping[builtins.str, typing.Any],
) -> typing.Mapping[builtins.str, typing.Any]:
'''
:param props: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__c8aa8e3eff16160f532d687c7303c9a472f625ef59e947e10d3682bc21920ad0)
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))
@jsii.python.classproperty
@jsii.member(jsii_name="ROS_RESOURCE_TYPE_NAME")
def ROS_RESOURCE_TYPE_NAME(cls) -> builtins.str:
'''The resource type name for this resource class.'''
return typing.cast(builtins.str, jsii.sget(cls, "ROS_RESOURCE_TYPE_NAME"))
@builtins.property
@jsii.member(jsii_name="attrCname")
def attr_cname(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: Cname: The CNAME generated for the CDN domain.You must add a CNAME record with your DNS provider to map the CDN domain name to the CNAME.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrCname"))
@builtins.property
@jsii.member(jsii_name="attrDomainName")
def attr_domain_name(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: DomainName: The CDN domain name. Wildcard domain names that start with periods (.) are supported. For example, .a.com.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrDomainName"))
@builtins.property
@jsii.member(jsii_name="rosProperties")
def _ros_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "rosProperties"))
@builtins.property
@jsii.member(jsii_name="cdnType")
def cdn_type(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: cdnType: The business type. Valid values: web, download, video, livestream, and httpsdelivery. web: acceleration of images and small files download. download: acceleration of large file downloads. video: live streaming acceleration. httpsdelivery: SSL acceleration for HTTPS.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "cdnType"))
@cdn_type.setter
def cdn_type(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__06620cf9cc373c426846ba39b8e58e2b004446afb32779a67c9888c55da60f67)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "cdnType", value)
@builtins.property
@jsii.member(jsii_name="domainName")
def domain_name(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: domainName: The CDN domain name. Wildcard domain names that start with periods (.) are supported. For example, .a.com.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "domainName"))
@domain_name.setter
def domain_name(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__04969fdd87836ba787c7988f9ee20f26e0e59715de2ad398c1e97deab7ba5d19)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "domainName", value)
@builtins.property
@jsii.member(jsii_name="enableResourcePropertyConstraint")
def enable_resource_property_constraint(self) -> builtins.bool:
return typing.cast(builtins.bool, jsii.get(self, "enableResourcePropertyConstraint"))
@enable_resource_property_constraint.setter
def enable_resource_property_constraint(self, value: builtins.bool) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__160cebb2a53cf04f8fcc462408cb094940a07e5974b183a51c26d125762d41c3)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "enableResourcePropertyConstraint", value)
@builtins.property
@jsii.member(jsii_name="checkUrl")
def check_url(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: checkUrl: The validation of the origin.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "checkUrl"))
@check_url.setter
def check_url(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__46784489843ff1158efd93105af1005b11ea700f6f40fc623f6b69c2145a197e)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "checkUrl", value)
@builtins.property
@jsii.member(jsii_name="resourceGroupId")
def resource_group_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: resourceGroupId: The ID of the resource group. If this is left blank, the system automatically fills in the ID of the default resource group.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "resourceGroupId"))
@resource_group_id.setter
def resource_group_id(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__1f10d662a42e88c5494b8733ae6565da8080f4331d20d0674ee2da0da17b8666)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "resourceGroupId", value)
@builtins.property
@jsii.member(jsii_name="scope")
def scope(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: scope: Valid values: domestic, overseas, and global. Default value: domestic. The setting is supported for users outside mainland China, users in mainland China of level 3 or above.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "scope"))
@scope.setter
def scope(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__f83a0fad5e24d4c49a47919442dd1f3157a27b90a4f6d5aab9a0fe00bf4698c7)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "scope", value)
@builtins.property
@jsii.member(jsii_name="sources")
def sources(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: sources: The list of origin URLs.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "sources"))
@sources.setter
def sources(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__d61985ac359cf3a8422ffd82ff980ee2b6ad232a2ac8390ecfbf57339b78b9e6)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "sources", value)
@builtins.property
@jsii.member(jsii_name="tags")
def tags(self) -> typing.Optional[typing.List["RosDomain.TagsProperty"]]:
'''
:Property: tags: Tags to attach to instance. Max support 20 tags to add during create instance. Each tag with two properties Key and Value, and Key is required.
'''
return typing.cast(typing.Optional[typing.List["RosDomain.TagsProperty"]], jsii.get(self, "tags"))
@tags.setter
def tags(
self,
value: typing.Optional[typing.List["RosDomain.TagsProperty"]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__c6cec6c881f3455145348958a9cbe1f1275cb3097dfbd4ec48da07348eec433a)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "tags", value)
@builtins.property
@jsii.member(jsii_name="topLevelDomain")
def top_level_domain(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: topLevelDomain: The top-level domain, which can only be configured by users on the whitelist.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "topLevelDomain"))
@top_level_domain.setter
def top_level_domain(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__4551e451792ef0538ec772fbcec48ce4f05a31c5371c0fdc5c5aaf7a6f013d40)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "topLevelDomain", value)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-cdn.RosDomain.TagsProperty",
jsii_struct_bases=[],
name_mapping={"key": "key", "value": "value"},
)
class TagsProperty:
def __init__(
self,
*,
key: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''
:param key:
:param value:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__c8fd4ed24fd9eeb4770011fa333d9ca09bbd784b0bc7ef3357d91e51ae181295)
check_type(argname="argument key", value=key, expected_type=type_hints["key"])
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"key": key,
}
if value is not None:
self._values["value"] = value
@builtins.property
def key(self) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: key: undefined
'''
result = self._values.get("key")
assert result is not None, "Required property 'key' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def value(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: value: undefined
'''
result = self._values.get("value")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "TagsProperty(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class RosDomainConfig(
_ros_cdk_core_7adfd82f.RosResource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-cdn.RosDomainConfig",
):
'''A ROS template type: ``ALIYUN::CDN::DomainConfig``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["RosDomainConfigProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
'''Create a new ``ALIYUN::CDN::DomainConfig``.
:param scope: - scope in which this resource is defined.
:param id: - scoped id of the resource.
:param props: - resource properties.
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__5d36017d1828a02fa0d24beb84457a3c4f98c22698aa99eab6f118ed9415df04)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@jsii.member(jsii_name="renderProperties")
def _render_properties(
self,
props: typing.Mapping[builtins.str, typing.Any],
) -> typing.Mapping[builtins.str, typing.Any]:
'''
:param props: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__f847c9c6c42b0e3da501b48f0ea4bb771b083eb683a86bcbd2fc4dc0ac3a84bd)
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))
@jsii.python.classproperty
@jsii.member(jsii_name="ROS_RESOURCE_TYPE_NAME")
def ROS_RESOURCE_TYPE_NAME(cls) -> builtins.str:
'''The resource type name for this resource class.'''
return typing.cast(builtins.str, jsii.sget(cls, "ROS_RESOURCE_TYPE_NAME"))
@builtins.property
@jsii.member(jsii_name="rosProperties")
def _ros_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "rosProperties"))
@builtins.property
@jsii.member(jsii_name="domainNames")
def domain_names(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: domainNames: Your accelerated domain name, separated by commas in English.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "domainNames"))
@domain_names.setter
def domain_names(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__08e235c5fdee02d5f363670f4a096d774bb780c0cd653428d55b9155769dd3ce)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "domainNames", value)
@builtins.property
@jsii.member(jsii_name="enableResourcePropertyConstraint")
def enable_resource_property_constraint(self) -> builtins.bool:
'''A factory method that creates a new instance of this class from an object containing the properties of this ROS resource.'''
return typing.cast(builtins.bool, jsii.get(self, "enableResourcePropertyConstraint"))
@enable_resource_property_constraint.setter
def enable_resource_property_constraint(self, value: builtins.bool) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__5b8681407c76018b824d3dceb565a38d49c0253cc4920b8b00b3573c0f785bb1)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "enableResourcePropertyConstraint", value)
@builtins.property
@jsii.member(jsii_name="functions")
def functions(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: functions: function list, please refer to the CDN documentation for details.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "functions"))
@functions.setter
def functions(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__080de19a5c12cc11e3a52b20c3fb4747ed23e61d15f682788bec7ab72910c153)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "functions", value)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-cdn.RosDomainConfigProps",
jsii_struct_bases=[],
name_mapping={"domain_names": "domainNames", "functions": "functions"},
)
class RosDomainConfigProps:
def __init__(
self,
*,
domain_names: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
functions: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
'''Properties for defining a ``ALIYUN::CDN::DomainConfig``.
:param domain_names:
:param functions:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__143f541f3167b7fa780e251790b39fb7fd53eda6ae3d49b8c638a5c7fb428a0d)
check_type(argname="argument domain_names", value=domain_names, expected_type=type_hints["domain_names"])
check_type(argname="argument functions", value=functions, expected_type=type_hints["functions"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"domain_names": domain_names,
"functions": functions,
}
@builtins.property
def domain_names(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: domainNames: Your accelerated domain name, separated by commas in English.
'''
result = self._values.get("domain_names")
assert result is not None, "Required property 'domain_names' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def functions(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: functions: function list, please refer to the CDN documentation for details.
'''
result = self._values.get("functions")
assert result is not None, "Required property 'functions' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "RosDomainConfigProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-cdn.RosDomainProps",
jsii_struct_bases=[],
name_mapping={
"cdn_type": "cdnType",
"domain_name": "domainName",
"check_url": "checkUrl",
"resource_group_id": "resourceGroupId",
"scope": "scope",
"sources": "sources",
"tags": "tags",
"top_level_domain": "topLevelDomain",
},
)
class RosDomainProps:
def __init__(
self,
*,
cdn_type: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
domain_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
check_url: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
resource_group_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
scope: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
sources: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
tags: typing.Optional[typing.Sequence[typing.Union[RosDomain.TagsProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
top_level_domain: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::CDN::Domain``.
:param cdn_type:
:param domain_name:
:param check_url:
:param resource_group_id:
:param scope:
:param sources:
:param tags:
:param top_level_domain:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__848d18b862effe65d493698c0fe2b469cc234db0026deca93854c279147f4dfd)
check_type(argname="argument cdn_type", value=cdn_type, expected_type=type_hints["cdn_type"])
check_type(argname="argument domain_name", value=domain_name, expected_type=type_hints["domain_name"])
check_type(argname="argument check_url", value=check_url, expected_type=type_hints["check_url"])
check_type(argname="argument resource_group_id", value=resource_group_id, expected_type=type_hints["resource_group_id"])
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument sources", value=sources, expected_type=type_hints["sources"])
check_type(argname="argument tags", value=tags, expected_type=type_hints["tags"])
check_type(argname="argument top_level_domain", value=top_level_domain, expected_type=type_hints["top_level_domain"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"cdn_type": cdn_type,
"domain_name": domain_name,
}
if check_url is not None:
self._values["check_url"] = check_url
if resource_group_id is not None:
self._values["resource_group_id"] = resource_group_id
if scope is not None:
self._values["scope"] = scope
if sources is not None:
self._values["sources"] = sources
if tags is not None:
self._values["tags"] = tags
if top_level_domain is not None:
self._values["top_level_domain"] = top_level_domain
@builtins.property
def cdn_type(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: cdnType: The business type. Valid values: web, download, video, livestream, and httpsdelivery. web: acceleration of images and small files download. download: acceleration of large file downloads. video: live streaming acceleration. httpsdelivery: SSL acceleration for HTTPS.
'''
result = self._values.get("cdn_type")
assert result is not None, "Required property 'cdn_type' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def domain_name(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: domainName: The CDN domain name. Wildcard domain names that start with periods (.) are supported. For example, .a.com.
'''
result = self._values.get("domain_name")
assert result is not None, "Required property 'domain_name' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def check_url(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: checkUrl: The validation of the origin.
'''
result = self._values.get("check_url")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def resource_group_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: resourceGroupId: The ID of the resource group. If this is left blank, the system automatically fills in the ID of the default resource group.
'''
result = self._values.get("resource_group_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def scope(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: scope: Valid values: domestic, overseas, and global. Default value: domestic. The setting is supported for users outside mainland China, users in mainland China of level 3 or above.
'''
result = self._values.get("scope")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def sources(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: sources: The list of origin URLs.
'''
result = self._values.get("sources")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def tags(self) -> typing.Optional[typing.List[RosDomain.TagsProperty]]:
'''
:Property: tags: Tags to attach to instance. Max support 20 tags to add during create instance. Each tag with two properties Key and Value, and Key is required.
'''
result = self._values.get("tags")
return typing.cast(typing.Optional[typing.List[RosDomain.TagsProperty]], result)
@builtins.property
def top_level_domain(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: topLevelDomain: The top-level domain, which can only be configured by users on the whitelist.
'''
result = self._values.get("top_level_domain")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "RosDomainProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
__all__ = [
"Domain",
"DomainConfig",
"DomainConfigProps",
"DomainProps",
"RosDomain",
"RosDomainConfig",
"RosDomainConfigProps",
"RosDomainProps",
"datasource",
]
publication.publish()
# Loading modules to ensure their types are registered with the jsii runtime library
from . import datasource
def _typecheckingstub__0a504257e802fc47414fd60396440a38b3d8189c7c8a055e12b18472b4c55304(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[DomainProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__9d139905fcc664b63d2cff155fa704af5f61d6ebcc4806131782109feb8baef5(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[DomainConfigProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__8b24d05b17dce3dd66e25492982b9174726df2150f56400c0ff3f98b1647d6e2(
*,
domain_names: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
functions: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__fbe00986bb9c4069fc1841fb168ef8d26854ded68bdfa55db3b8b5ef48e19d2e(
*,
cdn_type: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
domain_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
check_url: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
resource_group_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
scope: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
sources: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
tags: typing.Optional[typing.Sequence[typing.Union[RosDomain.TagsProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
top_level_domain: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__64a983aed56f99ff7184768286362700ca2ec8836351eb971116e15f739cd78f(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[RosDomainProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__c8aa8e3eff16160f532d687c7303c9a472f625ef59e947e10d3682bc21920ad0(
props: typing.Mapping[builtins.str, typing.Any],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__06620cf9cc373c426846ba39b8e58e2b004446afb32779a67c9888c55da60f67(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__04969fdd87836ba787c7988f9ee20f26e0e59715de2ad398c1e97deab7ba5d19(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__160cebb2a53cf04f8fcc462408cb094940a07e5974b183a51c26d125762d41c3(
value: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__46784489843ff1158efd93105af1005b11ea700f6f40fc623f6b69c2145a197e(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__1f10d662a42e88c5494b8733ae6565da8080f4331d20d0674ee2da0da17b8666(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__f83a0fad5e24d4c49a47919442dd1f3157a27b90a4f6d5aab9a0fe00bf4698c7(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__d61985ac359cf3a8422ffd82ff980ee2b6ad232a2ac8390ecfbf57339b78b9e6(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__c6cec6c881f3455145348958a9cbe1f1275cb3097dfbd4ec48da07348eec433a(
value: typing.Optional[typing.List[RosDomain.TagsProperty]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__4551e451792ef0538ec772fbcec48ce4f05a31c5371c0fdc5c5aaf7a6f013d40(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__c8fd4ed24fd9eeb4770011fa333d9ca09bbd784b0bc7ef3357d91e51ae181295(
*,
key: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__5d36017d1828a02fa0d24beb84457a3c4f98c22698aa99eab6f118ed9415df04(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[RosDomainConfigProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__f847c9c6c42b0e3da501b48f0ea4bb771b083eb683a86bcbd2fc4dc0ac3a84bd(
props: typing.Mapping[builtins.str, typing.Any],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__08e235c5fdee02d5f363670f4a096d774bb780c0cd653428d55b9155769dd3ce(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__5b8681407c76018b824d3dceb565a38d49c0253cc4920b8b00b3573c0f785bb1(
value: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__080de19a5c12cc11e3a52b20c3fb4747ed23e61d15f682788bec7ab72910c153(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__143f541f3167b7fa780e251790b39fb7fd53eda6ae3d49b8c638a5c7fb428a0d(
*,
domain_names: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
functions: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__848d18b862effe65d493698c0fe2b469cc234db0026deca93854c279147f4dfd(
*,
cdn_type: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
domain_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
check_url: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
resource_group_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
scope: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
sources: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
tags: typing.Optional[typing.Sequence[typing.Union[RosDomain.TagsProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
top_level_domain: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass | /ros-cdk-cdn-1.0.17.tar.gz/ros-cdk-cdn-1.0.17/src/ros_cdk_cdn/__init__.py | 0.658747 | 0.15393 | __init__.py | pypi |
import abc
import builtins
import datetime
import enum
import typing
import jsii
import publication
import typing_extensions
from typeguard import check_type
from .._jsii import *
import ros_cdk_core as _ros_cdk_core_7adfd82f
class Domains(
_ros_cdk_core_7adfd82f.Resource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-cdn.datasource.Domains",
):
'''A ROS resource type: ``DATASOURCE::CDN::Domains``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["DomainsProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
'''Create a new ``DATASOURCE::CDN::Domains``.
Param scope - scope in which this resource is defined
Param id - scoped id of the resource
Param props - resource properties
:param scope: -
:param id: -
:param props: -
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__ce1d951247d9ee265c44e802beb1724657f0f001cf17b61088fd5a3ecdf0c7b6)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@builtins.property
@jsii.member(jsii_name="attrDomainNames")
def attr_domain_names(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute DomainNames: The list of domain names.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrDomainNames"))
@builtins.property
@jsii.member(jsii_name="attrDomains")
def attr_domains(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute Domains: The list of domains.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrDomains"))
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-cdn.datasource.DomainsProps",
jsii_struct_bases=[],
name_mapping={"domain_name": "domainName"},
)
class DomainsProps:
def __init__(
self,
*,
domain_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
'''Properties for defining a ``DATASOURCE::CDN::Domains``.
:param domain_name: Property domainName: The accelerated domain name. You can specify only one domain name.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__3a8d1ec65e55ae2b8da74e6539a074b3d75244e7e9035358f9f66b23281c6231)
check_type(argname="argument domain_name", value=domain_name, expected_type=type_hints["domain_name"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"domain_name": domain_name,
}
@builtins.property
def domain_name(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property domainName: The accelerated domain name.
You can specify only one domain name.
'''
result = self._values.get("domain_name")
assert result is not None, "Required property 'domain_name' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "DomainsProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class RosDomains(
_ros_cdk_core_7adfd82f.RosResource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-cdn.datasource.RosDomains",
):
'''A ROS template type: ``DATASOURCE::CDN::Domains``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["RosDomainsProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
'''Create a new ``DATASOURCE::CDN::Domains``.
:param scope: - scope in which this resource is defined.
:param id: - scoped id of the resource.
:param props: - resource properties.
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__b48a466f4a905c1d5785a6344087e7c946a42f25759648c5e2d75bf55c265ed2)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@jsii.member(jsii_name="renderProperties")
def _render_properties(
self,
props: typing.Mapping[builtins.str, typing.Any],
) -> typing.Mapping[builtins.str, typing.Any]:
'''
:param props: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__552c6bcb53c3a39f549ce9d0d68d7bf5d9dd82e03fe715cd8da6abb844ead9b9)
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))
@jsii.python.classproperty
@jsii.member(jsii_name="ROS_RESOURCE_TYPE_NAME")
def ROS_RESOURCE_TYPE_NAME(cls) -> builtins.str:
'''The resource type name for this resource class.'''
return typing.cast(builtins.str, jsii.sget(cls, "ROS_RESOURCE_TYPE_NAME"))
@builtins.property
@jsii.member(jsii_name="attrDomainNames")
def attr_domain_names(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: DomainNames: The list of domain names.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrDomainNames"))
@builtins.property
@jsii.member(jsii_name="attrDomains")
def attr_domains(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: Domains: The list of domains.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrDomains"))
@builtins.property
@jsii.member(jsii_name="rosProperties")
def _ros_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "rosProperties"))
@builtins.property
@jsii.member(jsii_name="domainName")
def domain_name(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: domainName: The accelerated domain name. You can specify only one domain name.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "domainName"))
@domain_name.setter
def domain_name(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__a904a207d2b6057b2e4303835ccc57cc1efb18cd68c451065c418063991af05e)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "domainName", value)
@builtins.property
@jsii.member(jsii_name="enableResourcePropertyConstraint")
def enable_resource_property_constraint(self) -> builtins.bool:
return typing.cast(builtins.bool, jsii.get(self, "enableResourcePropertyConstraint"))
@enable_resource_property_constraint.setter
def enable_resource_property_constraint(self, value: builtins.bool) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__efd860638681eaa1e0f223c5ad14f9407281c89529af68f77bf5e5f186932ede)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "enableResourcePropertyConstraint", value)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-cdn.datasource.RosDomainsProps",
jsii_struct_bases=[],
name_mapping={"domain_name": "domainName"},
)
class RosDomainsProps:
def __init__(
self,
*,
domain_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
'''Properties for defining a ``DATASOURCE::CDN::Domains``.
:param domain_name:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__ea3252d763d1aa72d65a5f391ea52f53700e62bb90fef1a6bf51fbece9b1eb36)
check_type(argname="argument domain_name", value=domain_name, expected_type=type_hints["domain_name"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"domain_name": domain_name,
}
@builtins.property
def domain_name(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: domainName: The accelerated domain name. You can specify only one domain name.
'''
result = self._values.get("domain_name")
assert result is not None, "Required property 'domain_name' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "RosDomainsProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
__all__ = [
"Domains",
"DomainsProps",
"RosDomains",
"RosDomainsProps",
]
publication.publish()
def _typecheckingstub__ce1d951247d9ee265c44e802beb1724657f0f001cf17b61088fd5a3ecdf0c7b6(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[DomainsProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__3a8d1ec65e55ae2b8da74e6539a074b3d75244e7e9035358f9f66b23281c6231(
*,
domain_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__b48a466f4a905c1d5785a6344087e7c946a42f25759648c5e2d75bf55c265ed2(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[RosDomainsProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__552c6bcb53c3a39f549ce9d0d68d7bf5d9dd82e03fe715cd8da6abb844ead9b9(
props: typing.Mapping[builtins.str, typing.Any],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__a904a207d2b6057b2e4303835ccc57cc1efb18cd68c451065c418063991af05e(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__efd860638681eaa1e0f223c5ad14f9407281c89529af68f77bf5e5f186932ede(
value: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__ea3252d763d1aa72d65a5f391ea52f53700e62bb90fef1a6bf51fbece9b1eb36(
*,
domain_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass | /ros-cdk-cdn-1.0.17.tar.gz/ros-cdk-cdn-1.0.17/src/ros_cdk_cdn/datasource/__init__.py | 0.628293 | 0.158044 | __init__.py | pypi |
import abc
import builtins
import datetime
import enum
import typing
import jsii
import publication
import typing_extensions
from typeguard import check_type
from ._jsii import *
import ros_cdk_core as _ros_cdk_core_7adfd82f
class AddressBook(
_ros_cdk_core_7adfd82f.Resource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-cloudfw.AddressBook",
):
'''A ROS resource type: ``ALIYUN::CLOUDFW::AddressBook``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["AddressBookProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
'''Create a new ``ALIYUN::CLOUDFW::AddressBook``.
Param scope - scope in which this resource is defined
Param id - scoped id of the resource
Param props - resource properties
:param scope: -
:param id: -
:param props: -
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__271a635ebc1744b887b2c9866532a1b2037a9f07cd701ded648279b1462ba0d8)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@builtins.property
@jsii.member(jsii_name="attrGroupUuid")
def attr_group_uuid(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute GroupUuid: After a successful return to the address book to add unique identification ID.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrGroupUuid"))
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-cloudfw.AddressBookProps",
jsii_struct_bases=[],
name_mapping={
"description": "description",
"group_name": "groupName",
"group_type": "groupType",
"address_list": "addressList",
"auto_add_tag_ecs": "autoAddTagEcs",
"region_id": "regionId",
"tag_list": "tagList",
"tag_relation": "tagRelation",
},
)
class AddressBookProps:
def __init__(
self,
*,
description: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
group_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
group_type: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
address_list: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
auto_add_tag_ecs: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
region_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
tag_list: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union["RosAddressBook.TagListProperty", typing.Dict[builtins.str, typing.Any]]]]]] = None,
tag_relation: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::CLOUDFW::AddressBook``.
:param description: Property description: Address book description.
:param group_name: Property groupName: Name Address book.
:param group_type: Property groupType: Type the address book, the optional values are: ip: IP Address Book domain: domain name address book port: Port Address Book tag: ECS label address book.
:param address_list: Property addressList: Address list of the address book, between multiple addresses separated by commas. Note: When GroupType ip, it must be set to port or domain. When GroupType as ip, address list, fill in the IP address. For example: 1.2.3.4/32, 1.2.3.0/24 When GroupType for the port, the address list to fill in ports or port ranges. For example: 80, 100/200 When GroupType for the domain, the domain name to fill in the address list. For example: demo1.aliyun.com, demo2.aliyun.com
:param auto_add_tag_ecs: Property autoAddTagEcs: Whether to automatically add new ECS public network IP matching tags to the address book. Default to false.
:param region_id: Property regionId: Region ID. Default to cn-hangzhou.
:param tag_list: Property tagList:.
:param tag_relation: Property tagRelation: The relationship between the labels to be matched more ECS. and: the relationship between multiple labels "and" that matches both ECS IP public network more tags will be added to the address book. or: a plurality of inter-labeled "or" relationship, i.e., as long as a matching tag ECS public IP address book will be added.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__3048effdb5c7b0cfdfaaa89788fbfe08ce785eb8a5fd4cc81182082b27f80ad1)
check_type(argname="argument description", value=description, expected_type=type_hints["description"])
check_type(argname="argument group_name", value=group_name, expected_type=type_hints["group_name"])
check_type(argname="argument group_type", value=group_type, expected_type=type_hints["group_type"])
check_type(argname="argument address_list", value=address_list, expected_type=type_hints["address_list"])
check_type(argname="argument auto_add_tag_ecs", value=auto_add_tag_ecs, expected_type=type_hints["auto_add_tag_ecs"])
check_type(argname="argument region_id", value=region_id, expected_type=type_hints["region_id"])
check_type(argname="argument tag_list", value=tag_list, expected_type=type_hints["tag_list"])
check_type(argname="argument tag_relation", value=tag_relation, expected_type=type_hints["tag_relation"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"description": description,
"group_name": group_name,
"group_type": group_type,
}
if address_list is not None:
self._values["address_list"] = address_list
if auto_add_tag_ecs is not None:
self._values["auto_add_tag_ecs"] = auto_add_tag_ecs
if region_id is not None:
self._values["region_id"] = region_id
if tag_list is not None:
self._values["tag_list"] = tag_list
if tag_relation is not None:
self._values["tag_relation"] = tag_relation
@builtins.property
def description(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property description: Address book description.'''
result = self._values.get("description")
assert result is not None, "Required property 'description' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def group_name(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property groupName: Name Address book.'''
result = self._values.get("group_name")
assert result is not None, "Required property 'group_name' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def group_type(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property groupType: Type the address book, the optional values are: ip: IP Address Book domain: domain name address book port: Port Address Book tag: ECS label address book.'''
result = self._values.get("group_type")
assert result is not None, "Required property 'group_type' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def address_list(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property addressList: Address list of the address book, between multiple addresses separated by commas.
Note: When GroupType ip, it must be set to port or domain.
When GroupType as ip, address list, fill in the IP address. For example: 1.2.3.4/32, 1.2.3.0/24
When GroupType for the port, the address list to fill in ports or port ranges. For example: 80, 100/200
When GroupType for the domain, the domain name to fill in the address list. For example: demo1.aliyun.com, demo2.aliyun.com
'''
result = self._values.get("address_list")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def auto_add_tag_ecs(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property autoAddTagEcs: Whether to automatically add new ECS public network IP matching tags to the address book.
Default to false.
'''
result = self._values.get("auto_add_tag_ecs")
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def region_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property regionId: Region ID.
Default to cn-hangzhou.
'''
result = self._values.get("region_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def tag_list(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosAddressBook.TagListProperty"]]]]:
'''Property tagList:.'''
result = self._values.get("tag_list")
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosAddressBook.TagListProperty"]]]], result)
@builtins.property
def tag_relation(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property tagRelation: The relationship between the labels to be matched more ECS.
and: the relationship between multiple labels "and" that matches both ECS IP public network more tags will be added to the address book.
or: a plurality of inter-labeled "or" relationship, i.e., as long as a matching tag ECS public IP address book will be added.
'''
result = self._values.get("tag_relation")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "AddressBookProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class ControlPolicy(
_ros_cdk_core_7adfd82f.Resource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-cloudfw.ControlPolicy",
):
'''A ROS resource type: ``ALIYUN::CLOUDFW::ControlPolicy``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["ControlPolicyProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
'''Create a new ``ALIYUN::CLOUDFW::ControlPolicy``.
Param scope - scope in which this resource is defined
Param id - scoped id of the resource
Param props - resource properties
:param scope: -
:param id: -
:param props: -
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__07a5501d83aab148499db9690ba914742ec2ccb48465a9a4ff4accf4e476c112)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@builtins.property
@jsii.member(jsii_name="attrAclUuid")
def attr_acl_uuid(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute AclUuid: Security access control ID that uniquely identifies the policy.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrAclUuid"))
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-cloudfw.ControlPolicyProps",
jsii_struct_bases=[],
name_mapping={
"acl_action": "aclAction",
"application_name": "applicationName",
"description": "description",
"destination": "destination",
"destination_type": "destinationType",
"direction": "direction",
"new_order": "newOrder",
"proto": "proto",
"source": "source",
"source_type": "sourceType",
"dest_port": "destPort",
"dest_port_group": "destPortGroup",
"dest_port_type": "destPortType",
"region_id": "regionId",
},
)
class ControlPolicyProps:
def __init__(
self,
*,
acl_action: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
application_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
description: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
destination: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
destination_type: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
direction: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
new_order: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
proto: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
source: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
source_type: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
dest_port: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
dest_port_group: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
dest_port_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
region_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::CLOUDFW::ControlPolicy``.
:param acl_action: Property aclAction: Traffic access control policy set by the cloud of a firewall. accept: Release drop: rejected log: Observation
:param application_name: Property applicationName: Application types supported by the security policy. The following types of applications are supported: ANY, HTTP, HTTPS, MySQL, SMTP, SMTPS, RDP, VNC, SSH, Redis, MQTT, MongoDB, Memcache, SSL NOTE ANY indicates that the policy is applied to all types of applications.
:param description: Property description: Security access control policy description information.
:param destination: Property destination: Security Access Control destination address policy. When DestinationType is net, Destination purpose CIDR. For example: 1.2.3.4/24 When DestinationType as a group, Destination for the purpose of the address book name. For example: db_group When DestinationType for the domain, Destination for the purpose of a domain name. For example:. * Aliyuncs.com When DestinationType as location, Destination area for the purpose (see below position encoding specific regions). For example: [ "BJ11", "ZB"]
:param destination_type: Property destinationType: Security Access Control destination address type of policy. net: Destination network segment (CIDR) group: destination address book domain: The purpose domain location: The purpose area
:param direction: Property direction: Security access control traffic direction policies. in: internal and external traffic access control out: within the flow of external access control
:param new_order: Property newOrder: Security access control priority policy in force. Priority number increments sequentially from 1, lower the priority number, the higher the priority. Description -1 indicates the lowest priority.
:param proto: Property proto: The type of security protocol for traffic access in the security access control policy. Can be set to ANY when you are not sure of the specific protocol type. Allowed values: ANY, TCP, UDP, ICMP
:param source: Property source: Security access control source address policy. When SourceType for the net, Source is the source CIDR. For example: 1.2.3.0/24 When SourceType as a group, Source name for the source address book. For example: db_group When SourceType as location, Source source region (specific region position encoder see below). For example, [ "BJ11", "ZB"]
:param source_type: Property sourceType: Security access control source address type of policy. net: Source segment (CIDR) group: source address book location: the source area
:param dest_port: Property destPort: Security access control policy access traffic destination port. Note When DestPortType to port, set the item.
:param dest_port_group: Property destPortGroup: Security access control policy access traffic destination port address book name. Description DestPortType is group, set the item.
:param dest_port_type: Property destPortType: Security access control policy access destination port traffic type. port: Port group: port address book
:param region_id: Property regionId: Region ID. Default to cn-hangzhou.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__a6c97798b19d98d15e94ace72d5a086540e0056a4ded86896b51b7212bff79b9)
check_type(argname="argument acl_action", value=acl_action, expected_type=type_hints["acl_action"])
check_type(argname="argument application_name", value=application_name, expected_type=type_hints["application_name"])
check_type(argname="argument description", value=description, expected_type=type_hints["description"])
check_type(argname="argument destination", value=destination, expected_type=type_hints["destination"])
check_type(argname="argument destination_type", value=destination_type, expected_type=type_hints["destination_type"])
check_type(argname="argument direction", value=direction, expected_type=type_hints["direction"])
check_type(argname="argument new_order", value=new_order, expected_type=type_hints["new_order"])
check_type(argname="argument proto", value=proto, expected_type=type_hints["proto"])
check_type(argname="argument source", value=source, expected_type=type_hints["source"])
check_type(argname="argument source_type", value=source_type, expected_type=type_hints["source_type"])
check_type(argname="argument dest_port", value=dest_port, expected_type=type_hints["dest_port"])
check_type(argname="argument dest_port_group", value=dest_port_group, expected_type=type_hints["dest_port_group"])
check_type(argname="argument dest_port_type", value=dest_port_type, expected_type=type_hints["dest_port_type"])
check_type(argname="argument region_id", value=region_id, expected_type=type_hints["region_id"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"acl_action": acl_action,
"application_name": application_name,
"description": description,
"destination": destination,
"destination_type": destination_type,
"direction": direction,
"new_order": new_order,
"proto": proto,
"source": source,
"source_type": source_type,
}
if dest_port is not None:
self._values["dest_port"] = dest_port
if dest_port_group is not None:
self._values["dest_port_group"] = dest_port_group
if dest_port_type is not None:
self._values["dest_port_type"] = dest_port_type
if region_id is not None:
self._values["region_id"] = region_id
@builtins.property
def acl_action(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property aclAction: Traffic access control policy set by the cloud of a firewall.
accept: Release
drop: rejected
log: Observation
'''
result = self._values.get("acl_action")
assert result is not None, "Required property 'acl_action' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def application_name(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property applicationName: Application types supported by the security policy.
The following types of applications are supported: ANY, HTTP, HTTPS, MySQL, SMTP, SMTPS, RDP, VNC, SSH, Redis, MQTT, MongoDB, Memcache, SSL
NOTE ANY indicates that the policy is applied to all types of applications.
'''
result = self._values.get("application_name")
assert result is not None, "Required property 'application_name' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def description(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property description: Security access control policy description information.'''
result = self._values.get("description")
assert result is not None, "Required property 'description' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def destination(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property destination: Security Access Control destination address policy.
When DestinationType is net, Destination purpose CIDR. For example: 1.2.3.4/24
When DestinationType as a group, Destination for the purpose of the address book name. For example: db_group
When DestinationType for the domain, Destination for the purpose of a domain name. For example:. * Aliyuncs.com
When DestinationType as location, Destination area for the purpose (see below position encoding specific regions). For example: [ "BJ11", "ZB"]
'''
result = self._values.get("destination")
assert result is not None, "Required property 'destination' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def destination_type(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property destinationType: Security Access Control destination address type of policy.
net: Destination network segment (CIDR)
group: destination address book
domain: The purpose domain
location: The purpose area
'''
result = self._values.get("destination_type")
assert result is not None, "Required property 'destination_type' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def direction(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property direction: Security access control traffic direction policies.
in: internal and external traffic access control
out: within the flow of external access control
'''
result = self._values.get("direction")
assert result is not None, "Required property 'direction' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def new_order(
self,
) -> typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property newOrder: Security access control priority policy in force.
Priority number increments sequentially from 1, lower the priority number, the higher the priority.
Description -1 indicates the lowest priority.
'''
result = self._values.get("new_order")
assert result is not None, "Required property 'new_order' is missing"
return typing.cast(typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def proto(self) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property proto: The type of security protocol for traffic access in the security access control policy.
Can be set to ANY when you are not sure of the specific protocol type.
Allowed values: ANY, TCP, UDP, ICMP
'''
result = self._values.get("proto")
assert result is not None, "Required property 'proto' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def source(self) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property source: Security access control source address policy.
When SourceType for the net, Source is the source CIDR. For example: 1.2.3.0/24
When SourceType as a group, Source name for the source address book. For example: db_group
When SourceType as location, Source source region (specific region position encoder see below). For example, [ "BJ11", "ZB"]
'''
result = self._values.get("source")
assert result is not None, "Required property 'source' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def source_type(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property sourceType: Security access control source address type of policy.
net: Source segment (CIDR)
group: source address book
location: the source area
'''
result = self._values.get("source_type")
assert result is not None, "Required property 'source_type' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def dest_port(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property destPort: Security access control policy access traffic destination port.
Note When DestPortType to port, set the item.
'''
result = self._values.get("dest_port")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def dest_port_group(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property destPortGroup: Security access control policy access traffic destination port address book name.
Description DestPortType is group, set the item.
'''
result = self._values.get("dest_port_group")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def dest_port_type(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property destPortType: Security access control policy access destination port traffic type.
port: Port
group: port address book
'''
result = self._values.get("dest_port_type")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def region_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property regionId: Region ID.
Default to cn-hangzhou.
'''
result = self._values.get("region_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "ControlPolicyProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class RosAddressBook(
_ros_cdk_core_7adfd82f.RosResource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-cloudfw.RosAddressBook",
):
'''A ROS template type: ``ALIYUN::CLOUDFW::AddressBook``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["RosAddressBookProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
'''Create a new ``ALIYUN::CLOUDFW::AddressBook``.
:param scope: - scope in which this resource is defined.
:param id: - scoped id of the resource.
:param props: - resource properties.
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__47f238772a3ed56e5bd977485bb50c171c63c336b9e0a8a4b2ddd05b19bf9a55)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@jsii.member(jsii_name="renderProperties")
def _render_properties(
self,
props: typing.Mapping[builtins.str, typing.Any],
) -> typing.Mapping[builtins.str, typing.Any]:
'''
:param props: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__a28c30da64daf931477a5cb3d6cd1e445ee006dd686f54b70dc36fd302321418)
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))
@jsii.python.classproperty
@jsii.member(jsii_name="ROS_RESOURCE_TYPE_NAME")
def ROS_RESOURCE_TYPE_NAME(cls) -> builtins.str:
'''The resource type name for this resource class.'''
return typing.cast(builtins.str, jsii.sget(cls, "ROS_RESOURCE_TYPE_NAME"))
@builtins.property
@jsii.member(jsii_name="attrGroupUuid")
def attr_group_uuid(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: GroupUuid: After a successful return to the address book to add unique identification ID.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrGroupUuid"))
@builtins.property
@jsii.member(jsii_name="rosProperties")
def _ros_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "rosProperties"))
@builtins.property
@jsii.member(jsii_name="description")
def description(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: description: Address book description.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "description"))
@description.setter
def description(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__6e3920913a84268ddc2456bc7a56275ee9c3e4a078ea673fdd38c1c141702147)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "description", value)
@builtins.property
@jsii.member(jsii_name="enableResourcePropertyConstraint")
def enable_resource_property_constraint(self) -> builtins.bool:
return typing.cast(builtins.bool, jsii.get(self, "enableResourcePropertyConstraint"))
@enable_resource_property_constraint.setter
def enable_resource_property_constraint(self, value: builtins.bool) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__40ec77e3e0d96355ae15403b2dec6fc4cdefd1e0f5bdfe36d244b34ce27a98b3)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "enableResourcePropertyConstraint", value)
@builtins.property
@jsii.member(jsii_name="groupName")
def group_name(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: groupName: Name Address book.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "groupName"))
@group_name.setter
def group_name(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__c916728d1fea76c23a23151bfa3f83ea6a1b3c8cbf7dbb953fca12105455adcc)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "groupName", value)
@builtins.property
@jsii.member(jsii_name="groupType")
def group_type(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
groupType: Type the address book, the optional values are:
ip: IP Address Book
domain: domain name address book
port: Port Address Book
tag: ECS label address book
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "groupType"))
@group_type.setter
def group_type(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__1319722c91e9e07c2a11cef6ce87907d4697dde028ec426e87d5517573229cf9)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "groupType", value)
@builtins.property
@jsii.member(jsii_name="addressList")
def address_list(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
addressList: Address list of the address book, between multiple addresses separated by commas.
Note: When GroupType ip, it must be set to port or domain.
When GroupType as ip, address list, fill in the IP address. For example: 1.2.3.4/32, 1.2.3.0/24
When GroupType for the port, the address list to fill in ports or port ranges. For example: 80, 100/200
When GroupType for the domain, the domain name to fill in the address list. For example: demo1.aliyun.com, demo2.aliyun.com
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "addressList"))
@address_list.setter
def address_list(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__007b989906d00a2b3cda650fbb5c6ddfcbf109b8dc06baffe61e847b6e67a7bc)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "addressList", value)
@builtins.property
@jsii.member(jsii_name="autoAddTagEcs")
def auto_add_tag_ecs(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: autoAddTagEcs: Whether to automatically add new ECS public network IP matching tags to the address book. Default to false.
'''
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "autoAddTagEcs"))
@auto_add_tag_ecs.setter
def auto_add_tag_ecs(
self,
value: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__d84710d1be3e7b76a99b3be7991e10250c01747737d2511e9e5672641141a50f)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "autoAddTagEcs", value)
@builtins.property
@jsii.member(jsii_name="regionId")
def region_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: regionId: Region ID. Default to cn-hangzhou.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "regionId"))
@region_id.setter
def region_id(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__50e743014fc32b58b8d7923a74dcd4333617c71e5a24579d9851d9c5b468f94d)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "regionId", value)
@builtins.property
@jsii.member(jsii_name="tagList")
def tag_list(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosAddressBook.TagListProperty"]]]]:
'''
:Property: tagList:
'''
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosAddressBook.TagListProperty"]]]], jsii.get(self, "tagList"))
@tag_list.setter
def tag_list(
self,
value: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosAddressBook.TagListProperty"]]]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__a2a22f4b278eac71ceaf69aa66296f893b53f86b5492e34a347ccd0e10e434ae)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "tagList", value)
@builtins.property
@jsii.member(jsii_name="tagRelation")
def tag_relation(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
tagRelation: The relationship between the labels to be matched more ECS.
and: the relationship between multiple labels "and" that matches both ECS IP public network more tags will be added to the address book.
or: a plurality of inter-labeled "or" relationship, i.e., as long as a matching tag ECS public IP address book will be added.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "tagRelation"))
@tag_relation.setter
def tag_relation(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__9c3c2a7100caf425a0bf4bfd343bf5e97d805535717cf02d5120498a80de450d)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "tagRelation", value)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-cloudfw.RosAddressBook.TagListProperty",
jsii_struct_bases=[],
name_mapping={"tag_key": "tagKey", "tag_value": "tagValue"},
)
class TagListProperty:
def __init__(
self,
*,
tag_key: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
tag_value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''
:param tag_key:
:param tag_value:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__33015f906f965c083c31a4652a4853f6e347810a8faf2e3744d6d85571f38eb1)
check_type(argname="argument tag_key", value=tag_key, expected_type=type_hints["tag_key"])
check_type(argname="argument tag_value", value=tag_value, expected_type=type_hints["tag_value"])
self._values: typing.Dict[builtins.str, typing.Any] = {}
if tag_key is not None:
self._values["tag_key"] = tag_key
if tag_value is not None:
self._values["tag_value"] = tag_value
@builtins.property
def tag_key(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: tagKey: ECS labels to be matched Key.
'''
result = self._values.get("tag_key")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def tag_value(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: tagValue: ECS tag value to be matched.
'''
result = self._values.get("tag_value")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "TagListProperty(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-cloudfw.RosAddressBookProps",
jsii_struct_bases=[],
name_mapping={
"description": "description",
"group_name": "groupName",
"group_type": "groupType",
"address_list": "addressList",
"auto_add_tag_ecs": "autoAddTagEcs",
"region_id": "regionId",
"tag_list": "tagList",
"tag_relation": "tagRelation",
},
)
class RosAddressBookProps:
def __init__(
self,
*,
description: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
group_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
group_type: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
address_list: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
auto_add_tag_ecs: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
region_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
tag_list: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union[RosAddressBook.TagListProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
tag_relation: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::CLOUDFW::AddressBook``.
:param description:
:param group_name:
:param group_type:
:param address_list:
:param auto_add_tag_ecs:
:param region_id:
:param tag_list:
:param tag_relation:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__e3cf010e328c81ee26cf437f875ace412d595bafd7e726edc690c1a35b0ad9b1)
check_type(argname="argument description", value=description, expected_type=type_hints["description"])
check_type(argname="argument group_name", value=group_name, expected_type=type_hints["group_name"])
check_type(argname="argument group_type", value=group_type, expected_type=type_hints["group_type"])
check_type(argname="argument address_list", value=address_list, expected_type=type_hints["address_list"])
check_type(argname="argument auto_add_tag_ecs", value=auto_add_tag_ecs, expected_type=type_hints["auto_add_tag_ecs"])
check_type(argname="argument region_id", value=region_id, expected_type=type_hints["region_id"])
check_type(argname="argument tag_list", value=tag_list, expected_type=type_hints["tag_list"])
check_type(argname="argument tag_relation", value=tag_relation, expected_type=type_hints["tag_relation"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"description": description,
"group_name": group_name,
"group_type": group_type,
}
if address_list is not None:
self._values["address_list"] = address_list
if auto_add_tag_ecs is not None:
self._values["auto_add_tag_ecs"] = auto_add_tag_ecs
if region_id is not None:
self._values["region_id"] = region_id
if tag_list is not None:
self._values["tag_list"] = tag_list
if tag_relation is not None:
self._values["tag_relation"] = tag_relation
@builtins.property
def description(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: description: Address book description.
'''
result = self._values.get("description")
assert result is not None, "Required property 'description' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def group_name(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: groupName: Name Address book.
'''
result = self._values.get("group_name")
assert result is not None, "Required property 'group_name' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def group_type(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
groupType: Type the address book, the optional values are:
ip: IP Address Book
domain: domain name address book
port: Port Address Book
tag: ECS label address book
'''
result = self._values.get("group_type")
assert result is not None, "Required property 'group_type' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def address_list(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
addressList: Address list of the address book, between multiple addresses separated by commas.
Note: When GroupType ip, it must be set to port or domain.
When GroupType as ip, address list, fill in the IP address. For example: 1.2.3.4/32, 1.2.3.0/24
When GroupType for the port, the address list to fill in ports or port ranges. For example: 80, 100/200
When GroupType for the domain, the domain name to fill in the address list. For example: demo1.aliyun.com, demo2.aliyun.com
'''
result = self._values.get("address_list")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def auto_add_tag_ecs(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: autoAddTagEcs: Whether to automatically add new ECS public network IP matching tags to the address book. Default to false.
'''
result = self._values.get("auto_add_tag_ecs")
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def region_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: regionId: Region ID. Default to cn-hangzhou.
'''
result = self._values.get("region_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def tag_list(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, RosAddressBook.TagListProperty]]]]:
'''
:Property: tagList:
'''
result = self._values.get("tag_list")
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, RosAddressBook.TagListProperty]]]], result)
@builtins.property
def tag_relation(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
tagRelation: The relationship between the labels to be matched more ECS.
and: the relationship between multiple labels "and" that matches both ECS IP public network more tags will be added to the address book.
or: a plurality of inter-labeled "or" relationship, i.e., as long as a matching tag ECS public IP address book will be added.
'''
result = self._values.get("tag_relation")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "RosAddressBookProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class RosControlPolicy(
_ros_cdk_core_7adfd82f.RosResource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-cloudfw.RosControlPolicy",
):
'''A ROS template type: ``ALIYUN::CLOUDFW::ControlPolicy``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["RosControlPolicyProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
'''Create a new ``ALIYUN::CLOUDFW::ControlPolicy``.
:param scope: - scope in which this resource is defined.
:param id: - scoped id of the resource.
:param props: - resource properties.
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__ddb42ae0f4276889be14ab33bcf5c1d4908ee7dfa4c92d0c808c823467c11b88)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@jsii.member(jsii_name="renderProperties")
def _render_properties(
self,
props: typing.Mapping[builtins.str, typing.Any],
) -> typing.Mapping[builtins.str, typing.Any]:
'''
:param props: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__b502996760daf29c694d9da3445f1693e3edbff7a719ebb68f5ad3d11a021baf)
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))
@jsii.python.classproperty
@jsii.member(jsii_name="ROS_RESOURCE_TYPE_NAME")
def ROS_RESOURCE_TYPE_NAME(cls) -> builtins.str:
'''The resource type name for this resource class.'''
return typing.cast(builtins.str, jsii.sget(cls, "ROS_RESOURCE_TYPE_NAME"))
@builtins.property
@jsii.member(jsii_name="attrAclUuid")
def attr_acl_uuid(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: AclUuid: Security access control ID that uniquely identifies the policy.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrAclUuid"))
@builtins.property
@jsii.member(jsii_name="rosProperties")
def _ros_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "rosProperties"))
@builtins.property
@jsii.member(jsii_name="aclAction")
def acl_action(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
aclAction: Traffic access control policy set by the cloud of a firewall.
accept: Release
drop: rejected
log: Observation
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "aclAction"))
@acl_action.setter
def acl_action(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__42842dd2e28d3eff251f2a0cdff50c37502ee238166042901966e367cafefef5)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "aclAction", value)
@builtins.property
@jsii.member(jsii_name="applicationName")
def application_name(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
applicationName: Application types supported by the security policy.
The following types of applications are supported: ANY, HTTP, HTTPS, MySQL, SMTP, SMTPS, RDP, VNC, SSH, Redis, MQTT, MongoDB, Memcache, SSL
NOTE ANY indicates that the policy is applied to all types of applications.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "applicationName"))
@application_name.setter
def application_name(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__dfe2bd60e25abb0616a3a0e7947b03f7a77d96fbee9017276db1ea2154be9857)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "applicationName", value)
@builtins.property
@jsii.member(jsii_name="description")
def description(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: description: Security access control policy description information.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "description"))
@description.setter
def description(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__59d032dfb5f91df7823d38447e8019f408abd26cc3ad5a3a169d4f0f583c7498)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "description", value)
@builtins.property
@jsii.member(jsii_name="destination")
def destination(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
destination: Security Access Control destination address policy.
When DestinationType is net, Destination purpose CIDR. For example: 1.2.3.4/24
When DestinationType as a group, Destination for the purpose of the address book name. For example: db_group
When DestinationType for the domain, Destination for the purpose of a domain name. For example:. * Aliyuncs.com
When DestinationType as location, Destination area for the purpose (see below position encoding specific regions). For example: [ "BJ11", "ZB"]
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "destination"))
@destination.setter
def destination(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__3a61c02e970f47e08c374e6fdc11378f213c372d085bf3ea26993277f6319fda)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "destination", value)
@builtins.property
@jsii.member(jsii_name="destinationType")
def destination_type(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
destinationType: Security Access Control destination address type of policy.
net: Destination network segment (CIDR)
group: destination address book
domain: The purpose domain
location: The purpose area
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "destinationType"))
@destination_type.setter
def destination_type(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__69fb67318d48840c9e78267377b07ee06dff87d4913ecbb64f55c62ffdd66ee4)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "destinationType", value)
@builtins.property
@jsii.member(jsii_name="direction")
def direction(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
direction: Security access control traffic direction policies.
in: internal and external traffic access control
out: within the flow of external access control
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "direction"))
@direction.setter
def direction(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__79cdcb681e3cfc3d6e0e06fa6784adf9a836d82431b955b0498ac21267b3437a)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "direction", value)
@builtins.property
@jsii.member(jsii_name="enableResourcePropertyConstraint")
def enable_resource_property_constraint(self) -> builtins.bool:
return typing.cast(builtins.bool, jsii.get(self, "enableResourcePropertyConstraint"))
@enable_resource_property_constraint.setter
def enable_resource_property_constraint(self, value: builtins.bool) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__b0f06a85be4b568a46b0d4bd2eba77b57b009049cc2f9575a0f209ee60e3a648)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "enableResourcePropertyConstraint", value)
@builtins.property
@jsii.member(jsii_name="newOrder")
def new_order(
self,
) -> typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
newOrder: Security access control priority policy in force. Priority number increments sequentially from 1, lower the priority number, the higher the priority.
Description -1 indicates the lowest priority.
'''
return typing.cast(typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "newOrder"))
@new_order.setter
def new_order(
self,
value: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__b95cd8c29eb0cf4492a951b5c61b7231d6a339c21c226363bd24f4226e55de7f)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "newOrder", value)
@builtins.property
@jsii.member(jsii_name="proto")
def proto(self) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
proto: The type of security protocol for traffic access in the security access control policy. Can be set to ANY when you are not sure of the specific protocol type.
Allowed values: ANY, TCP, UDP, ICMP
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "proto"))
@proto.setter
def proto(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__c9f2ea3043880e9ea1314654a21e5063f59606eade0cbf9b14e4e1072396d41d)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "proto", value)
@builtins.property
@jsii.member(jsii_name="source")
def source(self) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
source: Security access control source address policy.
When SourceType for the net, Source is the source CIDR. For example: 1.2.3.0/24
When SourceType as a group, Source name for the source address book. For example: db_group
When SourceType as location, Source source region (specific region position encoder see below). For example, [ "BJ11", "ZB"]
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "source"))
@source.setter
def source(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__31c67a5274e30d043eefc4eb90e744f7b863a37e140f154510e9b2c8946d9024)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "source", value)
@builtins.property
@jsii.member(jsii_name="sourceType")
def source_type(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
sourceType: Security access control source address type of policy.
net: Source segment (CIDR)
group: source address book
location: the source area
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "sourceType"))
@source_type.setter
def source_type(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__279eb9d1c7ff0047070f05521c15358f0c430707db906fe35426b61044ef109c)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "sourceType", value)
@builtins.property
@jsii.member(jsii_name="destPort")
def dest_port(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
destPort: Security access control policy access traffic destination port.
Note When DestPortType to port, set the item.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "destPort"))
@dest_port.setter
def dest_port(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__1726089d1212398c4c172279ad11effbe9a7bd440284ed75a082b32cf4e9cc13)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "destPort", value)
@builtins.property
@jsii.member(jsii_name="destPortGroup")
def dest_port_group(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
destPortGroup: Security access control policy access traffic destination port address book name.
Description DestPortType is group, set the item.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "destPortGroup"))
@dest_port_group.setter
def dest_port_group(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__5016bb41f3d7f459b47ce3946d741256804eea606e1056300415c1631f938a6c)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "destPortGroup", value)
@builtins.property
@jsii.member(jsii_name="destPortType")
def dest_port_type(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
destPortType: Security access control policy access destination port traffic type.
port: Port
group: port address book
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "destPortType"))
@dest_port_type.setter
def dest_port_type(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__57ef585ab5d10af54f015c43e44f3ebb2303095d7e3808b28e2e9af452fc7955)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "destPortType", value)
@builtins.property
@jsii.member(jsii_name="regionId")
def region_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: regionId: Region ID. Default to cn-hangzhou.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "regionId"))
@region_id.setter
def region_id(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__d213af605db6a677bf73e6abba066285635197e958432109f0db098010c3202a)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "regionId", value)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-cloudfw.RosControlPolicyProps",
jsii_struct_bases=[],
name_mapping={
"acl_action": "aclAction",
"application_name": "applicationName",
"description": "description",
"destination": "destination",
"destination_type": "destinationType",
"direction": "direction",
"new_order": "newOrder",
"proto": "proto",
"source": "source",
"source_type": "sourceType",
"dest_port": "destPort",
"dest_port_group": "destPortGroup",
"dest_port_type": "destPortType",
"region_id": "regionId",
},
)
class RosControlPolicyProps:
def __init__(
self,
*,
acl_action: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
application_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
description: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
destination: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
destination_type: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
direction: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
new_order: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
proto: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
source: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
source_type: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
dest_port: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
dest_port_group: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
dest_port_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
region_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::CLOUDFW::ControlPolicy``.
:param acl_action:
:param application_name:
:param description:
:param destination:
:param destination_type:
:param direction:
:param new_order:
:param proto:
:param source:
:param source_type:
:param dest_port:
:param dest_port_group:
:param dest_port_type:
:param region_id:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__1b0597838817cd28ec192aedb55f20a5dccb9153f1ecd07ffb4d2d889ef27f04)
check_type(argname="argument acl_action", value=acl_action, expected_type=type_hints["acl_action"])
check_type(argname="argument application_name", value=application_name, expected_type=type_hints["application_name"])
check_type(argname="argument description", value=description, expected_type=type_hints["description"])
check_type(argname="argument destination", value=destination, expected_type=type_hints["destination"])
check_type(argname="argument destination_type", value=destination_type, expected_type=type_hints["destination_type"])
check_type(argname="argument direction", value=direction, expected_type=type_hints["direction"])
check_type(argname="argument new_order", value=new_order, expected_type=type_hints["new_order"])
check_type(argname="argument proto", value=proto, expected_type=type_hints["proto"])
check_type(argname="argument source", value=source, expected_type=type_hints["source"])
check_type(argname="argument source_type", value=source_type, expected_type=type_hints["source_type"])
check_type(argname="argument dest_port", value=dest_port, expected_type=type_hints["dest_port"])
check_type(argname="argument dest_port_group", value=dest_port_group, expected_type=type_hints["dest_port_group"])
check_type(argname="argument dest_port_type", value=dest_port_type, expected_type=type_hints["dest_port_type"])
check_type(argname="argument region_id", value=region_id, expected_type=type_hints["region_id"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"acl_action": acl_action,
"application_name": application_name,
"description": description,
"destination": destination,
"destination_type": destination_type,
"direction": direction,
"new_order": new_order,
"proto": proto,
"source": source,
"source_type": source_type,
}
if dest_port is not None:
self._values["dest_port"] = dest_port
if dest_port_group is not None:
self._values["dest_port_group"] = dest_port_group
if dest_port_type is not None:
self._values["dest_port_type"] = dest_port_type
if region_id is not None:
self._values["region_id"] = region_id
@builtins.property
def acl_action(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
aclAction: Traffic access control policy set by the cloud of a firewall.
accept: Release
drop: rejected
log: Observation
'''
result = self._values.get("acl_action")
assert result is not None, "Required property 'acl_action' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def application_name(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
applicationName: Application types supported by the security policy.
The following types of applications are supported: ANY, HTTP, HTTPS, MySQL, SMTP, SMTPS, RDP, VNC, SSH, Redis, MQTT, MongoDB, Memcache, SSL
NOTE ANY indicates that the policy is applied to all types of applications.
'''
result = self._values.get("application_name")
assert result is not None, "Required property 'application_name' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def description(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: description: Security access control policy description information.
'''
result = self._values.get("description")
assert result is not None, "Required property 'description' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def destination(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
destination: Security Access Control destination address policy.
When DestinationType is net, Destination purpose CIDR. For example: 1.2.3.4/24
When DestinationType as a group, Destination for the purpose of the address book name. For example: db_group
When DestinationType for the domain, Destination for the purpose of a domain name. For example:. * Aliyuncs.com
When DestinationType as location, Destination area for the purpose (see below position encoding specific regions). For example: [ "BJ11", "ZB"]
'''
result = self._values.get("destination")
assert result is not None, "Required property 'destination' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def destination_type(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
destinationType: Security Access Control destination address type of policy.
net: Destination network segment (CIDR)
group: destination address book
domain: The purpose domain
location: The purpose area
'''
result = self._values.get("destination_type")
assert result is not None, "Required property 'destination_type' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def direction(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
direction: Security access control traffic direction policies.
in: internal and external traffic access control
out: within the flow of external access control
'''
result = self._values.get("direction")
assert result is not None, "Required property 'direction' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def new_order(
self,
) -> typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
newOrder: Security access control priority policy in force. Priority number increments sequentially from 1, lower the priority number, the higher the priority.
Description -1 indicates the lowest priority.
'''
result = self._values.get("new_order")
assert result is not None, "Required property 'new_order' is missing"
return typing.cast(typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def proto(self) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
proto: The type of security protocol for traffic access in the security access control policy. Can be set to ANY when you are not sure of the specific protocol type.
Allowed values: ANY, TCP, UDP, ICMP
'''
result = self._values.get("proto")
assert result is not None, "Required property 'proto' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def source(self) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
source: Security access control source address policy.
When SourceType for the net, Source is the source CIDR. For example: 1.2.3.0/24
When SourceType as a group, Source name for the source address book. For example: db_group
When SourceType as location, Source source region (specific region position encoder see below). For example, [ "BJ11", "ZB"]
'''
result = self._values.get("source")
assert result is not None, "Required property 'source' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def source_type(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
sourceType: Security access control source address type of policy.
net: Source segment (CIDR)
group: source address book
location: the source area
'''
result = self._values.get("source_type")
assert result is not None, "Required property 'source_type' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def dest_port(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
destPort: Security access control policy access traffic destination port.
Note When DestPortType to port, set the item.
'''
result = self._values.get("dest_port")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def dest_port_group(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
destPortGroup: Security access control policy access traffic destination port address book name.
Description DestPortType is group, set the item.
'''
result = self._values.get("dest_port_group")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def dest_port_type(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
destPortType: Security access control policy access destination port traffic type.
port: Port
group: port address book
'''
result = self._values.get("dest_port_type")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def region_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: regionId: Region ID. Default to cn-hangzhou.
'''
result = self._values.get("region_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "RosControlPolicyProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class RosVpcFirewallControlPolicy(
_ros_cdk_core_7adfd82f.RosResource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-cloudfw.RosVpcFirewallControlPolicy",
):
'''A ROS template type: ``ALIYUN::CLOUDFW::VpcFirewallControlPolicy``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["RosVpcFirewallControlPolicyProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
'''Create a new ``ALIYUN::CLOUDFW::VpcFirewallControlPolicy``.
:param scope: - scope in which this resource is defined.
:param id: - scoped id of the resource.
:param props: - resource properties.
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__7dce15297ae1a1ffa21fd1485c595a9499c8947815ae36eadccfb0e23066b11f)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@jsii.member(jsii_name="renderProperties")
def _render_properties(
self,
props: typing.Mapping[builtins.str, typing.Any],
) -> typing.Mapping[builtins.str, typing.Any]:
'''
:param props: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__39423d0ca0dd5f5089fc5ca7754afc41b8f51d8b14cbcf43b5b8aed31782a466)
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))
@jsii.python.classproperty
@jsii.member(jsii_name="ROS_RESOURCE_TYPE_NAME")
def ROS_RESOURCE_TYPE_NAME(cls) -> builtins.str:
'''The resource type name for this resource class.'''
return typing.cast(builtins.str, jsii.sget(cls, "ROS_RESOURCE_TYPE_NAME"))
@builtins.property
@jsii.member(jsii_name="attrAclUuid")
def attr_acl_uuid(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: AclUuid: The unique ID of the access control policy.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrAclUuid"))
@builtins.property
@jsii.member(jsii_name="rosProperties")
def _ros_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "rosProperties"))
@builtins.property
@jsii.member(jsii_name="aclAction")
def acl_action(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
aclAction: The action that Cloud Firewall performs on the traffic. Valid values:
accept: allows the traffic.
drop: denies the traffic.
log: monitors the traffic.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "aclAction"))
@acl_action.setter
def acl_action(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__1d228e200dafe7406841a2cc4ca75dc8842dff16f5f32598ff91d7b33368c35f)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "aclAction", value)
@builtins.property
@jsii.member(jsii_name="applicationName")
def application_name(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
applicationName: The application type that the access control policy supports.
Valid values:
ANY (indicates that all application types are supported)
FTP
HTTP
HTTPS
MySQL
SMTP
SMTPS
RDP
VNC
SSH
Redis
MQTT
MongoDB
Memcache
SSL
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "applicationName"))
@application_name.setter
def application_name(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__599c39b3a7815e06aa3526411ea576dcdbe893faf5a3b5874355d12e40c88e73)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "applicationName", value)
@builtins.property
@jsii.member(jsii_name="description")
def description(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: description: The description of the access control policy.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "description"))
@description.setter
def description(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__9977897a275c257529d1fffe0c95179e09a2addcaf52fdeb2574a7a764539271)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "description", value)
@builtins.property
@jsii.member(jsii_name="destination")
def destination(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
destination: The destination address in the access control policy.
Set this parameter in the following way:
If the DestinationType parameter is set to net, set the value to a Classless Inter-Domain Routing (CIDR) block.
Example: 10.2.3.0/24.
If the DestinationType parameter is set to group, set the value to the name of an address book.
Example: db_group.
If the DestinationType parameter is set to domain, set the value to a domain name.
Example: *.aliyuncs.com.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "destination"))
@destination.setter
def destination(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__9791ee1ad40b5c6e3507d13467fb8b4f557079ebb82a59b2a9a0599ac7b325f0)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "destination", value)
@builtins.property
@jsii.member(jsii_name="destinationType")
def destination_type(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
destinationType: The type of the destination address in the access control policy. Valid values:
net: CIDR block
group: address book
domain: domain name
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "destinationType"))
@destination_type.setter
def destination_type(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__955776c7ef3e15b187ae67076581b5e521ae8f25b47771b7d56e5874d7ab4eab)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "destinationType", value)
@builtins.property
@jsii.member(jsii_name="enableResourcePropertyConstraint")
def enable_resource_property_constraint(self) -> builtins.bool:
return typing.cast(builtins.bool, jsii.get(self, "enableResourcePropertyConstraint"))
@enable_resource_property_constraint.setter
def enable_resource_property_constraint(self, value: builtins.bool) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__1a58ebad222e9627cff03be30322be10428bf6a1c1b4d8ca0f32821832071238)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "enableResourcePropertyConstraint", value)
@builtins.property
@jsii.member(jsii_name="newOrder")
def new_order(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
newOrder: The priority of the access control policy.
The priority value starts from 1. A smaller priority value indicates a higher priority.
Note The value of -1 indicates the lowest priority.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "newOrder"))
@new_order.setter
def new_order(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__6f4ea5f8ae5d283dd505c49e11e0fff427ab76fff5e0e8a100713f4f0b29a4c4)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "newOrder", value)
@builtins.property
@jsii.member(jsii_name="proto")
def proto(self) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: proto: The type of the security protocol in the access control policy.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "proto"))
@proto.setter
def proto(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__bb8fdd2e47281677f7f57862d0408ea97540aeb81b32d449665114c1f7249722)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "proto", value)
@builtins.property
@jsii.member(jsii_name="source")
def source(self) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
source: The source address in the access control policy.
If the SourceType parameter is set to net, set the value to a CIDR block. Example: 10.2.3.0/24.
If the SourceType parameter is set to group, set the value to the name of an address book. Example: db_group.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "source"))
@source.setter
def source(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__5097c79a903a5a21ea153e82556cb1b28c15f4b0573a9befac96ba0cc025ba3c)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "source", value)
@builtins.property
@jsii.member(jsii_name="sourceType")
def source_type(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
sourceType: The type of the source address in the access control policy. Valid values:
net: CIDR block
group: address book
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "sourceType"))
@source_type.setter
def source_type(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__c87571e178d1228070b70a459c16287059d72396cf55ed6402a7664167ea7e73)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "sourceType", value)
@builtins.property
@jsii.member(jsii_name="vpcFirewallId")
def vpc_firewall_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
vpcFirewallId: The ID of the policy group to which you want to add the access control policy.
If the VPC firewall is used to protect CEN, set the value to the ID of the CEN instance
that the VPC firewall protects. Example: cen-ervw5jbw1234*****.
If the VPC firewall is used to protect Express Connect, set the value to the ID of
the VPC firewall instance. Example: vfw-a42bbb748c91234*****.
Note You can call the DescribeVpcFirewallAclGroupList operation to query the ID of the policy group.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "vpcFirewallId"))
@vpc_firewall_id.setter
def vpc_firewall_id(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__7592edf3640f58b1a2f728d625d9a0e01c76b8c4ad735fa0b0a2eb0a2ffe3f18)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "vpcFirewallId", value)
@builtins.property
@jsii.member(jsii_name="destPort")
def dest_port(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
destPort: The destination port in the access control policy.
Note This parameter must be specified if the DestPortType parameter is set to port.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "destPort"))
@dest_port.setter
def dest_port(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__51b0d526f445c26a21691bbc90c8cec5ad275fd0060a321adffe31413fed1d62)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "destPort", value)
@builtins.property
@jsii.member(jsii_name="destPortGroup")
def dest_port_group(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
destPortGroup: The address book of destination ports in the access control policy.
Note This parameter must be specified if the DestPortType parameter is set to group.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "destPortGroup"))
@dest_port_group.setter
def dest_port_group(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__3177838aaa2ed0a2c3baf5fab49270536b64a426677e852adb30b7b65d83060f)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "destPortGroup", value)
@builtins.property
@jsii.member(jsii_name="destPortType")
def dest_port_type(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
destPortType: The type of the destination port in the access control policy. Valid values:
port: port
group: address book
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "destPortType"))
@dest_port_type.setter
def dest_port_type(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__d502738f836acc24dbda31663a7589f36a4423e88544148803ebcd1b722a22c9)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "destPortType", value)
@builtins.property
@jsii.member(jsii_name="lang")
def lang(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
lang: The natural language of the request and response. Valid values:
zh: Chinese
en: English
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "lang"))
@lang.setter
def lang(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__96d999d2420828e537e4e75c270ee3181087edca0f79df47ca34defcba99fe8a)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "lang", value)
@builtins.property
@jsii.member(jsii_name="regionId")
def region_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: regionId: Region ID. Default to cn-hangzhou.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "regionId"))
@region_id.setter
def region_id(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__d3f90392eefb4dcc20c36b3189d0986cf82004cebfded3dbefd96dbf5a7f3800)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "regionId", value)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-cloudfw.RosVpcFirewallControlPolicyProps",
jsii_struct_bases=[],
name_mapping={
"acl_action": "aclAction",
"application_name": "applicationName",
"description": "description",
"destination": "destination",
"destination_type": "destinationType",
"new_order": "newOrder",
"proto": "proto",
"source": "source",
"source_type": "sourceType",
"vpc_firewall_id": "vpcFirewallId",
"dest_port": "destPort",
"dest_port_group": "destPortGroup",
"dest_port_type": "destPortType",
"lang": "lang",
"region_id": "regionId",
},
)
class RosVpcFirewallControlPolicyProps:
def __init__(
self,
*,
acl_action: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
application_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
description: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
destination: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
destination_type: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
new_order: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
proto: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
source: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
source_type: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
vpc_firewall_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
dest_port: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
dest_port_group: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
dest_port_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
lang: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
region_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::CLOUDFW::VpcFirewallControlPolicy``.
:param acl_action:
:param application_name:
:param description:
:param destination:
:param destination_type:
:param new_order:
:param proto:
:param source:
:param source_type:
:param vpc_firewall_id:
:param dest_port:
:param dest_port_group:
:param dest_port_type:
:param lang:
:param region_id:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__57de059de0eaf5505e96950f7a983c3f53222bfaa47b923bf388ff26c2186d9b)
check_type(argname="argument acl_action", value=acl_action, expected_type=type_hints["acl_action"])
check_type(argname="argument application_name", value=application_name, expected_type=type_hints["application_name"])
check_type(argname="argument description", value=description, expected_type=type_hints["description"])
check_type(argname="argument destination", value=destination, expected_type=type_hints["destination"])
check_type(argname="argument destination_type", value=destination_type, expected_type=type_hints["destination_type"])
check_type(argname="argument new_order", value=new_order, expected_type=type_hints["new_order"])
check_type(argname="argument proto", value=proto, expected_type=type_hints["proto"])
check_type(argname="argument source", value=source, expected_type=type_hints["source"])
check_type(argname="argument source_type", value=source_type, expected_type=type_hints["source_type"])
check_type(argname="argument vpc_firewall_id", value=vpc_firewall_id, expected_type=type_hints["vpc_firewall_id"])
check_type(argname="argument dest_port", value=dest_port, expected_type=type_hints["dest_port"])
check_type(argname="argument dest_port_group", value=dest_port_group, expected_type=type_hints["dest_port_group"])
check_type(argname="argument dest_port_type", value=dest_port_type, expected_type=type_hints["dest_port_type"])
check_type(argname="argument lang", value=lang, expected_type=type_hints["lang"])
check_type(argname="argument region_id", value=region_id, expected_type=type_hints["region_id"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"acl_action": acl_action,
"application_name": application_name,
"description": description,
"destination": destination,
"destination_type": destination_type,
"new_order": new_order,
"proto": proto,
"source": source,
"source_type": source_type,
"vpc_firewall_id": vpc_firewall_id,
}
if dest_port is not None:
self._values["dest_port"] = dest_port
if dest_port_group is not None:
self._values["dest_port_group"] = dest_port_group
if dest_port_type is not None:
self._values["dest_port_type"] = dest_port_type
if lang is not None:
self._values["lang"] = lang
if region_id is not None:
self._values["region_id"] = region_id
@builtins.property
def acl_action(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
aclAction: The action that Cloud Firewall performs on the traffic. Valid values:
accept: allows the traffic.
drop: denies the traffic.
log: monitors the traffic.
'''
result = self._values.get("acl_action")
assert result is not None, "Required property 'acl_action' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def application_name(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
applicationName: The application type that the access control policy supports.
Valid values:
ANY (indicates that all application types are supported)
FTP
HTTP
HTTPS
MySQL
SMTP
SMTPS
RDP
VNC
SSH
Redis
MQTT
MongoDB
Memcache
SSL
'''
result = self._values.get("application_name")
assert result is not None, "Required property 'application_name' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def description(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: description: The description of the access control policy.
'''
result = self._values.get("description")
assert result is not None, "Required property 'description' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def destination(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
destination: The destination address in the access control policy.
Set this parameter in the following way:
If the DestinationType parameter is set to net, set the value to a Classless Inter-Domain Routing (CIDR) block.
Example: 10.2.3.0/24.
If the DestinationType parameter is set to group, set the value to the name of an address book.
Example: db_group.
If the DestinationType parameter is set to domain, set the value to a domain name.
Example: *.aliyuncs.com.
'''
result = self._values.get("destination")
assert result is not None, "Required property 'destination' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def destination_type(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
destinationType: The type of the destination address in the access control policy. Valid values:
net: CIDR block
group: address book
domain: domain name
'''
result = self._values.get("destination_type")
assert result is not None, "Required property 'destination_type' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def new_order(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
newOrder: The priority of the access control policy.
The priority value starts from 1. A smaller priority value indicates a higher priority.
Note The value of -1 indicates the lowest priority.
'''
result = self._values.get("new_order")
assert result is not None, "Required property 'new_order' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def proto(self) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: proto: The type of the security protocol in the access control policy.
'''
result = self._values.get("proto")
assert result is not None, "Required property 'proto' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def source(self) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
source: The source address in the access control policy.
If the SourceType parameter is set to net, set the value to a CIDR block. Example: 10.2.3.0/24.
If the SourceType parameter is set to group, set the value to the name of an address book. Example: db_group.
'''
result = self._values.get("source")
assert result is not None, "Required property 'source' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def source_type(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
sourceType: The type of the source address in the access control policy. Valid values:
net: CIDR block
group: address book
'''
result = self._values.get("source_type")
assert result is not None, "Required property 'source_type' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def vpc_firewall_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
vpcFirewallId: The ID of the policy group to which you want to add the access control policy.
If the VPC firewall is used to protect CEN, set the value to the ID of the CEN instance
that the VPC firewall protects. Example: cen-ervw5jbw1234*****.
If the VPC firewall is used to protect Express Connect, set the value to the ID of
the VPC firewall instance. Example: vfw-a42bbb748c91234*****.
Note You can call the DescribeVpcFirewallAclGroupList operation to query the ID of the policy group.
'''
result = self._values.get("vpc_firewall_id")
assert result is not None, "Required property 'vpc_firewall_id' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def dest_port(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
destPort: The destination port in the access control policy.
Note This parameter must be specified if the DestPortType parameter is set to port.
'''
result = self._values.get("dest_port")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def dest_port_group(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
destPortGroup: The address book of destination ports in the access control policy.
Note This parameter must be specified if the DestPortType parameter is set to group.
'''
result = self._values.get("dest_port_group")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def dest_port_type(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
destPortType: The type of the destination port in the access control policy. Valid values:
port: port
group: address book
'''
result = self._values.get("dest_port_type")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def lang(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
lang: The natural language of the request and response. Valid values:
zh: Chinese
en: English
'''
result = self._values.get("lang")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def region_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: regionId: Region ID. Default to cn-hangzhou.
'''
result = self._values.get("region_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "RosVpcFirewallControlPolicyProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class VpcFirewallControlPolicy(
_ros_cdk_core_7adfd82f.Resource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-cloudfw.VpcFirewallControlPolicy",
):
'''A ROS resource type: ``ALIYUN::CLOUDFW::VpcFirewallControlPolicy``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["VpcFirewallControlPolicyProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
'''Create a new ``ALIYUN::CLOUDFW::VpcFirewallControlPolicy``.
Param scope - scope in which this resource is defined
Param id - scoped id of the resource
Param props - resource properties
:param scope: -
:param id: -
:param props: -
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__103237e016fdd08288a48de94867c0ecb53fe4b809a6d0da5b31bdffe91c6f75)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@builtins.property
@jsii.member(jsii_name="attrAclUuid")
def attr_acl_uuid(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute AclUuid: The unique ID of the access control policy.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrAclUuid"))
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-cloudfw.VpcFirewallControlPolicyProps",
jsii_struct_bases=[],
name_mapping={
"acl_action": "aclAction",
"application_name": "applicationName",
"description": "description",
"destination": "destination",
"destination_type": "destinationType",
"new_order": "newOrder",
"proto": "proto",
"source": "source",
"source_type": "sourceType",
"vpc_firewall_id": "vpcFirewallId",
"dest_port": "destPort",
"dest_port_group": "destPortGroup",
"dest_port_type": "destPortType",
"lang": "lang",
"region_id": "regionId",
},
)
class VpcFirewallControlPolicyProps:
def __init__(
self,
*,
acl_action: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
application_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
description: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
destination: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
destination_type: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
new_order: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
proto: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
source: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
source_type: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
vpc_firewall_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
dest_port: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
dest_port_group: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
dest_port_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
lang: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
region_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::CLOUDFW::VpcFirewallControlPolicy``.
:param acl_action: Property aclAction: The action that Cloud Firewall performs on the traffic. Valid values: accept: allows the traffic. drop: denies the traffic. log: monitors the traffic.
:param application_name: Property applicationName: The application type that the access control policy supports. Valid values: ANY (indicates that all application types are supported) FTP HTTP HTTPS MySQL SMTP SMTPS RDP VNC SSH Redis MQTT MongoDB Memcache SSL
:param description: Property description: The description of the access control policy.
:param destination: Property destination: The destination address in the access control policy. Set this parameter in the following way: If the DestinationType parameter is set to net, set the value to a Classless Inter-Domain Routing (CIDR) block. Example: 10.2.3.0/24. If the DestinationType parameter is set to group, set the value to the name of an address book. Example: db_group. If the DestinationType parameter is set to domain, set the value to a domain name. Example: *.aliyuncs.com.
:param destination_type: Property destinationType: The type of the destination address in the access control policy. Valid values: net: CIDR block group: address book domain: domain name
:param new_order: Property newOrder: The priority of the access control policy. The priority value starts from 1. A smaller priority value indicates a higher priority. Note The value of -1 indicates the lowest priority.
:param proto: Property proto: The type of the security protocol in the access control policy.
:param source: Property source: The source address in the access control policy. If the SourceType parameter is set to net, set the value to a CIDR block. Example: 10.2.3.0/24. If the SourceType parameter is set to group, set the value to the name of an address book. Example: db_group.
:param source_type: Property sourceType: The type of the source address in the access control policy. Valid values: net: CIDR block group: address book
:param vpc_firewall_id: Property vpcFirewallId: The ID of the policy group to which you want to add the access control policy. If the VPC firewall is used to protect CEN, set the value to the ID of the CEN instance that the VPC firewall protects. Example: cen-ervw5jbw1234*****. If the VPC firewall is used to protect Express Connect, set the value to the ID of the VPC firewall instance. Example: vfw-a42bbb748c91234*****. Note You can call the DescribeVpcFirewallAclGroupList operation to query the ID of the policy group.
:param dest_port: Property destPort: The destination port in the access control policy. Note This parameter must be specified if the DestPortType parameter is set to port.
:param dest_port_group: Property destPortGroup: The address book of destination ports in the access control policy. Note This parameter must be specified if the DestPortType parameter is set to group.
:param dest_port_type: Property destPortType: The type of the destination port in the access control policy. Valid values: port: port group: address book
:param lang: Property lang: The natural language of the request and response. Valid values: zh: Chinese en: English
:param region_id: Property regionId: Region ID. Default to cn-hangzhou.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__2fb36318f0736b578a6f26d6fd6f3668db0389dcf8143a1ea23ac8d7dc0ae413)
check_type(argname="argument acl_action", value=acl_action, expected_type=type_hints["acl_action"])
check_type(argname="argument application_name", value=application_name, expected_type=type_hints["application_name"])
check_type(argname="argument description", value=description, expected_type=type_hints["description"])
check_type(argname="argument destination", value=destination, expected_type=type_hints["destination"])
check_type(argname="argument destination_type", value=destination_type, expected_type=type_hints["destination_type"])
check_type(argname="argument new_order", value=new_order, expected_type=type_hints["new_order"])
check_type(argname="argument proto", value=proto, expected_type=type_hints["proto"])
check_type(argname="argument source", value=source, expected_type=type_hints["source"])
check_type(argname="argument source_type", value=source_type, expected_type=type_hints["source_type"])
check_type(argname="argument vpc_firewall_id", value=vpc_firewall_id, expected_type=type_hints["vpc_firewall_id"])
check_type(argname="argument dest_port", value=dest_port, expected_type=type_hints["dest_port"])
check_type(argname="argument dest_port_group", value=dest_port_group, expected_type=type_hints["dest_port_group"])
check_type(argname="argument dest_port_type", value=dest_port_type, expected_type=type_hints["dest_port_type"])
check_type(argname="argument lang", value=lang, expected_type=type_hints["lang"])
check_type(argname="argument region_id", value=region_id, expected_type=type_hints["region_id"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"acl_action": acl_action,
"application_name": application_name,
"description": description,
"destination": destination,
"destination_type": destination_type,
"new_order": new_order,
"proto": proto,
"source": source,
"source_type": source_type,
"vpc_firewall_id": vpc_firewall_id,
}
if dest_port is not None:
self._values["dest_port"] = dest_port
if dest_port_group is not None:
self._values["dest_port_group"] = dest_port_group
if dest_port_type is not None:
self._values["dest_port_type"] = dest_port_type
if lang is not None:
self._values["lang"] = lang
if region_id is not None:
self._values["region_id"] = region_id
@builtins.property
def acl_action(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property aclAction: The action that Cloud Firewall performs on the traffic.
Valid values:
accept: allows the traffic.
drop: denies the traffic.
log: monitors the traffic.
'''
result = self._values.get("acl_action")
assert result is not None, "Required property 'acl_action' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def application_name(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property applicationName: The application type that the access control policy supports.
Valid values:
ANY (indicates that all application types are supported)
FTP
HTTP
HTTPS
MySQL
SMTP
SMTPS
RDP
VNC
SSH
Redis
MQTT
MongoDB
Memcache
SSL
'''
result = self._values.get("application_name")
assert result is not None, "Required property 'application_name' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def description(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property description: The description of the access control policy.'''
result = self._values.get("description")
assert result is not None, "Required property 'description' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def destination(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property destination: The destination address in the access control policy.
Set this parameter in the following way:
If the DestinationType parameter is set to net, set the value to a Classless Inter-Domain Routing (CIDR) block.
Example: 10.2.3.0/24.
If the DestinationType parameter is set to group, set the value to the name of an address book.
Example: db_group.
If the DestinationType parameter is set to domain, set the value to a domain name.
Example: *.aliyuncs.com.
'''
result = self._values.get("destination")
assert result is not None, "Required property 'destination' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def destination_type(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property destinationType: The type of the destination address in the access control policy.
Valid values:
net: CIDR block
group: address book
domain: domain name
'''
result = self._values.get("destination_type")
assert result is not None, "Required property 'destination_type' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def new_order(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property newOrder: The priority of the access control policy.
The priority value starts from 1. A smaller priority value indicates a higher priority.
Note The value of -1 indicates the lowest priority.
'''
result = self._values.get("new_order")
assert result is not None, "Required property 'new_order' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def proto(self) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property proto: The type of the security protocol in the access control policy.'''
result = self._values.get("proto")
assert result is not None, "Required property 'proto' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def source(self) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property source: The source address in the access control policy.
If the SourceType parameter is set to net, set the value to a CIDR block. Example: 10.2.3.0/24.
If the SourceType parameter is set to group, set the value to the name of an address book. Example: db_group.
'''
result = self._values.get("source")
assert result is not None, "Required property 'source' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def source_type(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property sourceType: The type of the source address in the access control policy.
Valid values:
net: CIDR block
group: address book
'''
result = self._values.get("source_type")
assert result is not None, "Required property 'source_type' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def vpc_firewall_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property vpcFirewallId: The ID of the policy group to which you want to add the access control policy.
If the VPC firewall is used to protect CEN, set the value to the ID of the CEN instance
that the VPC firewall protects. Example: cen-ervw5jbw1234*****.
If the VPC firewall is used to protect Express Connect, set the value to the ID of
the VPC firewall instance. Example: vfw-a42bbb748c91234*****.
Note You can call the DescribeVpcFirewallAclGroupList operation to query the ID of the policy group.
'''
result = self._values.get("vpc_firewall_id")
assert result is not None, "Required property 'vpc_firewall_id' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def dest_port(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property destPort: The destination port in the access control policy.
Note This parameter must be specified if the DestPortType parameter is set to port.
'''
result = self._values.get("dest_port")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def dest_port_group(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property destPortGroup: The address book of destination ports in the access control policy.
Note This parameter must be specified if the DestPortType parameter is set to group.
'''
result = self._values.get("dest_port_group")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def dest_port_type(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property destPortType: The type of the destination port in the access control policy.
Valid values:
port: port
group: address book
'''
result = self._values.get("dest_port_type")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def lang(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property lang: The natural language of the request and response.
Valid values:
zh: Chinese
en: English
'''
result = self._values.get("lang")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def region_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property regionId: Region ID.
Default to cn-hangzhou.
'''
result = self._values.get("region_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "VpcFirewallControlPolicyProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
__all__ = [
"AddressBook",
"AddressBookProps",
"ControlPolicy",
"ControlPolicyProps",
"RosAddressBook",
"RosAddressBookProps",
"RosControlPolicy",
"RosControlPolicyProps",
"RosVpcFirewallControlPolicy",
"RosVpcFirewallControlPolicyProps",
"VpcFirewallControlPolicy",
"VpcFirewallControlPolicyProps",
]
publication.publish()
def _typecheckingstub__271a635ebc1744b887b2c9866532a1b2037a9f07cd701ded648279b1462ba0d8(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[AddressBookProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__3048effdb5c7b0cfdfaaa89788fbfe08ce785eb8a5fd4cc81182082b27f80ad1(
*,
description: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
group_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
group_type: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
address_list: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
auto_add_tag_ecs: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
region_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
tag_list: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union[RosAddressBook.TagListProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
tag_relation: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__07a5501d83aab148499db9690ba914742ec2ccb48465a9a4ff4accf4e476c112(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[ControlPolicyProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__a6c97798b19d98d15e94ace72d5a086540e0056a4ded86896b51b7212bff79b9(
*,
acl_action: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
application_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
description: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
destination: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
destination_type: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
direction: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
new_order: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
proto: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
source: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
source_type: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
dest_port: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
dest_port_group: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
dest_port_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
region_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__47f238772a3ed56e5bd977485bb50c171c63c336b9e0a8a4b2ddd05b19bf9a55(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[RosAddressBookProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__a28c30da64daf931477a5cb3d6cd1e445ee006dd686f54b70dc36fd302321418(
props: typing.Mapping[builtins.str, typing.Any],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__6e3920913a84268ddc2456bc7a56275ee9c3e4a078ea673fdd38c1c141702147(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__40ec77e3e0d96355ae15403b2dec6fc4cdefd1e0f5bdfe36d244b34ce27a98b3(
value: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__c916728d1fea76c23a23151bfa3f83ea6a1b3c8cbf7dbb953fca12105455adcc(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__1319722c91e9e07c2a11cef6ce87907d4697dde028ec426e87d5517573229cf9(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__007b989906d00a2b3cda650fbb5c6ddfcbf109b8dc06baffe61e847b6e67a7bc(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__d84710d1be3e7b76a99b3be7991e10250c01747737d2511e9e5672641141a50f(
value: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__50e743014fc32b58b8d7923a74dcd4333617c71e5a24579d9851d9c5b468f94d(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__a2a22f4b278eac71ceaf69aa66296f893b53f86b5492e34a347ccd0e10e434ae(
value: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, RosAddressBook.TagListProperty]]]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__9c3c2a7100caf425a0bf4bfd343bf5e97d805535717cf02d5120498a80de450d(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__33015f906f965c083c31a4652a4853f6e347810a8faf2e3744d6d85571f38eb1(
*,
tag_key: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
tag_value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__e3cf010e328c81ee26cf437f875ace412d595bafd7e726edc690c1a35b0ad9b1(
*,
description: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
group_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
group_type: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
address_list: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
auto_add_tag_ecs: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
region_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
tag_list: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union[RosAddressBook.TagListProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
tag_relation: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__ddb42ae0f4276889be14ab33bcf5c1d4908ee7dfa4c92d0c808c823467c11b88(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[RosControlPolicyProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__b502996760daf29c694d9da3445f1693e3edbff7a719ebb68f5ad3d11a021baf(
props: typing.Mapping[builtins.str, typing.Any],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__42842dd2e28d3eff251f2a0cdff50c37502ee238166042901966e367cafefef5(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__dfe2bd60e25abb0616a3a0e7947b03f7a77d96fbee9017276db1ea2154be9857(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__59d032dfb5f91df7823d38447e8019f408abd26cc3ad5a3a169d4f0f583c7498(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__3a61c02e970f47e08c374e6fdc11378f213c372d085bf3ea26993277f6319fda(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__69fb67318d48840c9e78267377b07ee06dff87d4913ecbb64f55c62ffdd66ee4(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__79cdcb681e3cfc3d6e0e06fa6784adf9a836d82431b955b0498ac21267b3437a(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__b0f06a85be4b568a46b0d4bd2eba77b57b009049cc2f9575a0f209ee60e3a648(
value: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__b95cd8c29eb0cf4492a951b5c61b7231d6a339c21c226363bd24f4226e55de7f(
value: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__c9f2ea3043880e9ea1314654a21e5063f59606eade0cbf9b14e4e1072396d41d(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__31c67a5274e30d043eefc4eb90e744f7b863a37e140f154510e9b2c8946d9024(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__279eb9d1c7ff0047070f05521c15358f0c430707db906fe35426b61044ef109c(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__1726089d1212398c4c172279ad11effbe9a7bd440284ed75a082b32cf4e9cc13(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__5016bb41f3d7f459b47ce3946d741256804eea606e1056300415c1631f938a6c(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__57ef585ab5d10af54f015c43e44f3ebb2303095d7e3808b28e2e9af452fc7955(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__d213af605db6a677bf73e6abba066285635197e958432109f0db098010c3202a(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__1b0597838817cd28ec192aedb55f20a5dccb9153f1ecd07ffb4d2d889ef27f04(
*,
acl_action: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
application_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
description: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
destination: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
destination_type: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
direction: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
new_order: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
proto: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
source: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
source_type: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
dest_port: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
dest_port_group: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
dest_port_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
region_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__7dce15297ae1a1ffa21fd1485c595a9499c8947815ae36eadccfb0e23066b11f(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[RosVpcFirewallControlPolicyProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__39423d0ca0dd5f5089fc5ca7754afc41b8f51d8b14cbcf43b5b8aed31782a466(
props: typing.Mapping[builtins.str, typing.Any],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__1d228e200dafe7406841a2cc4ca75dc8842dff16f5f32598ff91d7b33368c35f(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__599c39b3a7815e06aa3526411ea576dcdbe893faf5a3b5874355d12e40c88e73(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__9977897a275c257529d1fffe0c95179e09a2addcaf52fdeb2574a7a764539271(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__9791ee1ad40b5c6e3507d13467fb8b4f557079ebb82a59b2a9a0599ac7b325f0(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__955776c7ef3e15b187ae67076581b5e521ae8f25b47771b7d56e5874d7ab4eab(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__1a58ebad222e9627cff03be30322be10428bf6a1c1b4d8ca0f32821832071238(
value: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__6f4ea5f8ae5d283dd505c49e11e0fff427ab76fff5e0e8a100713f4f0b29a4c4(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__bb8fdd2e47281677f7f57862d0408ea97540aeb81b32d449665114c1f7249722(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__5097c79a903a5a21ea153e82556cb1b28c15f4b0573a9befac96ba0cc025ba3c(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__c87571e178d1228070b70a459c16287059d72396cf55ed6402a7664167ea7e73(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__7592edf3640f58b1a2f728d625d9a0e01c76b8c4ad735fa0b0a2eb0a2ffe3f18(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__51b0d526f445c26a21691bbc90c8cec5ad275fd0060a321adffe31413fed1d62(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__3177838aaa2ed0a2c3baf5fab49270536b64a426677e852adb30b7b65d83060f(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__d502738f836acc24dbda31663a7589f36a4423e88544148803ebcd1b722a22c9(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__96d999d2420828e537e4e75c270ee3181087edca0f79df47ca34defcba99fe8a(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__d3f90392eefb4dcc20c36b3189d0986cf82004cebfded3dbefd96dbf5a7f3800(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__57de059de0eaf5505e96950f7a983c3f53222bfaa47b923bf388ff26c2186d9b(
*,
acl_action: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
application_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
description: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
destination: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
destination_type: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
new_order: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
proto: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
source: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
source_type: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
vpc_firewall_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
dest_port: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
dest_port_group: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
dest_port_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
lang: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
region_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__103237e016fdd08288a48de94867c0ecb53fe4b809a6d0da5b31bdffe91c6f75(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[VpcFirewallControlPolicyProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__2fb36318f0736b578a6f26d6fd6f3668db0389dcf8143a1ea23ac8d7dc0ae413(
*,
acl_action: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
application_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
description: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
destination: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
destination_type: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
new_order: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
proto: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
source: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
source_type: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
vpc_firewall_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
dest_port: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
dest_port_group: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
dest_port_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
lang: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
region_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass | /ros-cdk-cloudfw-1.0.17.tar.gz/ros-cdk-cloudfw-1.0.17/src/ros_cdk_cloudfw/__init__.py | 0.635788 | 0.188212 | __init__.py | pypi |
import abc
import builtins
import datetime
import enum
import typing
import jsii
import publication
import typing_extensions
from typeguard import check_type
from ._jsii import *
import constructs as _constructs_77d1e7e8
import ros_cdk_cxapi as _ros_cdk_cxapi_45dace6b
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-core.AppProps",
jsii_struct_bases=[],
name_mapping={
"auto_synth": "autoSynth",
"context": "context",
"outdir": "outdir",
"runtime_info": "runtimeInfo",
"stack_traces": "stackTraces",
"tree_metadata": "treeMetadata",
},
)
class AppProps:
def __init__(
self,
*,
auto_synth: typing.Optional[builtins.bool] = None,
context: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
outdir: typing.Optional[builtins.str] = None,
runtime_info: typing.Optional[builtins.bool] = None,
stack_traces: typing.Optional[builtins.bool] = None,
tree_metadata: typing.Optional[builtins.bool] = None,
) -> None:
'''Initialization props for apps.
:param auto_synth: Automatically call 'synth()' before the program exits. If you set this, you don't have to call 'synth()' explicitly. Note that this feature is only available for certain programming languages, and calling 'synth()' is still recommended. Default true if running via CDK CLI ('CDK_OUTDIR' is set), 'false' otherwise
:param context: Additional context values for the application. Context set by the CLI or the 'context' key in 'cdk.json' has precedence. Context can be read from any construct using 'node.getContext(key)'. Default: - no additional context
:param outdir: The output directory into which to emit synthesized artifacts. Default - If this value is *not* set, considers the environment variable 'CDK_OUTDIR'. If 'CDK_OUTDIR' is not defined, uses a temp directory.
:param runtime_info: Include runtime versioning information. Default: true runtime info is included unless related comtext is set.
:param stack_traces: Include construct creation stack trace. Default: true stack traces are included unless related context is set.
:param tree_metadata: Include construct tree metadata as part of the Cloud Assembly. Default: true
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__748c8a4f3f80cbb46f7db3d45e1fc62f897a813df65337c1692a26757af6df49)
check_type(argname="argument auto_synth", value=auto_synth, expected_type=type_hints["auto_synth"])
check_type(argname="argument context", value=context, expected_type=type_hints["context"])
check_type(argname="argument outdir", value=outdir, expected_type=type_hints["outdir"])
check_type(argname="argument runtime_info", value=runtime_info, expected_type=type_hints["runtime_info"])
check_type(argname="argument stack_traces", value=stack_traces, expected_type=type_hints["stack_traces"])
check_type(argname="argument tree_metadata", value=tree_metadata, expected_type=type_hints["tree_metadata"])
self._values: typing.Dict[builtins.str, typing.Any] = {}
if auto_synth is not None:
self._values["auto_synth"] = auto_synth
if context is not None:
self._values["context"] = context
if outdir is not None:
self._values["outdir"] = outdir
if runtime_info is not None:
self._values["runtime_info"] = runtime_info
if stack_traces is not None:
self._values["stack_traces"] = stack_traces
if tree_metadata is not None:
self._values["tree_metadata"] = tree_metadata
@builtins.property
def auto_synth(self) -> typing.Optional[builtins.bool]:
'''Automatically call 'synth()' before the program exits.
If you set this, you don't have to call 'synth()' explicitly. Note that
this feature is only available for certain programming languages, and
calling 'synth()' is still recommended.
Default true if running via CDK CLI ('CDK_OUTDIR' is set), 'false'
otherwise
'''
result = self._values.get("auto_synth")
return typing.cast(typing.Optional[builtins.bool], result)
@builtins.property
def context(self) -> typing.Optional[typing.Mapping[builtins.str, builtins.str]]:
'''Additional context values for the application.
Context set by the CLI or the 'context' key in 'cdk.json' has precedence.
Context can be read from any construct using 'node.getContext(key)'.
:default: - no additional context
'''
result = self._values.get("context")
return typing.cast(typing.Optional[typing.Mapping[builtins.str, builtins.str]], result)
@builtins.property
def outdir(self) -> typing.Optional[builtins.str]:
'''The output directory into which to emit synthesized artifacts.
Default - If this value is *not* set, considers the environment variable 'CDK_OUTDIR'.
If 'CDK_OUTDIR' is not defined, uses a temp directory.
'''
result = self._values.get("outdir")
return typing.cast(typing.Optional[builtins.str], result)
@builtins.property
def runtime_info(self) -> typing.Optional[builtins.bool]:
'''Include runtime versioning information.
:default: true runtime info is included unless related comtext is set.
'''
result = self._values.get("runtime_info")
return typing.cast(typing.Optional[builtins.bool], result)
@builtins.property
def stack_traces(self) -> typing.Optional[builtins.bool]:
'''Include construct creation stack trace.
:default: true stack traces are included unless related context is set.
'''
result = self._values.get("stack_traces")
return typing.cast(typing.Optional[builtins.bool], result)
@builtins.property
def tree_metadata(self) -> typing.Optional[builtins.bool]:
'''Include construct tree metadata as part of the Cloud Assembly.
:default: true
'''
result = self._values.get("tree_metadata")
return typing.cast(typing.Optional[builtins.bool], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "AppProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class ConstructNode(
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-core.ConstructNode",
):
'''Represents the construct node in the scope tree.'''
def __init__(
self,
host: "Construct",
scope: "IConstruct",
id: builtins.str,
) -> None:
'''
:param host: -
:param scope: -
:param id: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__6a47bad65275b85b8612877823d54537652d86b16d9cc47c3f0fe2e682cad87e)
check_type(argname="argument host", value=host, expected_type=type_hints["host"])
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
jsii.create(self.__class__, self, [host, scope, id])
@jsii.member(jsii_name="prepare")
@builtins.classmethod
def prepare(cls, node: "ConstructNode") -> None:
'''(deprecated) Invokes "prepare" on all constructs (depth-first, post-order) in the tree under ``node``.
:param node: The root node.
:deprecated: Use ``app.synth()`` instead
:stability: deprecated
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__6645ca4ad5ccd4cd68a4050a9e5c2511fdb248cb9310394c721b1c69950e5975)
check_type(argname="argument node", value=node, expected_type=type_hints["node"])
return typing.cast(None, jsii.sinvoke(cls, "prepare", [node]))
@jsii.member(jsii_name="synth")
@builtins.classmethod
def synth(
cls,
node: "ConstructNode",
*,
outdir: typing.Optional[builtins.str] = None,
skip_validation: typing.Optional[builtins.bool] = None,
runtime_info: typing.Optional[typing.Union[_ros_cdk_cxapi_45dace6b.RuntimeInfo, typing.Dict[builtins.str, typing.Any]]] = None,
) -> _ros_cdk_cxapi_45dace6b.CloudAssembly:
'''(deprecated) Synthesizes a CloudAssembly from a construct tree.
:param node: The root of the construct tree.
:param outdir: (deprecated) The output directory into which to synthesize the cloud assembly. Default: - creates a temporary directory
:param skip_validation: (deprecated) Whether synthesis should skip the validation phase. Default: false
:param runtime_info: Include the specified runtime information (module versions) in manifest. Default: - if this option is not specified, runtime info will not be included
:deprecated: Use ``app.synth()`` or ``stage.synth()`` instead
:stability: deprecated
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__df4441eafb1cb1046b32ca5295d005d3131df919989d3b694d1ce2e3881d2b51)
check_type(argname="argument node", value=node, expected_type=type_hints["node"])
options = SynthesisOptions(
outdir=outdir, skip_validation=skip_validation, runtime_info=runtime_info
)
return typing.cast(_ros_cdk_cxapi_45dace6b.CloudAssembly, jsii.sinvoke(cls, "synth", [node, options]))
@jsii.member(jsii_name="validate")
@builtins.classmethod
def validate(cls, node: "ConstructNode") -> typing.List["ValidationError"]:
'''Invokes "validate" on all constructs in the tree (depth-first, pre-order) and returns the list of all errors.
An empty list indicates that there are no errors.
:param node: The root node.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__15d58cf30911824dccc4b726e85b99d3c5af21fbe85acb679afb5632b9b4410b)
check_type(argname="argument node", value=node, expected_type=type_hints["node"])
return typing.cast(typing.List["ValidationError"], jsii.sinvoke(cls, "validate", [node]))
@jsii.member(jsii_name="addDependency")
def add_dependency(self, *dependencies: "IDependable") -> None:
'''Add an ordering dependency on another Construct.
All constructs in the dependency's scope will be deployed before any
construct in this construct's scope.
:param dependencies: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__4621c8e910f9ed69913adeffe0161d40cfde5ebadeba3e7bd20a4b0cfbfee3b9)
check_type(argname="argument dependencies", value=dependencies, expected_type=typing.Tuple[type_hints["dependencies"], ...]) # pyright: ignore [reportGeneralTypeIssues]
return typing.cast(None, jsii.invoke(self, "addDependency", [*dependencies]))
@jsii.member(jsii_name="addError")
def add_error(self, message: builtins.str) -> None:
'''Adds an { "error": } metadata entry to this construct.
The toolkit will fail synthesis when errors are reported.
:param message: The error message.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__5828fca22ddd84c8c5f392d283078c4556c6a3104e3afda44917f05f086da22f)
check_type(argname="argument message", value=message, expected_type=type_hints["message"])
return typing.cast(None, jsii.invoke(self, "addError", [message]))
@jsii.member(jsii_name="addInfo")
def add_info(self, message: builtins.str) -> None:
'''Adds a { "info": } metadata entry to this construct.
The toolkit will display the info message when apps are synthesized.
:param message: The info message.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__7f520bb9a468976f66105a240b5a66c7ade94873ab55373e1ac571b500c21d6a)
check_type(argname="argument message", value=message, expected_type=type_hints["message"])
return typing.cast(None, jsii.invoke(self, "addInfo", [message]))
@jsii.member(jsii_name="addMetadata")
def add_metadata(
self,
type: builtins.str,
data: typing.Any,
from_function: typing.Any = None,
) -> None:
'''Adds a metadata entry to this construct.
Entries are arbitrary values and will also include a stack trace to allow tracing back to
the code location for when the entry was added. It can be used, for example, to include source
mapping in templates to improve diagnostics.
:param type: a string denoting the type of metadata.
:param data: the value of the metadata (can be a Token). If null/undefined, metadata will not be added.
:param from_function: a function under which to restrict the metadata entry's stack trace (defaults to this.addMetadata).
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__959c55db0db52728d3f598e4c83dd98fc47eb2297c12d34642150aad945923fd)
check_type(argname="argument type", value=type, expected_type=type_hints["type"])
check_type(argname="argument data", value=data, expected_type=type_hints["data"])
check_type(argname="argument from_function", value=from_function, expected_type=type_hints["from_function"])
return typing.cast(None, jsii.invoke(self, "addMetadata", [type, data, from_function]))
@jsii.member(jsii_name="addWarning")
def add_warning(self, message: builtins.str) -> None:
'''Adds a { "warning": } metadata entry to this construct.
The toolkit will display the warning when an app is synthesized, or fail
if run in --strict mode.
:param message: The warning message.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__570f16aaf6d6ed0a36aaf59690d63691db9c638fa7db4426ffff61a3eec2507a)
check_type(argname="argument message", value=message, expected_type=type_hints["message"])
return typing.cast(None, jsii.invoke(self, "addWarning", [message]))
@jsii.member(jsii_name="findAll")
def find_all(
self,
order: typing.Optional["ConstructOrder"] = None,
) -> typing.List["IConstruct"]:
'''Return this construct and all of its children in the given order.
:param order: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__f373a014879a19ab5383814e7c60e2fdc9b85ff481266088ce12f7a126854d60)
check_type(argname="argument order", value=order, expected_type=type_hints["order"])
return typing.cast(typing.List["IConstruct"], jsii.invoke(self, "findAll", [order]))
@jsii.member(jsii_name="findChild")
def find_child(self, id: builtins.str) -> "IConstruct":
'''Return a direct child by id.
Throws an error if the child is not found.
:param id: Identifier of direct child.
:return: Child with the given id.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__d4e9a97593ce9f2c58b87536455eb37e870708a060b383b357d9f6fcb2469e26)
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
return typing.cast("IConstruct", jsii.invoke(self, "findChild", [id]))
@jsii.member(jsii_name="setContext")
def set_context(self, key: builtins.str, value: typing.Any) -> None:
'''This can be used to set contextual values.
Context must be set before any children are added, since children may consult context info during construction.
If the key already exists, it will be overridden.
:param key: The context key.
:param value: The context value.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__5ffc85bdb046e28e24026eca3ca7feb5e1cbec09d4e2d58eb5f259741e0f5805)
check_type(argname="argument key", value=key, expected_type=type_hints["key"])
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
return typing.cast(None, jsii.invoke(self, "setContext", [key, value]))
@jsii.member(jsii_name="tryFindChild")
def try_find_child(self, id: builtins.str) -> typing.Optional["IConstruct"]:
'''Return a direct child by id, or undefined.
:param id: Identifier of direct child.
:return: the child if found, or undefined
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__5cbe01369ed9844edb9ceff08f9f1d6ffdf493083e9de9b90f37b2eb7024c63c)
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
return typing.cast(typing.Optional["IConstruct"], jsii.invoke(self, "tryFindChild", [id]))
@jsii.member(jsii_name="tryGetContext")
def try_get_context(self, key: builtins.str) -> typing.Any:
'''Retrieves a value from tree context.
Context is usually initialized at the root, but can be overridden at any point in the tree.
:param key: The context key.
:return: The context value or ``undefined`` if there is no context value for thie key.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__0d5e8d9fc5378c36b1914ff9ef3d1743c82cf3a6020c5d4b16ef390692134d84)
check_type(argname="argument key", value=key, expected_type=type_hints["key"])
return typing.cast(typing.Any, jsii.invoke(self, "tryGetContext", [key]))
@jsii.member(jsii_name="tryRemoveChild")
def try_remove_child(self, child_name: builtins.str) -> builtins.bool:
'''(experimental) Remove the child with the given name, if present.
:param child_name: -
:return: Whether a child with the given name was deleted.
:stability: experimental
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__4528d4bf540c03795edbfe799321d679a7800f5bda281eb50419a46623ff4eb1)
check_type(argname="argument child_name", value=child_name, expected_type=type_hints["child_name"])
return typing.cast(builtins.bool, jsii.invoke(self, "tryRemoveChild", [child_name]))
@jsii.python.classproperty
@jsii.member(jsii_name="PATH_SEP")
def PATH_SEP(cls) -> builtins.str:
'''Separator used to delimit construct path components.'''
return typing.cast(builtins.str, jsii.sget(cls, "PATH_SEP"))
@builtins.property
@jsii.member(jsii_name="children")
def children(self) -> typing.List["IConstruct"]:
'''All direct children of this construct.'''
return typing.cast(typing.List["IConstruct"], jsii.get(self, "children"))
@builtins.property
@jsii.member(jsii_name="dependencies")
def dependencies(self) -> typing.List["Dependency"]:
'''Return all dependencies registered on this node or any of its children.'''
return typing.cast(typing.List["Dependency"], jsii.get(self, "dependencies"))
@builtins.property
@jsii.member(jsii_name="id")
def id(self) -> builtins.str:
'''The id of this construct within the current scope.
This is a a scope-unique id. To obtain an app-unique id for this construct, use ``uniqueId``.
'''
return typing.cast(builtins.str, jsii.get(self, "id"))
@builtins.property
@jsii.member(jsii_name="locked")
def locked(self) -> builtins.bool:
'''Returns true if this construct or the scopes in which it is defined are locked.'''
return typing.cast(builtins.bool, jsii.get(self, "locked"))
@builtins.property
@jsii.member(jsii_name="metadata")
def metadata(self) -> typing.List[_ros_cdk_cxapi_45dace6b.MetadataEntry]:
'''An immutable array of metadata objects associated with this construct.
This can be used, for example, to implement support for deprecation notices, source mapping, etc.
'''
return typing.cast(typing.List[_ros_cdk_cxapi_45dace6b.MetadataEntry], jsii.get(self, "metadata"))
@builtins.property
@jsii.member(jsii_name="path")
def path(self) -> builtins.str:
'''The full, absolute path of this construct in the tree.
Components are separated by '/'.
'''
return typing.cast(builtins.str, jsii.get(self, "path"))
@builtins.property
@jsii.member(jsii_name="root")
def root(self) -> "IConstruct":
'''
:return: The root of the construct tree.
'''
return typing.cast("IConstruct", jsii.get(self, "root"))
@builtins.property
@jsii.member(jsii_name="scopes")
def scopes(self) -> typing.List["IConstruct"]:
'''All parent scopes of this construct.
:return:
a list of parent scopes. The last element in the list will always
be the current construct and the first element will be the root of the
tree.
'''
return typing.cast(typing.List["IConstruct"], jsii.get(self, "scopes"))
@builtins.property
@jsii.member(jsii_name="uniqueId")
def unique_id(self) -> builtins.str:
'''A tree-global unique alphanumeric identifier for this construct.
Includes all components of the tree.
'''
return typing.cast(builtins.str, jsii.get(self, "uniqueId"))
@builtins.property
@jsii.member(jsii_name="scope")
def scope(self) -> typing.Optional["IConstruct"]:
'''Returns the scope in which this construct is defined.
The value is ``undefined`` at the root of the construct scope tree.
'''
return typing.cast(typing.Optional["IConstruct"], jsii.get(self, "scope"))
@builtins.property
@jsii.member(jsii_name="defaultChild")
def default_child(self) -> typing.Optional["IConstruct"]:
'''Returns the child construct that has the id ``Default`` or ``Resource"``.
This is usually the construct that provides the bulk of the underlying functionality.
Useful for modifications of the underlying construct that are not available at the higher levels.
Override the defaultChild property.
This should only be used in the cases where the correct
default child is not named 'Resource' or 'Default' as it
should be.
If you set this to undefined, the default behavior of finding
the child named 'Resource' or 'Default' will be used.
:return: a construct or undefined if there is no default child
:throws: if there is more than one child
'''
return typing.cast(typing.Optional["IConstruct"], jsii.get(self, "defaultChild"))
@default_child.setter
def default_child(self, value: typing.Optional["IConstruct"]) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__1122548f7c053a88310186a509d813226fa408734e0b465c5934441a333f1cf4)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "defaultChild", value)
@jsii.enum(jsii_type="@alicloud/ros-cdk-core.ConstructOrder")
class ConstructOrder(enum.Enum):
'''In what order to return constructs.'''
PREORDER = "PREORDER"
'''Depth-first, pre-order.'''
POSTORDER = "POSTORDER"
'''Depth-first, post-order (leaf nodes first).'''
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-core.DefaultStackSynthesizerProps",
jsii_struct_bases=[],
name_mapping={"qualifier": "qualifier"},
)
class DefaultStackSynthesizerProps:
def __init__(self, *, qualifier: typing.Optional[builtins.str] = None) -> None:
'''Configuration properties for DefaultStackSynthesizer.
:param qualifier: Qualifier to disambiguate multiple environments in the same account. You can use this and leave the other naming properties empty if you have deployed the bootstrap environment with standard names but only differnet qualifiers.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__ba524959d80a1a88eee86a3a039a209594e07b39da331bb1cafb9fc849c5a97d)
check_type(argname="argument qualifier", value=qualifier, expected_type=type_hints["qualifier"])
self._values: typing.Dict[builtins.str, typing.Any] = {}
if qualifier is not None:
self._values["qualifier"] = qualifier
@builtins.property
def qualifier(self) -> typing.Optional[builtins.str]:
'''Qualifier to disambiguate multiple environments in the same account.
You can use this and leave the other naming properties empty if you have deployed
the bootstrap environment with standard names but only differnet qualifiers.
'''
result = self._values.get("qualifier")
return typing.cast(typing.Optional[builtins.str], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "DefaultStackSynthesizerProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class DependableTrait(
metaclass=jsii.JSIIAbstractClass,
jsii_type="@alicloud/ros-cdk-core.DependableTrait",
):
'''(experimental) Trait for IDependable.
Traits are interfaces that are privately implemented by objects. Instead of
showing up in the public interface of a class, they need to be queried
explicitly. This is used to implement certain framework features that are
not intended to be used by Construct consumers, and so should be hidden
from accidental use.
:stability: experimental
Example::
// Usage
const roots = DependableTrait.get(construct).dependencyRoots;
// Definition
DependableTrait.implement(construct, {
get dependencyRoots() { return []; }
});
'''
def __init__(self) -> None:
jsii.create(self.__class__, self, [])
@jsii.member(jsii_name="get")
@builtins.classmethod
def get(cls, instance: "IDependable") -> "DependableTrait":
'''(experimental) Return the matching DependableTrait for the given class instance.
:param instance: -
:stability: experimental
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__be877a98a70eaf2e415053ecc3597f54d82bf1b02ab801068be53d34c3645e0b)
check_type(argname="argument instance", value=instance, expected_type=type_hints["instance"])
return typing.cast("DependableTrait", jsii.sinvoke(cls, "get", [instance]))
@jsii.member(jsii_name="implement")
@builtins.classmethod
def implement(cls, instance: "IDependable", trait: "DependableTrait") -> None:
'''(experimental) Register ``instance`` to have the given DependableTrait.
Should be called in the class constructor.
:param instance: -
:param trait: -
:stability: experimental
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__27f51d221a1d3f0592bfeaf5e954b8d1ed157c843e51a32099396c3c78cc123d)
check_type(argname="argument instance", value=instance, expected_type=type_hints["instance"])
check_type(argname="argument trait", value=trait, expected_type=type_hints["trait"])
return typing.cast(None, jsii.sinvoke(cls, "implement", [instance, trait]))
@builtins.property
@jsii.member(jsii_name="dependencyRoots")
@abc.abstractmethod
def dependency_roots(self) -> typing.List["IConstruct"]:
'''(experimental) The set of constructs that form the root of this dependable.
All resources under all returned constructs are included in the ordering
dependency.
:stability: experimental
'''
...
class _DependableTraitProxy(DependableTrait):
@builtins.property
@jsii.member(jsii_name="dependencyRoots")
def dependency_roots(self) -> typing.List["IConstruct"]:
'''(experimental) The set of constructs that form the root of this dependable.
All resources under all returned constructs are included in the ordering
dependency.
:stability: experimental
'''
return typing.cast(typing.List["IConstruct"], jsii.get(self, "dependencyRoots"))
# Adding a "__jsii_proxy_class__(): typing.Type" function to the abstract class
typing.cast(typing.Any, DependableTrait).__jsii_proxy_class__ = lambda : _DependableTraitProxy
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-core.Dependency",
jsii_struct_bases=[],
name_mapping={"source": "source", "target": "target"},
)
class Dependency:
def __init__(self, *, source: "IConstruct", target: "IConstruct") -> None:
'''A single dependency.
:param source: Source the dependency.
:param target: Target of the dependency.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__be971e1a5b7d053e1a29fe327cce65a823280ff9c0231b2ae0a5de6c0c9cafaa)
check_type(argname="argument source", value=source, expected_type=type_hints["source"])
check_type(argname="argument target", value=target, expected_type=type_hints["target"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"source": source,
"target": target,
}
@builtins.property
def source(self) -> "IConstruct":
'''Source the dependency.'''
result = self._values.get("source")
assert result is not None, "Required property 'source' is missing"
return typing.cast("IConstruct", result)
@builtins.property
def target(self) -> "IConstruct":
'''Target of the dependency.'''
result = self._values.get("target")
assert result is not None, "Required property 'target' is missing"
return typing.cast("IConstruct", result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "Dependency(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-core.EncodingOptions",
jsii_struct_bases=[],
name_mapping={"display_hint": "displayHint"},
)
class EncodingOptions:
def __init__(self, *, display_hint: typing.Optional[builtins.str] = None) -> None:
'''Properties to string encodings.
:param display_hint: A hint for the Token's purpose when stringifying it.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__592ddd870eea1153b99934c7382cc772fd9c62743fc04f026567e47d474c14a6)
check_type(argname="argument display_hint", value=display_hint, expected_type=type_hints["display_hint"])
self._values: typing.Dict[builtins.str, typing.Any] = {}
if display_hint is not None:
self._values["display_hint"] = display_hint
@builtins.property
def display_hint(self) -> typing.Optional[builtins.str]:
'''A hint for the Token's purpose when stringifying it.'''
result = self._values.get("display_hint")
return typing.cast(typing.Optional[builtins.str], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "EncodingOptions(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class Fn(metaclass=jsii.JSIIMeta, jsii_type="@alicloud/ros-cdk-core.Fn"):
'''Resource Orchestration Service intrinsic functions.
https://help.aliyun.com/document_detail/28852.html
'''
@jsii.member(jsii_name="add")
@builtins.classmethod
def add(
cls,
values: typing.Union[jsii.Number, typing.Sequence[typing.Any], typing.Mapping[builtins.str, typing.Any]],
) -> "IResolvable":
'''
:param values: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__c4463aa739260d8ce63c1fc5c0d0104b648438afea3cc84fd0508ce2ff89e41d)
check_type(argname="argument values", value=values, expected_type=type_hints["values"])
return typing.cast("IResolvable", jsii.sinvoke(cls, "add", [values]))
@jsii.member(jsii_name="avg")
@builtins.classmethod
def avg(
cls,
ndigits: jsii.Number,
values: typing.Sequence[jsii.Number],
) -> jsii.Number:
'''
:param ndigits: -
:param values: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__c4603e8d5b00df56f000c5dadb14d841aa452846777e902e565f1c0b2decdd8c)
check_type(argname="argument ndigits", value=ndigits, expected_type=type_hints["ndigits"])
check_type(argname="argument values", value=values, expected_type=type_hints["values"])
return typing.cast(jsii.Number, jsii.sinvoke(cls, "avg", [ndigits, values]))
@jsii.member(jsii_name="base64Decode")
@builtins.classmethod
def base64_decode(cls, data: builtins.str) -> builtins.str:
'''
:param data: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__5654a30fb1a45859f496027acf7a03d482124e055620291bac9e02da204e9cb6)
check_type(argname="argument data", value=data, expected_type=type_hints["data"])
return typing.cast(builtins.str, jsii.sinvoke(cls, "base64Decode", [data]))
@jsii.member(jsii_name="base64Encode")
@builtins.classmethod
def base64_encode(cls, data: builtins.str) -> builtins.str:
'''The intrinsic function ``Fn::Base64`` returns the Base64 representation of the input string.
:param data: The string value you want to convert to Base64.
:return: a token represented as a string
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__ce3856953e5d2815bfc23c0d182df0cf035b30feda4d849f172136dd500a32a0)
check_type(argname="argument data", value=data, expected_type=type_hints["data"])
return typing.cast(builtins.str, jsii.sinvoke(cls, "base64Encode", [data]))
@jsii.member(jsii_name="calculate")
@builtins.classmethod
def calculate(
cls,
values: builtins.str,
ndigits: jsii.Number,
para: typing.Sequence[jsii.Number],
) -> jsii.Number:
'''
:param values: -
:param ndigits: -
:param para: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__247d1bde91a0d2f5bdbe0d77b1d77116951cc7a286d8876b7ee3c841e3d01986)
check_type(argname="argument values", value=values, expected_type=type_hints["values"])
check_type(argname="argument ndigits", value=ndigits, expected_type=type_hints["ndigits"])
check_type(argname="argument para", value=para, expected_type=type_hints["para"])
return typing.cast(jsii.Number, jsii.sinvoke(cls, "calculate", [values, ndigits, para]))
@jsii.member(jsii_name="conditionAnd")
@builtins.classmethod
def condition_and(
cls,
*conditions: typing.Union[builtins.str, "IRosConditionExpression"],
) -> "IRosConditionExpression":
'''Returns true if all the specified conditions evaluate to true, or returns false if any one of the conditions evaluates to false.
``Fn::And`` acts as
an AND operator. The minimum number of conditions that you can include is
2, and the maximum is 10.
:param conditions: conditions to AND.
:return: an FnCondition token
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__1d3b053d7bd2380d1777011cb385769042414d91dcd1ac5c5d4126a11fb6ced7)
check_type(argname="argument conditions", value=conditions, expected_type=typing.Tuple[type_hints["conditions"], ...]) # pyright: ignore [reportGeneralTypeIssues]
return typing.cast("IRosConditionExpression", jsii.sinvoke(cls, "conditionAnd", [*conditions]))
@jsii.member(jsii_name="conditionEquals")
@builtins.classmethod
def condition_equals(
cls,
lhs: typing.Any,
rhs: typing.Any,
) -> "IRosConditionExpression":
'''Compares if two values are equal.
Returns true if the two values are equal
or false if they aren't.
:param lhs: A value of any type that you want to compare.
:param rhs: A value of any type that you want to compare.
:return: an FnCondition token
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__c32d8c967b76fe1b22006921d766d24460ced611ddaeca23b0cef97797df9dee)
check_type(argname="argument lhs", value=lhs, expected_type=type_hints["lhs"])
check_type(argname="argument rhs", value=rhs, expected_type=type_hints["rhs"])
return typing.cast("IRosConditionExpression", jsii.sinvoke(cls, "conditionEquals", [lhs, rhs]))
@jsii.member(jsii_name="conditionIf")
@builtins.classmethod
def condition_if(
cls,
condition_id: typing.Union[builtins.str, "IRosConditionExpression"],
value_if_true: typing.Any,
value_if_false: typing.Any,
) -> typing.Any:
'''Returns one value if the specified condition evaluates to true and another value if the specified condition evaluates to false.
:param condition_id: A reference to a condition in the Conditions section. Use the condition's name to reference it.
:param value_if_true: A value to be returned if the specified condition evaluates to true.
:param value_if_false: A value to be returned if the specified condition evaluates to false.
:return: an FnCondition token
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__98d6a20e1d755c3448e9346d51da27f01a171bd61c63ea885517e0002d03b1c1)
check_type(argname="argument condition_id", value=condition_id, expected_type=type_hints["condition_id"])
check_type(argname="argument value_if_true", value=value_if_true, expected_type=type_hints["value_if_true"])
check_type(argname="argument value_if_false", value=value_if_false, expected_type=type_hints["value_if_false"])
return typing.cast(typing.Any, jsii.sinvoke(cls, "conditionIf", [condition_id, value_if_true, value_if_false]))
@jsii.member(jsii_name="conditionNot")
@builtins.classmethod
def condition_not(
cls,
condition: typing.Union[builtins.str, "IRosConditionExpression"],
) -> "IRosConditionExpression":
'''Returns true for a condition that evaluates to false or returns false for a condition that evaluates to true.
``Fn::Not`` acts as a NOT operator.
:param condition: A condition such as ``Fn::Equals`` that evaluates to true or false.
:return: an FnCondition token
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__d0f1efc96374482cd77e5e775be7aaf6b0826705fbb51a9778b524db9beb7f5b)
check_type(argname="argument condition", value=condition, expected_type=type_hints["condition"])
return typing.cast("IRosConditionExpression", jsii.sinvoke(cls, "conditionNot", [condition]))
@jsii.member(jsii_name="conditionOr")
@builtins.classmethod
def condition_or(
cls,
*conditions: typing.Union[builtins.str, "IRosConditionExpression"],
) -> "IRosConditionExpression":
'''Returns true if any one of the specified conditions evaluate to true, or returns false if all of the conditions evaluates to false.
``Fn::Or`` acts
as an OR operator. The minimum number of conditions that you can include is
2, and the maximum is 10.
:param conditions: conditions that evaluates to true or false.
:return: an FnCondition token
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__87426609e3c35a1db0e27d2a3800878e1f22676645588ff18f69707d682c3b90)
check_type(argname="argument conditions", value=conditions, expected_type=typing.Tuple[type_hints["conditions"], ...]) # pyright: ignore [reportGeneralTypeIssues]
return typing.cast("IRosConditionExpression", jsii.sinvoke(cls, "conditionOr", [*conditions]))
@jsii.member(jsii_name="findInMap")
@builtins.classmethod
def find_in_map(
cls,
map_name: builtins.str,
top_level_key: builtins.str,
second_level_key: builtins.str,
) -> "IResolvable":
'''The intrinsic function ``Fn::FindInMap`` returns the value corresponding to keys in a two-level map that is declared in the Mappings section.
:param map_name: -
:param top_level_key: -
:param second_level_key: -
:return: a token represented as a string
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__483847ae80b6d31323ba40a393751618bf0a768d1d766b45ec2a6e9a1c81cbfa)
check_type(argname="argument map_name", value=map_name, expected_type=type_hints["map_name"])
check_type(argname="argument top_level_key", value=top_level_key, expected_type=type_hints["top_level_key"])
check_type(argname="argument second_level_key", value=second_level_key, expected_type=type_hints["second_level_key"])
return typing.cast("IResolvable", jsii.sinvoke(cls, "findInMap", [map_name, top_level_key, second_level_key]))
@jsii.member(jsii_name="getAtt")
@builtins.classmethod
def get_att(
cls,
logical_name_of_resource: builtins.str,
attribute_name: builtins.str,
) -> "IResolvable":
'''The ``Fn::GetAtt`` intrinsic function returns the value of an attribute from a resource in the template.
:param logical_name_of_resource: The logical name (also called logical ID) of the resource that contains the attribute that you want.
:param attribute_name: The name of the resource-specific attribute whose value you want. See the resource's reference page for details about the attributes available for that resource type.
:return: an IResolvable object
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__8c616186d3b472030fc6ff0709da54ba8f4263acff902f4e13dc63abddb12693)
check_type(argname="argument logical_name_of_resource", value=logical_name_of_resource, expected_type=type_hints["logical_name_of_resource"])
check_type(argname="argument attribute_name", value=attribute_name, expected_type=type_hints["attribute_name"])
return typing.cast("IResolvable", jsii.sinvoke(cls, "getAtt", [logical_name_of_resource, attribute_name]))
@jsii.member(jsii_name="getAzs")
@builtins.classmethod
def get_azs(cls, region: builtins.str) -> typing.List[builtins.str]:
'''The intrinsic function ``Fn::GetAZs`` returns an array that lists Availability Zones for a specified region.
Because customers have access to
different Availability Zones, the intrinsic function ``Fn::GetAZs`` enables
template authors to write templates that adapt to the calling user's
access. That way you don't have to hard-code a full list of Availability
Zones for a specified region.
:param region: The name of the region for which you want to get the Availability Zones. You can use the ROS::Region pseudo parameter to specify the region in which the stack is created. Specifying an empty string is equivalent to specifying ROS::Region.
:return: a token represented as a string array
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__d5df40a11802df885fed03fa5ee963ab074e2dd8e1f13cd43d87df7b9facfb9c)
check_type(argname="argument region", value=region, expected_type=type_hints["region"])
return typing.cast(typing.List[builtins.str], jsii.sinvoke(cls, "getAzs", [region]))
@jsii.member(jsii_name="getJsonValue")
@builtins.classmethod
def get_json_value(cls, key: builtins.str, json_data: typing.Any) -> builtins.str:
'''
:param key: -
:param json_data: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__9bec0ea9134fb15498bbd9212d243dbe6cb81310293221509061e9dbe3df6313)
check_type(argname="argument key", value=key, expected_type=type_hints["key"])
check_type(argname="argument json_data", value=json_data, expected_type=type_hints["json_data"])
return typing.cast(builtins.str, jsii.sinvoke(cls, "getJsonValue", [key, json_data]))
@jsii.member(jsii_name="getStackOutput")
@builtins.classmethod
def get_stack_output(
cls,
stack_id: builtins.str,
output_key: builtins.str,
stack_region: typing.Optional[builtins.str] = None,
) -> "IResolvable":
'''The intrinsic function ``Fn::GetStackOutput`` returns the value of an output exported by another stack.
:param stack_id: -
:param output_key: -
:param stack_region: -
:return: a token represented as a string
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__ffa0ab99cd7d646eb78d61ad0b07aa230afdb88914c828db09aaab14cf714839)
check_type(argname="argument stack_id", value=stack_id, expected_type=type_hints["stack_id"])
check_type(argname="argument output_key", value=output_key, expected_type=type_hints["output_key"])
check_type(argname="argument stack_region", value=stack_region, expected_type=type_hints["stack_region"])
return typing.cast("IResolvable", jsii.sinvoke(cls, "getStackOutput", [stack_id, output_key, stack_region]))
@jsii.member(jsii_name="join")
@builtins.classmethod
def join(
cls,
delimiter: builtins.str,
list_of_values: typing.Sequence[builtins.str],
) -> builtins.str:
'''The intrinsic function ``Fn::Join`` appends a set of values into a single value, separated by the specified delimiter.
If a delimiter is the empty
string, the set of values are concatenated with no delimiter.
:param delimiter: The value you want to occur between fragments. The delimiter will occur between fragments only. It will not terminate the final value.
:param list_of_values: The list of values you want combined.
:return: a token represented as a string
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__88f3fc6721043fc599f60ea05b463881dcf4075d5127c09179c02a1690454ef0)
check_type(argname="argument delimiter", value=delimiter, expected_type=type_hints["delimiter"])
check_type(argname="argument list_of_values", value=list_of_values, expected_type=type_hints["list_of_values"])
return typing.cast(builtins.str, jsii.sinvoke(cls, "join", [delimiter, list_of_values]))
@jsii.member(jsii_name="jq")
@builtins.classmethod
def jq(
cls,
method: builtins.str,
script: builtins.str,
input_string: typing.Union[builtins.str, typing.Mapping[builtins.str, typing.Any]],
) -> "IResolvable":
'''
:param method: -
:param script: -
:param input_string: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__0bf918016f24f24d6d8d161b6d860b5a0b5506fe4d57b968ce44fea4797441b7)
check_type(argname="argument method", value=method, expected_type=type_hints["method"])
check_type(argname="argument script", value=script, expected_type=type_hints["script"])
check_type(argname="argument input_string", value=input_string, expected_type=type_hints["input_string"])
return typing.cast("IResolvable", jsii.sinvoke(cls, "jq", [method, script, input_string]))
@jsii.member(jsii_name="listMerge")
@builtins.classmethod
def list_merge(
cls,
value_list: typing.Sequence[typing.Sequence[typing.Any]],
) -> "IResolvable":
'''
:param value_list: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__418ce724afaaaf93016caa6baae8868b58470039ae7a0209173008f801bd0cce)
check_type(argname="argument value_list", value=value_list, expected_type=type_hints["value_list"])
return typing.cast("IResolvable", jsii.sinvoke(cls, "listMerge", [value_list]))
@jsii.member(jsii_name="max")
@builtins.classmethod
def max(cls, values: typing.Sequence[jsii.Number]) -> jsii.Number:
'''
:param values: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__2c2a2d4a102c055ada8b542f1e629eebbdc2c3b23b6ec2f9d3156425c6e0acfe)
check_type(argname="argument values", value=values, expected_type=type_hints["values"])
return typing.cast(jsii.Number, jsii.sinvoke(cls, "max", [values]))
@jsii.member(jsii_name="mergeMapToList")
@builtins.classmethod
def merge_map_to_list(
cls,
map_list: typing.Sequence[typing.Mapping[builtins.str, typing.Sequence[typing.Any]]],
) -> "IResolvable":
'''
:param map_list: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__82b64e548b2fe149619ab5ddf83a2692c9fd8f25ee48e660845b06e12306d617)
check_type(argname="argument map_list", value=map_list, expected_type=type_hints["map_list"])
return typing.cast("IResolvable", jsii.sinvoke(cls, "mergeMapToList", [map_list]))
@jsii.member(jsii_name="min")
@builtins.classmethod
def min(cls, values: typing.Sequence[jsii.Number]) -> jsii.Number:
'''
:param values: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__6fc4584dee600015afe6c6649a88dcc4e525cadcf95374eb87929129b2f3ef1c)
check_type(argname="argument values", value=values, expected_type=type_hints["values"])
return typing.cast(jsii.Number, jsii.sinvoke(cls, "min", [values]))
@jsii.member(jsii_name="ref")
@builtins.classmethod
def ref(cls, logical_name: builtins.str) -> builtins.str:
'''The ``Ref`` intrinsic function returns the value of the specified parameter or resource.
Note that it doesn't validate the logicalName, it mainly serves paremeter/resource reference defined in a ``RosInclude`` template.
:param logical_name: The logical name of a parameter/resource for which you want to retrieve its value.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__5e9634d4ce38e42ffeb12b5d5faf8aa2a239fc7e2f6389ee89c22a433f482341)
check_type(argname="argument logical_name", value=logical_name, expected_type=type_hints["logical_name"])
return typing.cast(builtins.str, jsii.sinvoke(cls, "ref", [logical_name]))
@jsii.member(jsii_name="replace")
@builtins.classmethod
def replace(
cls,
replace_data: typing.Mapping[builtins.str, typing.Any],
content: builtins.str,
) -> builtins.str:
'''
:param replace_data: -
:param content: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__1f093db3c371af0aa55cd98c01151e474879cb90d07575abea0e5cf971413df4)
check_type(argname="argument replace_data", value=replace_data, expected_type=type_hints["replace_data"])
check_type(argname="argument content", value=content, expected_type=type_hints["content"])
return typing.cast(builtins.str, jsii.sinvoke(cls, "replace", [replace_data, content]))
@jsii.member(jsii_name="select")
@builtins.classmethod
def select(
cls,
index: typing.Union[builtins.str, jsii.Number],
array: typing.Any,
) -> "IResolvable":
'''The intrinsic function ``Fn::Select`` returns a single object from a list of objects by index.
:param index: The index of the object to retrieve. This must be a value from zero to N-1, where N represents the number of elements in the array.
:param array: The list of objects to select from. This list must not be null, nor can it have null entries.
:return: a token represented as a string
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__9b26926a5816f273496a6351b2085fc2ed9f3fafe5e2353790c65e10563fcf72)
check_type(argname="argument index", value=index, expected_type=type_hints["index"])
check_type(argname="argument array", value=array, expected_type=type_hints["array"])
return typing.cast("IResolvable", jsii.sinvoke(cls, "select", [index, array]))
@jsii.member(jsii_name="selectMapList")
@builtins.classmethod
def select_map_list(
cls,
key: builtins.str,
map_list: typing.Sequence[typing.Mapping[builtins.str, typing.Any]],
) -> "IResolvable":
'''
:param key: -
:param map_list: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__14777cebe9bed53e78225c85b1b6b1636e8831c632317c0d9b6cec030eb1e31c)
check_type(argname="argument key", value=key, expected_type=type_hints["key"])
check_type(argname="argument map_list", value=map_list, expected_type=type_hints["map_list"])
return typing.cast("IResolvable", jsii.sinvoke(cls, "selectMapList", [key, map_list]))
@jsii.member(jsii_name="split")
@builtins.classmethod
def split(
cls,
delimiter: builtins.str,
source: builtins.str,
) -> typing.List[builtins.str]:
'''To split a string into a list of string values so that you can select an element from the resulting string list, use the ``Fn::Split`` intrinsic function.
Specify the location of splits
with a delimiter, such as , (a comma). After you split a string, use the ``Fn::Select`` function
to pick a specific element.
:param delimiter: A string value that determines where the source string is divided.
:param source: The string value that you want to split.
:return: a token represented as a string array
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__5e40386a7e03a946cc861ea88a3c7bc073d133b957f617719c7c9dc19f966c12)
check_type(argname="argument delimiter", value=delimiter, expected_type=type_hints["delimiter"])
check_type(argname="argument source", value=source, expected_type=type_hints["source"])
return typing.cast(typing.List[builtins.str], jsii.sinvoke(cls, "split", [delimiter, source]))
@jsii.member(jsii_name="str")
@builtins.classmethod
def str(cls, value: typing.Any) -> builtins.str:
'''
:param value: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__00895398044099548c609b2ecdc6200196f3347f2b3473fae8a7dd295d6a55dd)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
return typing.cast(builtins.str, jsii.sinvoke(cls, "str", [value]))
@jsii.member(jsii_name="sub")
@builtins.classmethod
def sub(
cls,
body: builtins.str,
variables: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
) -> builtins.str:
'''The intrinsic function ``Fn::Sub`` substitutes variables in an input string with values that you specify.
In your templates, you can use this function
to construct commands or outputs that include values that aren't available
until you create or update a stack.
:param body: A string with variables that Ros Template substitutes with their associated values at runtime. Write variables as ${MyVarName}. Variables can be template parameter names, resource logical IDs, resource attributes, or a variable in a key-value map. If you specify only template parameter names, resource logical IDs, and resource attributes, don't specify a key-value map.
:param variables: The name of a variable that you included in the String parameter. The value that Ros Template substitutes for the associated variable name at runtime.
:return: a token represented as a string
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__936318f7d306dbbfa94357c01fc7ea166b43b16cc0756f030d327ffe3a409e5c)
check_type(argname="argument body", value=body, expected_type=type_hints["body"])
check_type(argname="argument variables", value=variables, expected_type=type_hints["variables"])
return typing.cast(builtins.str, jsii.sinvoke(cls, "sub", [body, variables]))
@jsii.interface(jsii_type="@alicloud/ros-cdk-core.IAnyProducer")
class IAnyProducer(typing_extensions.Protocol):
'''Interface for lazy untyped value producers.'''
@jsii.member(jsii_name="produce")
def produce(self, context: "IResolveContext") -> typing.Any:
'''Produce the value.
:param context: -
'''
...
class _IAnyProducerProxy:
'''Interface for lazy untyped value producers.'''
__jsii_type__: typing.ClassVar[str] = "@alicloud/ros-cdk-core.IAnyProducer"
@jsii.member(jsii_name="produce")
def produce(self, context: "IResolveContext") -> typing.Any:
'''Produce the value.
:param context: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__c17c877cbc31bd56fc0d0ada8af1359356a47e367984086f30dbdd1e8909805d)
check_type(argname="argument context", value=context, expected_type=type_hints["context"])
return typing.cast(typing.Any, jsii.invoke(self, "produce", [context]))
# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface
typing.cast(typing.Any, IAnyProducer).__jsii_proxy_class__ = lambda : _IAnyProducerProxy
@jsii.interface(jsii_type="@alicloud/ros-cdk-core.IDependable")
class IDependable(typing_extensions.Protocol):
'''Trait marker for classes that can be depended upon.
The presence of this interface indicates that an object has
an ``IDependableTrait`` implementation.
This interface can be used to take an (ordering) dependency on a set of
constructs. An ordering dependency implies that the resources represented by
those constructs are deployed before the resources depending ON them are
deployed.
'''
pass
class _IDependableProxy:
'''Trait marker for classes that can be depended upon.
The presence of this interface indicates that an object has
an ``IDependableTrait`` implementation.
This interface can be used to take an (ordering) dependency on a set of
constructs. An ordering dependency implies that the resources represented by
those constructs are deployed before the resources depending ON them are
deployed.
'''
__jsii_type__: typing.ClassVar[str] = "@alicloud/ros-cdk-core.IDependable"
pass
# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface
typing.cast(typing.Any, IDependable).__jsii_proxy_class__ = lambda : _IDependableProxy
@jsii.interface(jsii_type="@alicloud/ros-cdk-core.IFragmentConcatenator")
class IFragmentConcatenator(typing_extensions.Protocol):
'''(experimental) Function used to concatenate symbols in the target document language.
Interface so it could potentially be exposed over jsii.
:stability: experimental
'''
@jsii.member(jsii_name="join")
def join(self, left: typing.Any, right: typing.Any) -> typing.Any:
'''(experimental) Join the fragment on the left and on the right.
:param left: -
:param right: -
:stability: experimental
'''
...
class _IFragmentConcatenatorProxy:
'''(experimental) Function used to concatenate symbols in the target document language.
Interface so it could potentially be exposed over jsii.
:stability: experimental
'''
__jsii_type__: typing.ClassVar[str] = "@alicloud/ros-cdk-core.IFragmentConcatenator"
@jsii.member(jsii_name="join")
def join(self, left: typing.Any, right: typing.Any) -> typing.Any:
'''(experimental) Join the fragment on the left and on the right.
:param left: -
:param right: -
:stability: experimental
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__0c52de30a7fb0655b01843c16a129e0a7eebacf9016fd797efec15cd3678577a)
check_type(argname="argument left", value=left, expected_type=type_hints["left"])
check_type(argname="argument right", value=right, expected_type=type_hints["right"])
return typing.cast(typing.Any, jsii.invoke(self, "join", [left, right]))
# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface
typing.cast(typing.Any, IFragmentConcatenator).__jsii_proxy_class__ = lambda : _IFragmentConcatenatorProxy
@jsii.interface(jsii_type="@alicloud/ros-cdk-core.IInspectable")
class IInspectable(typing_extensions.Protocol):
'''Interface for examining a construct and exposing metadata.'''
@jsii.member(jsii_name="inspect")
def inspect(self, inspector: "TreeInspector") -> None:
'''Examines construct.
:param inspector: - tree inspector to collect and process attributes.
'''
...
class _IInspectableProxy:
'''Interface for examining a construct and exposing metadata.'''
__jsii_type__: typing.ClassVar[str] = "@alicloud/ros-cdk-core.IInspectable"
@jsii.member(jsii_name="inspect")
def inspect(self, inspector: "TreeInspector") -> None:
'''Examines construct.
:param inspector: - tree inspector to collect and process attributes.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__1465a36c9a263cd138c4c560a149095fbdfecd574cfbe3422439e98c3fbdf2ed)
check_type(argname="argument inspector", value=inspector, expected_type=type_hints["inspector"])
return typing.cast(None, jsii.invoke(self, "inspect", [inspector]))
# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface
typing.cast(typing.Any, IInspectable).__jsii_proxy_class__ = lambda : _IInspectableProxy
@jsii.interface(jsii_type="@alicloud/ros-cdk-core.IListProducer")
class IListProducer(typing_extensions.Protocol):
'''Interface for lazy list producers.'''
@jsii.member(jsii_name="produce")
def produce(
self,
context: "IResolveContext",
) -> typing.Optional[typing.List[builtins.str]]:
'''Produce the list value.
:param context: -
'''
...
class _IListProducerProxy:
'''Interface for lazy list producers.'''
__jsii_type__: typing.ClassVar[str] = "@alicloud/ros-cdk-core.IListProducer"
@jsii.member(jsii_name="produce")
def produce(
self,
context: "IResolveContext",
) -> typing.Optional[typing.List[builtins.str]]:
'''Produce the list value.
:param context: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__767ea28bc08d47b0e1f0d4765fe0bc3f22c8289fee8b2e194da7d57277824f5a)
check_type(argname="argument context", value=context, expected_type=type_hints["context"])
return typing.cast(typing.Optional[typing.List[builtins.str]], jsii.invoke(self, "produce", [context]))
# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface
typing.cast(typing.Any, IListProducer).__jsii_proxy_class__ = lambda : _IListProducerProxy
@jsii.interface(jsii_type="@alicloud/ros-cdk-core.INumberProducer")
class INumberProducer(typing_extensions.Protocol):
'''Interface for lazy number producers.'''
@jsii.member(jsii_name="produce")
def produce(self, context: "IResolveContext") -> typing.Optional[jsii.Number]:
'''Produce the number value.
:param context: -
'''
...
class _INumberProducerProxy:
'''Interface for lazy number producers.'''
__jsii_type__: typing.ClassVar[str] = "@alicloud/ros-cdk-core.INumberProducer"
@jsii.member(jsii_name="produce")
def produce(self, context: "IResolveContext") -> typing.Optional[jsii.Number]:
'''Produce the number value.
:param context: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__0831a2456f0182fa20ecb7b158e0a1186592cd9b986aa74ba61a4a4d1bbc0611)
check_type(argname="argument context", value=context, expected_type=type_hints["context"])
return typing.cast(typing.Optional[jsii.Number], jsii.invoke(self, "produce", [context]))
# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface
typing.cast(typing.Any, INumberProducer).__jsii_proxy_class__ = lambda : _INumberProducerProxy
@jsii.interface(jsii_type="@alicloud/ros-cdk-core.IPostProcessor")
class IPostProcessor(typing_extensions.Protocol):
'''A Token that can post-process the complete resolved value, after resolve() has recursed over it.'''
@jsii.member(jsii_name="postProcess")
def post_process(self, input: typing.Any, context: "IResolveContext") -> typing.Any:
'''Process the completely resolved value, after full recursion/resolution has happened.
:param input: -
:param context: -
'''
...
class _IPostProcessorProxy:
'''A Token that can post-process the complete resolved value, after resolve() has recursed over it.'''
__jsii_type__: typing.ClassVar[str] = "@alicloud/ros-cdk-core.IPostProcessor"
@jsii.member(jsii_name="postProcess")
def post_process(self, input: typing.Any, context: "IResolveContext") -> typing.Any:
'''Process the completely resolved value, after full recursion/resolution has happened.
:param input: -
:param context: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__15f5bff2f879cc4cc32197c0039cad4b57418edeed34a996ca4874cf726ea5d4)
check_type(argname="argument input", value=input, expected_type=type_hints["input"])
check_type(argname="argument context", value=context, expected_type=type_hints["context"])
return typing.cast(typing.Any, jsii.invoke(self, "postProcess", [input, context]))
# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface
typing.cast(typing.Any, IPostProcessor).__jsii_proxy_class__ = lambda : _IPostProcessorProxy
@jsii.interface(jsii_type="@alicloud/ros-cdk-core.IResolvable")
class IResolvable(typing_extensions.Protocol):
'''Interface for values that can be resolvable later.
Tokens are special objects that participate in synthesis.
'''
@builtins.property
@jsii.member(jsii_name="creationStack")
def creation_stack(self) -> typing.List[builtins.str]:
'''The creation stack of this resolvable which will be appended to errors thrown during resolution.
If this returns an empty array the stack will not be attached.
'''
...
@jsii.member(jsii_name="resolve")
def resolve(self, context: "IResolveContext") -> typing.Any:
'''Produce the Token's value at resolution time.
:param context: -
'''
...
@jsii.member(jsii_name="toString")
def to_string(self) -> builtins.str:
'''Return a string representation of this resolvable object.
Returns a reversible string representation.
'''
...
class _IResolvableProxy:
'''Interface for values that can be resolvable later.
Tokens are special objects that participate in synthesis.
'''
__jsii_type__: typing.ClassVar[str] = "@alicloud/ros-cdk-core.IResolvable"
@builtins.property
@jsii.member(jsii_name="creationStack")
def creation_stack(self) -> typing.List[builtins.str]:
'''The creation stack of this resolvable which will be appended to errors thrown during resolution.
If this returns an empty array the stack will not be attached.
'''
return typing.cast(typing.List[builtins.str], jsii.get(self, "creationStack"))
@jsii.member(jsii_name="resolve")
def resolve(self, context: "IResolveContext") -> typing.Any:
'''Produce the Token's value at resolution time.
:param context: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__0955aa64060a165ec5f774d258aa1859e4c9a08ded723ede00b5c1bdc9df52b3)
check_type(argname="argument context", value=context, expected_type=type_hints["context"])
return typing.cast(typing.Any, jsii.invoke(self, "resolve", [context]))
@jsii.member(jsii_name="toString")
def to_string(self) -> builtins.str:
'''Return a string representation of this resolvable object.
Returns a reversible string representation.
'''
return typing.cast(builtins.str, jsii.invoke(self, "toString", []))
# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface
typing.cast(typing.Any, IResolvable).__jsii_proxy_class__ = lambda : _IResolvableProxy
@jsii.interface(jsii_type="@alicloud/ros-cdk-core.IResolveContext")
class IResolveContext(typing_extensions.Protocol):
'''Current resolution context for tokens.'''
@builtins.property
@jsii.member(jsii_name="preparing")
def preparing(self) -> builtins.bool:
'''True when we are still preparing, false if we're rendering the final output.'''
...
@builtins.property
@jsii.member(jsii_name="scope")
def scope(self) -> "IConstruct":
'''The scope from which resolution has been initiated.'''
...
@jsii.member(jsii_name="registerPostProcessor")
def register_post_processor(self, post_processor: IPostProcessor) -> None:
'''Use this postprocessor after the entire token structure has been resolved.
:param post_processor: -
'''
...
@jsii.member(jsii_name="resolve")
def resolve(self, x: typing.Any) -> typing.Any:
'''Resolve an inner object.
:param x: -
'''
...
class _IResolveContextProxy:
'''Current resolution context for tokens.'''
__jsii_type__: typing.ClassVar[str] = "@alicloud/ros-cdk-core.IResolveContext"
@builtins.property
@jsii.member(jsii_name="preparing")
def preparing(self) -> builtins.bool:
'''True when we are still preparing, false if we're rendering the final output.'''
return typing.cast(builtins.bool, jsii.get(self, "preparing"))
@builtins.property
@jsii.member(jsii_name="scope")
def scope(self) -> "IConstruct":
'''The scope from which resolution has been initiated.'''
return typing.cast("IConstruct", jsii.get(self, "scope"))
@jsii.member(jsii_name="registerPostProcessor")
def register_post_processor(self, post_processor: IPostProcessor) -> None:
'''Use this postprocessor after the entire token structure has been resolved.
:param post_processor: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__015447ccb4a9906395b20fd902cabcd4597a590171c08295f278be5342f4e7e3)
check_type(argname="argument post_processor", value=post_processor, expected_type=type_hints["post_processor"])
return typing.cast(None, jsii.invoke(self, "registerPostProcessor", [post_processor]))
@jsii.member(jsii_name="resolve")
def resolve(self, x: typing.Any) -> typing.Any:
'''Resolve an inner object.
:param x: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__20944a7cc00f2136f1d3365c36cfc599ebe106e8d4cdddf174ebbd715657933c)
check_type(argname="argument x", value=x, expected_type=type_hints["x"])
return typing.cast(typing.Any, jsii.invoke(self, "resolve", [x]))
# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface
typing.cast(typing.Any, IResolveContext).__jsii_proxy_class__ = lambda : _IResolveContextProxy
@jsii.interface(jsii_type="@alicloud/ros-cdk-core.IRosConditionExpression")
class IRosConditionExpression(IResolvable, typing_extensions.Protocol):
'''Represents a RosTemplate element that can be used within a Condition.
You can use intrinsic functions, such as ``Fn.conditionIf``,
``Fn.conditionEquals``, and ``Fn.conditionNot``, to conditionally create
stack resources. These conditions are evaluated based on input parameters
that you declare when you create or update a stack. After you define all your
conditions, you can associate them with resources or resource properties in
the Resources and Outputs sections of a template.
'''
pass
class _IRosConditionExpressionProxy(
jsii.proxy_for(IResolvable), # type: ignore[misc]
):
'''Represents a RosTemplate element that can be used within a Condition.
You can use intrinsic functions, such as ``Fn.conditionIf``,
``Fn.conditionEquals``, and ``Fn.conditionNot``, to conditionally create
stack resources. These conditions are evaluated based on input parameters
that you declare when you create or update a stack. After you define all your
conditions, you can associate them with resources or resource properties in
the Resources and Outputs sections of a template.
'''
__jsii_type__: typing.ClassVar[str] = "@alicloud/ros-cdk-core.IRosConditionExpression"
pass
# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface
typing.cast(typing.Any, IRosConditionExpression).__jsii_proxy_class__ = lambda : _IRosConditionExpressionProxy
@jsii.interface(jsii_type="@alicloud/ros-cdk-core.IRosResourceOptions")
class IRosResourceOptions(typing_extensions.Protocol):
@builtins.property
@jsii.member(jsii_name="condition")
def condition(self) -> typing.Optional["RosCondition"]:
'''A condition to associate with this resource.
This means that only if the condition evaluates to 'true' when the stack
is deployed, the resource will be included. This is provided to allow CDK projects to produce legacy templates, but noramlly
there is no need to use it in CDK projects.
'''
...
@condition.setter
def condition(self, value: typing.Optional["RosCondition"]) -> None:
...
@builtins.property
@jsii.member(jsii_name="count")
def count(self) -> typing.Optional[typing.Union[jsii.Number, IResolvable]]:
...
@count.setter
def count(
self,
value: typing.Optional[typing.Union[jsii.Number, IResolvable]],
) -> None:
...
@builtins.property
@jsii.member(jsii_name="deletionPolicy")
def deletion_policy(self) -> typing.Optional["RosDeletionPolicy"]:
'''With the DeletionPolicy attribute you can preserve or (in some cases) backup a resource when its stack is deleted.
You specify a DeletionPolicy attribute for each resource that you want to control. If a resource has no DeletionPolicy
attribute, ROS deletes the resource by default. Note that this capability also applies to update operations
that lead to resources being removed.
'''
...
@deletion_policy.setter
def deletion_policy(self, value: typing.Optional["RosDeletionPolicy"]) -> None:
...
@builtins.property
@jsii.member(jsii_name="description")
def description(self) -> typing.Optional[builtins.str]:
...
@description.setter
def description(self, value: typing.Optional[builtins.str]) -> None:
...
@builtins.property
@jsii.member(jsii_name="metadata")
def metadata(self) -> typing.Optional[typing.Mapping[builtins.str, typing.Any]]:
'''Metadata associated with the ROS resource.
This is not the same as the construct metadata which can be added
using construct.addMetadata(), but would not appear in the ROS template automatically.
'''
...
@metadata.setter
def metadata(
self,
value: typing.Optional[typing.Mapping[builtins.str, typing.Any]],
) -> None:
...
class _IRosResourceOptionsProxy:
__jsii_type__: typing.ClassVar[str] = "@alicloud/ros-cdk-core.IRosResourceOptions"
@builtins.property
@jsii.member(jsii_name="condition")
def condition(self) -> typing.Optional["RosCondition"]:
'''A condition to associate with this resource.
This means that only if the condition evaluates to 'true' when the stack
is deployed, the resource will be included. This is provided to allow CDK projects to produce legacy templates, but noramlly
there is no need to use it in CDK projects.
'''
return typing.cast(typing.Optional["RosCondition"], jsii.get(self, "condition"))
@condition.setter
def condition(self, value: typing.Optional["RosCondition"]) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__6b9af138a0065ab24db0137ba4df5cee7e42b723f07b919cba01deb86f6721d1)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "condition", value)
@builtins.property
@jsii.member(jsii_name="count")
def count(self) -> typing.Optional[typing.Union[jsii.Number, IResolvable]]:
return typing.cast(typing.Optional[typing.Union[jsii.Number, IResolvable]], jsii.get(self, "count"))
@count.setter
def count(
self,
value: typing.Optional[typing.Union[jsii.Number, IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__19ccbf023e632728666a7277d8c6574e3cf45a8648865fbe9b2af9d1ae076fb7)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "count", value)
@builtins.property
@jsii.member(jsii_name="deletionPolicy")
def deletion_policy(self) -> typing.Optional["RosDeletionPolicy"]:
'''With the DeletionPolicy attribute you can preserve or (in some cases) backup a resource when its stack is deleted.
You specify a DeletionPolicy attribute for each resource that you want to control. If a resource has no DeletionPolicy
attribute, ROS deletes the resource by default. Note that this capability also applies to update operations
that lead to resources being removed.
'''
return typing.cast(typing.Optional["RosDeletionPolicy"], jsii.get(self, "deletionPolicy"))
@deletion_policy.setter
def deletion_policy(self, value: typing.Optional["RosDeletionPolicy"]) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__f1cddf5277a3c64108ce0c15fa5faa290e10d8d379815c3af84baaccfc3808ac)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "deletionPolicy", value)
@builtins.property
@jsii.member(jsii_name="description")
def description(self) -> typing.Optional[builtins.str]:
return typing.cast(typing.Optional[builtins.str], jsii.get(self, "description"))
@description.setter
def description(self, value: typing.Optional[builtins.str]) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__35f4c58d13e139e5c6223bdbf53164654b2095b5fd91c1bf7e993bd3dc84140f)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "description", value)
@builtins.property
@jsii.member(jsii_name="metadata")
def metadata(self) -> typing.Optional[typing.Mapping[builtins.str, typing.Any]]:
'''Metadata associated with the ROS resource.
This is not the same as the construct metadata which can be added
using construct.addMetadata(), but would not appear in the ROS template automatically.
'''
return typing.cast(typing.Optional[typing.Mapping[builtins.str, typing.Any]], jsii.get(self, "metadata"))
@metadata.setter
def metadata(
self,
value: typing.Optional[typing.Mapping[builtins.str, typing.Any]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__71a66b9935f95fe5d4e4f70341aa002ed47fa3648ffbbe393e5120f0f1087c43)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "metadata", value)
# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface
typing.cast(typing.Any, IRosResourceOptions).__jsii_proxy_class__ = lambda : _IRosResourceOptionsProxy
@jsii.interface(jsii_type="@alicloud/ros-cdk-core.IStackSynthesizer")
class IStackSynthesizer(typing_extensions.Protocol):
'''Encodes information how a certain Stack should be deployed.'''
@jsii.member(jsii_name="bind")
def bind(self, stack: "Stack") -> None:
'''Bind to the stack this environment is going to be used on.
Must be called before any of the other methods are called.
:param stack: -
'''
...
@jsii.member(jsii_name="synthesizeStackArtifacts")
def synthesize_stack_artifacts(self, session: "ISynthesisSession") -> None:
'''(experimental) Synthesize all artifacts required for the stack into the session.
:param session: -
:stability: experimental
'''
...
class _IStackSynthesizerProxy:
'''Encodes information how a certain Stack should be deployed.'''
__jsii_type__: typing.ClassVar[str] = "@alicloud/ros-cdk-core.IStackSynthesizer"
@jsii.member(jsii_name="bind")
def bind(self, stack: "Stack") -> None:
'''Bind to the stack this environment is going to be used on.
Must be called before any of the other methods are called.
:param stack: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__4a06319e966e22b6794f594e79b9622c69452df8b350eb1db66803917ce61c9c)
check_type(argname="argument stack", value=stack, expected_type=type_hints["stack"])
return typing.cast(None, jsii.invoke(self, "bind", [stack]))
@jsii.member(jsii_name="synthesizeStackArtifacts")
def synthesize_stack_artifacts(self, session: "ISynthesisSession") -> None:
'''(experimental) Synthesize all artifacts required for the stack into the session.
:param session: -
:stability: experimental
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__51447d13933e5456a4c6300399eb55ac5df14f92fa88bc9f6722990b9f25fe80)
check_type(argname="argument session", value=session, expected_type=type_hints["session"])
return typing.cast(None, jsii.invoke(self, "synthesizeStackArtifacts", [session]))
# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface
typing.cast(typing.Any, IStackSynthesizer).__jsii_proxy_class__ = lambda : _IStackSynthesizerProxy
@jsii.interface(jsii_type="@alicloud/ros-cdk-core.IStringProducer")
class IStringProducer(typing_extensions.Protocol):
'''Interface for lazy string producers.'''
@jsii.member(jsii_name="produce")
def produce(self, context: IResolveContext) -> typing.Optional[builtins.str]:
'''Produce the string value.
:param context: -
'''
...
class _IStringProducerProxy:
'''Interface for lazy string producers.'''
__jsii_type__: typing.ClassVar[str] = "@alicloud/ros-cdk-core.IStringProducer"
@jsii.member(jsii_name="produce")
def produce(self, context: IResolveContext) -> typing.Optional[builtins.str]:
'''Produce the string value.
:param context: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__4459cd8f8716a48963ca392c9ef233a3a6f41bb3af29ad7cc2c41f450aa8713d)
check_type(argname="argument context", value=context, expected_type=type_hints["context"])
return typing.cast(typing.Optional[builtins.str], jsii.invoke(self, "produce", [context]))
# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface
typing.cast(typing.Any, IStringProducer).__jsii_proxy_class__ = lambda : _IStringProducerProxy
@jsii.interface(jsii_type="@alicloud/ros-cdk-core.ISynthesisSession")
class ISynthesisSession(typing_extensions.Protocol):
'''Represents a single session of synthesis.
Passed into ``Construct.synthesize()`` methods.
'''
@builtins.property
@jsii.member(jsii_name="assembly")
def assembly(self) -> _ros_cdk_cxapi_45dace6b.CloudAssemblyBuilder:
'''Cloud assembly builder.'''
...
@assembly.setter
def assembly(self, value: _ros_cdk_cxapi_45dace6b.CloudAssemblyBuilder) -> None:
...
@builtins.property
@jsii.member(jsii_name="outdir")
def outdir(self) -> builtins.str:
'''The output directory for this synthesis session.'''
...
@outdir.setter
def outdir(self, value: builtins.str) -> None:
...
class _ISynthesisSessionProxy:
'''Represents a single session of synthesis.
Passed into ``Construct.synthesize()`` methods.
'''
__jsii_type__: typing.ClassVar[str] = "@alicloud/ros-cdk-core.ISynthesisSession"
@builtins.property
@jsii.member(jsii_name="assembly")
def assembly(self) -> _ros_cdk_cxapi_45dace6b.CloudAssemblyBuilder:
'''Cloud assembly builder.'''
return typing.cast(_ros_cdk_cxapi_45dace6b.CloudAssemblyBuilder, jsii.get(self, "assembly"))
@assembly.setter
def assembly(self, value: _ros_cdk_cxapi_45dace6b.CloudAssemblyBuilder) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__1c1cff4576a8245902913886959c7001a767c437b52225234ea1b9baf6a9e05d)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "assembly", value)
@builtins.property
@jsii.member(jsii_name="outdir")
def outdir(self) -> builtins.str:
'''The output directory for this synthesis session.'''
return typing.cast(builtins.str, jsii.get(self, "outdir"))
@outdir.setter
def outdir(self, value: builtins.str) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__d2762b383cd1433befe9d900f9538105bc7ff724b6f3bd94e9babdde6b6b651f)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "outdir", value)
# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface
typing.cast(typing.Any, ISynthesisSession).__jsii_proxy_class__ = lambda : _ISynthesisSessionProxy
@jsii.interface(jsii_type="@alicloud/ros-cdk-core.ITaggable")
class ITaggable(typing_extensions.Protocol):
'''Interface to implement tags.'''
@builtins.property
@jsii.member(jsii_name="tags")
def tags(self) -> "TagManager":
'''TagManager to set, remove and format tags.'''
...
class _ITaggableProxy:
'''Interface to implement tags.'''
__jsii_type__: typing.ClassVar[str] = "@alicloud/ros-cdk-core.ITaggable"
@builtins.property
@jsii.member(jsii_name="tags")
def tags(self) -> "TagManager":
'''TagManager to set, remove and format tags.'''
return typing.cast("TagManager", jsii.get(self, "tags"))
# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface
typing.cast(typing.Any, ITaggable).__jsii_proxy_class__ = lambda : _ITaggableProxy
@jsii.interface(jsii_type="@alicloud/ros-cdk-core.ITemplateOptions")
class ITemplateOptions(typing_extensions.Protocol):
'''ROS template options for a stack.'''
@builtins.property
@jsii.member(jsii_name="description")
def description(self) -> typing.Optional[builtins.str]:
'''Gets or sets the description of this stack.
If provided, it will be included in the ROS template's "Description" attribute.
'''
...
@description.setter
def description(self, value: typing.Optional[builtins.str]) -> None:
...
@builtins.property
@jsii.member(jsii_name="metadata")
def metadata(self) -> typing.Optional[typing.Mapping[builtins.str, typing.Any]]:
'''Metadata associated with the ROS template.'''
...
@metadata.setter
def metadata(
self,
value: typing.Optional[typing.Mapping[builtins.str, typing.Any]],
) -> None:
...
class _ITemplateOptionsProxy:
'''ROS template options for a stack.'''
__jsii_type__: typing.ClassVar[str] = "@alicloud/ros-cdk-core.ITemplateOptions"
@builtins.property
@jsii.member(jsii_name="description")
def description(self) -> typing.Optional[builtins.str]:
'''Gets or sets the description of this stack.
If provided, it will be included in the ROS template's "Description" attribute.
'''
return typing.cast(typing.Optional[builtins.str], jsii.get(self, "description"))
@description.setter
def description(self, value: typing.Optional[builtins.str]) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__014ac8e6afd23cc5d8dbaa362ea76b16a5188f58d5d520c3fb9b08768d065850)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "description", value)
@builtins.property
@jsii.member(jsii_name="metadata")
def metadata(self) -> typing.Optional[typing.Mapping[builtins.str, typing.Any]]:
'''Metadata associated with the ROS template.'''
return typing.cast(typing.Optional[typing.Mapping[builtins.str, typing.Any]], jsii.get(self, "metadata"))
@metadata.setter
def metadata(
self,
value: typing.Optional[typing.Mapping[builtins.str, typing.Any]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__bcca51c7205afe0a4756cb9a5de79e6efe34349870e4aaee85d9de6f3b426dbb)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "metadata", value)
# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface
typing.cast(typing.Any, ITemplateOptions).__jsii_proxy_class__ = lambda : _ITemplateOptionsProxy
@jsii.interface(jsii_type="@alicloud/ros-cdk-core.ITokenMapper")
class ITokenMapper(typing_extensions.Protocol):
'''Interface to apply operation to tokens in a string.
Interface so it can be exported via jsii.
'''
@jsii.member(jsii_name="mapToken")
def map_token(self, t: IResolvable) -> typing.Any:
'''Replace a single token.
:param t: -
'''
...
class _ITokenMapperProxy:
'''Interface to apply operation to tokens in a string.
Interface so it can be exported via jsii.
'''
__jsii_type__: typing.ClassVar[str] = "@alicloud/ros-cdk-core.ITokenMapper"
@jsii.member(jsii_name="mapToken")
def map_token(self, t: IResolvable) -> typing.Any:
'''Replace a single token.
:param t: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__06428b1b28ed30f0c1384a6d5a13aa09e69ba4094155ef9bff2074261f64bc85)
check_type(argname="argument t", value=t, expected_type=type_hints["t"])
return typing.cast(typing.Any, jsii.invoke(self, "mapToken", [t]))
# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface
typing.cast(typing.Any, ITokenMapper).__jsii_proxy_class__ = lambda : _ITokenMapperProxy
@jsii.interface(jsii_type="@alicloud/ros-cdk-core.ITokenResolver")
class ITokenResolver(typing_extensions.Protocol):
'''How to resolve tokens.'''
@jsii.member(jsii_name="resolveList")
def resolve_list(
self,
l: typing.Sequence[builtins.str],
context: IResolveContext,
) -> typing.Any:
'''Resolve a tokenized list.
:param l: -
:param context: -
'''
...
@jsii.member(jsii_name="resolveString")
def resolve_string(
self,
s: "TokenizedStringFragments",
context: IResolveContext,
) -> typing.Any:
'''Resolve a string with at least one stringified token in it.
(May use concatenation)
:param s: -
:param context: -
'''
...
@jsii.member(jsii_name="resolveToken")
def resolve_token(
self,
t: IResolvable,
context: IResolveContext,
post_processor: IPostProcessor,
) -> typing.Any:
'''Resolve a single token.
:param t: -
:param context: -
:param post_processor: -
'''
...
class _ITokenResolverProxy:
'''How to resolve tokens.'''
__jsii_type__: typing.ClassVar[str] = "@alicloud/ros-cdk-core.ITokenResolver"
@jsii.member(jsii_name="resolveList")
def resolve_list(
self,
l: typing.Sequence[builtins.str],
context: IResolveContext,
) -> typing.Any:
'''Resolve a tokenized list.
:param l: -
:param context: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__6e2496293c1d52f1d1a1d7cb90d199bc2d95c0efc70ec58bef81c5e92e78c6c2)
check_type(argname="argument l", value=l, expected_type=type_hints["l"])
check_type(argname="argument context", value=context, expected_type=type_hints["context"])
return typing.cast(typing.Any, jsii.invoke(self, "resolveList", [l, context]))
@jsii.member(jsii_name="resolveString")
def resolve_string(
self,
s: "TokenizedStringFragments",
context: IResolveContext,
) -> typing.Any:
'''Resolve a string with at least one stringified token in it.
(May use concatenation)
:param s: -
:param context: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__ec6d2795c1854413fd11b04f75ac05db5d3e9ebda3e0c44fd5c5519a148c471f)
check_type(argname="argument s", value=s, expected_type=type_hints["s"])
check_type(argname="argument context", value=context, expected_type=type_hints["context"])
return typing.cast(typing.Any, jsii.invoke(self, "resolveString", [s, context]))
@jsii.member(jsii_name="resolveToken")
def resolve_token(
self,
t: IResolvable,
context: IResolveContext,
post_processor: IPostProcessor,
) -> typing.Any:
'''Resolve a single token.
:param t: -
:param context: -
:param post_processor: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__b83a71c854922c76207ee3305ff734b2f1aaa0a7a12636de23ff86f45b756041)
check_type(argname="argument t", value=t, expected_type=type_hints["t"])
check_type(argname="argument context", value=context, expected_type=type_hints["context"])
check_type(argname="argument post_processor", value=post_processor, expected_type=type_hints["post_processor"])
return typing.cast(typing.Any, jsii.invoke(self, "resolveToken", [t, context, post_processor]))
# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface
typing.cast(typing.Any, ITokenResolver).__jsii_proxy_class__ = lambda : _ITokenResolverProxy
@jsii.implements(IResolvable)
class Intrinsic(metaclass=jsii.JSIIMeta, jsii_type="@alicloud/ros-cdk-core.Intrinsic"):
'''(experimental) Token subclass that represents values intrinsic to the target document language.
This class will disappear in a future release and should not be used.
:stability: experimental
'''
def __init__(self, value: typing.Any) -> None:
'''
:param value: -
:stability: experimental
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__f690835f92182062a506fffc4e9d3275914ee37a6eb328a1e03037ac62192123)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.create(self.__class__, self, [value])
@jsii.member(jsii_name="newError")
def _new_error(self, message: builtins.str) -> typing.Any:
'''(experimental) Creates a throwable Error object that contains the token creation stack trace.
:param message: Error message.
:stability: experimental
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__a9d6cb405f1dc003d11ded0e2fcf4924af28d4bb81a501991a861ccc28b25294)
check_type(argname="argument message", value=message, expected_type=type_hints["message"])
return typing.cast(typing.Any, jsii.invoke(self, "newError", [message]))
@jsii.member(jsii_name="resolve")
def resolve(self, _context: IResolveContext) -> typing.Any:
'''(experimental) Produce the Token's value at resolution time.
:param _context: -
:stability: experimental
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__6ed11c272182745b8f071c64a59933a914b55021a02f39aebbbdaed7955fcf4a)
check_type(argname="argument _context", value=_context, expected_type=type_hints["_context"])
return typing.cast(typing.Any, jsii.invoke(self, "resolve", [_context]))
@jsii.member(jsii_name="toJSON")
def to_json(self) -> typing.Any:
'''(experimental) Turn this Token into JSON.
Called automatically when JSON.stringify() is called on a Token.
:stability: experimental
'''
return typing.cast(typing.Any, jsii.invoke(self, "toJSON", []))
@jsii.member(jsii_name="toString")
def to_string(self) -> builtins.str:
'''(experimental) Convert an instance of this Token to a string.
This method will be called implicitly by language runtimes if the object
is embedded into a string. We treat it the same as an explicit
stringification.
:stability: experimental
'''
return typing.cast(builtins.str, jsii.invoke(self, "toString", []))
@builtins.property
@jsii.member(jsii_name="creationStack")
def creation_stack(self) -> typing.List[builtins.str]:
'''(experimental) The captured stack trace which represents the location in which this token was created.
:stability: experimental
'''
return typing.cast(typing.List[builtins.str], jsii.get(self, "creationStack"))
class Lazy(metaclass=jsii.JSIIMeta, jsii_type="@alicloud/ros-cdk-core.Lazy"):
'''Lazily produce a value.
Can be used to return a string, list or numeric value whose actual value
will only be calculated later, during synthesis.
'''
@jsii.member(jsii_name="anyValue")
@builtins.classmethod
def any_value(
cls,
producer: IAnyProducer,
*,
display_hint: typing.Optional[builtins.str] = None,
omit_empty_array: typing.Optional[builtins.bool] = None,
) -> IResolvable:
'''
:param producer: -
:param display_hint: Use the given name as a display hint. Default: - No hint
:param omit_empty_array: If the produced value is an array and it is empty, return 'undefined' instead. Default: false
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__855c3b8f704d5568c58b5eaf5256d1f96e8973533df785d2287a1fa17f8e0625)
check_type(argname="argument producer", value=producer, expected_type=type_hints["producer"])
options = LazyAnyValueOptions(
display_hint=display_hint, omit_empty_array=omit_empty_array
)
return typing.cast(IResolvable, jsii.sinvoke(cls, "anyValue", [producer, options]))
@jsii.member(jsii_name="listValue")
@builtins.classmethod
def list_value(
cls,
producer: IListProducer,
*,
display_hint: typing.Optional[builtins.str] = None,
omit_empty: typing.Optional[builtins.bool] = None,
) -> typing.List[builtins.str]:
'''
:param producer: -
:param display_hint: Use the given name as a display hint. Default: - No hint
:param omit_empty: If the produced list is empty, return 'undefined' instead. Default: false
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__9d27bdcb87429f6c1ad1c6a63e4fa7f37ec6b156995dd935db8c0232ba62cfb1)
check_type(argname="argument producer", value=producer, expected_type=type_hints["producer"])
options = LazyListValueOptions(
display_hint=display_hint, omit_empty=omit_empty
)
return typing.cast(typing.List[builtins.str], jsii.sinvoke(cls, "listValue", [producer, options]))
@jsii.member(jsii_name="numberValue")
@builtins.classmethod
def number_value(cls, producer: INumberProducer) -> jsii.Number:
'''
:param producer: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__eb3d27bb92f07376c0671ce2a29b9e0322a5e620e9e5d9261fcc112c7dd83880)
check_type(argname="argument producer", value=producer, expected_type=type_hints["producer"])
return typing.cast(jsii.Number, jsii.sinvoke(cls, "numberValue", [producer]))
@jsii.member(jsii_name="stringValue")
@builtins.classmethod
def string_value(
cls,
producer: IStringProducer,
*,
display_hint: typing.Optional[builtins.str] = None,
) -> builtins.str:
'''
:param producer: -
:param display_hint: Use the given name as a display hint. Default: - No hint
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__f6b154666a2f7bd28fa1944715b8f57b93cf5a42b94aa1cc51b4c287075e2e6f)
check_type(argname="argument producer", value=producer, expected_type=type_hints["producer"])
options = LazyStringValueOptions(display_hint=display_hint)
return typing.cast(builtins.str, jsii.sinvoke(cls, "stringValue", [producer, options]))
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-core.LazyAnyValueOptions",
jsii_struct_bases=[],
name_mapping={"display_hint": "displayHint", "omit_empty_array": "omitEmptyArray"},
)
class LazyAnyValueOptions:
def __init__(
self,
*,
display_hint: typing.Optional[builtins.str] = None,
omit_empty_array: typing.Optional[builtins.bool] = None,
) -> None:
'''Options for creating lazy untyped tokens.
:param display_hint: Use the given name as a display hint. Default: - No hint
:param omit_empty_array: If the produced value is an array and it is empty, return 'undefined' instead. Default: false
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__459da39148795d4a2ffdb32575cd274897146155c51dea7f0361cb43373e04b7)
check_type(argname="argument display_hint", value=display_hint, expected_type=type_hints["display_hint"])
check_type(argname="argument omit_empty_array", value=omit_empty_array, expected_type=type_hints["omit_empty_array"])
self._values: typing.Dict[builtins.str, typing.Any] = {}
if display_hint is not None:
self._values["display_hint"] = display_hint
if omit_empty_array is not None:
self._values["omit_empty_array"] = omit_empty_array
@builtins.property
def display_hint(self) -> typing.Optional[builtins.str]:
'''Use the given name as a display hint.
:default: - No hint
'''
result = self._values.get("display_hint")
return typing.cast(typing.Optional[builtins.str], result)
@builtins.property
def omit_empty_array(self) -> typing.Optional[builtins.bool]:
'''If the produced value is an array and it is empty, return 'undefined' instead.
:default: false
'''
result = self._values.get("omit_empty_array")
return typing.cast(typing.Optional[builtins.bool], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "LazyAnyValueOptions(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-core.LazyListValueOptions",
jsii_struct_bases=[],
name_mapping={"display_hint": "displayHint", "omit_empty": "omitEmpty"},
)
class LazyListValueOptions:
def __init__(
self,
*,
display_hint: typing.Optional[builtins.str] = None,
omit_empty: typing.Optional[builtins.bool] = None,
) -> None:
'''Options for creating a lazy list token.
:param display_hint: Use the given name as a display hint. Default: - No hint
:param omit_empty: If the produced list is empty, return 'undefined' instead. Default: false
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__f43363319a77742c2083fd9d84db3926afdc535ad84dd79e943bb24b761be25d)
check_type(argname="argument display_hint", value=display_hint, expected_type=type_hints["display_hint"])
check_type(argname="argument omit_empty", value=omit_empty, expected_type=type_hints["omit_empty"])
self._values: typing.Dict[builtins.str, typing.Any] = {}
if display_hint is not None:
self._values["display_hint"] = display_hint
if omit_empty is not None:
self._values["omit_empty"] = omit_empty
@builtins.property
def display_hint(self) -> typing.Optional[builtins.str]:
'''Use the given name as a display hint.
:default: - No hint
'''
result = self._values.get("display_hint")
return typing.cast(typing.Optional[builtins.str], result)
@builtins.property
def omit_empty(self) -> typing.Optional[builtins.bool]:
'''If the produced list is empty, return 'undefined' instead.
:default: false
'''
result = self._values.get("omit_empty")
return typing.cast(typing.Optional[builtins.bool], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "LazyListValueOptions(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-core.LazyStringValueOptions",
jsii_struct_bases=[],
name_mapping={"display_hint": "displayHint"},
)
class LazyStringValueOptions:
def __init__(self, *, display_hint: typing.Optional[builtins.str] = None) -> None:
'''Options for creating a lazy string token.
:param display_hint: Use the given name as a display hint. Default: - No hint
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__11154e9acb99e91fe8a38a92330e2004810b345c011269ed4ae3381d938718d9)
check_type(argname="argument display_hint", value=display_hint, expected_type=type_hints["display_hint"])
self._values: typing.Dict[builtins.str, typing.Any] = {}
if display_hint is not None:
self._values["display_hint"] = display_hint
@builtins.property
def display_hint(self) -> typing.Optional[builtins.str]:
'''Use the given name as a display hint.
:default: - No hint
'''
result = self._values.get("display_hint")
return typing.cast(typing.Optional[builtins.str], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "LazyStringValueOptions(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-core.NestedStackProps",
jsii_struct_bases=[],
name_mapping={
"parameters": "parameters",
"template_body": "templateBody",
"template_url": "templateUrl",
"timeout": "timeout",
},
)
class NestedStackProps:
def __init__(
self,
*,
parameters: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
template_body: typing.Optional[builtins.str] = None,
template_url: typing.Optional[builtins.str] = None,
timeout: typing.Optional[jsii.Number] = None,
) -> None:
'''
:param parameters: -
:param template_body: -
:param template_url: -
:param timeout: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__25327f9b7ddf68f2c9dae74053743641437aa840308c92297b09ca5ce4b2daad)
check_type(argname="argument parameters", value=parameters, expected_type=type_hints["parameters"])
check_type(argname="argument template_body", value=template_body, expected_type=type_hints["template_body"])
check_type(argname="argument template_url", value=template_url, expected_type=type_hints["template_url"])
check_type(argname="argument timeout", value=timeout, expected_type=type_hints["timeout"])
self._values: typing.Dict[builtins.str, typing.Any] = {}
if parameters is not None:
self._values["parameters"] = parameters
if template_body is not None:
self._values["template_body"] = template_body
if template_url is not None:
self._values["template_url"] = template_url
if timeout is not None:
self._values["timeout"] = timeout
@builtins.property
def parameters(self) -> typing.Optional[typing.Mapping[builtins.str, typing.Any]]:
result = self._values.get("parameters")
return typing.cast(typing.Optional[typing.Mapping[builtins.str, typing.Any]], result)
@builtins.property
def template_body(self) -> typing.Optional[builtins.str]:
result = self._values.get("template_body")
return typing.cast(typing.Optional[builtins.str], result)
@builtins.property
def template_url(self) -> typing.Optional[builtins.str]:
result = self._values.get("template_url")
return typing.cast(typing.Optional[builtins.str], result)
@builtins.property
def timeout(self) -> typing.Optional[jsii.Number]:
result = self._values.get("timeout")
return typing.cast(typing.Optional[jsii.Number], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "NestedStackProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class Reference(
Intrinsic,
metaclass=jsii.JSIIAbstractClass,
jsii_type="@alicloud/ros-cdk-core.Reference",
):
'''An intrinsic Token that represents a reference to a construct.
References are recorded.
'''
def __init__(
self,
value: typing.Any,
target: "IConstruct",
display_name: typing.Optional[builtins.str] = None,
) -> None:
'''
:param value: -
:param target: -
:param display_name: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__1f8dc2790577ee818f6a8555fec401bd0e2aad0ca17cbcf1ad940dc9bc4fe6f0)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
check_type(argname="argument target", value=target, expected_type=type_hints["target"])
check_type(argname="argument display_name", value=display_name, expected_type=type_hints["display_name"])
jsii.create(self.__class__, self, [value, target, display_name])
@jsii.member(jsii_name="isReference")
@builtins.classmethod
def is_reference(cls, x: typing.Any) -> builtins.bool:
'''Check whether this is actually a Reference.
:param x: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__ac9bc39f84fa4ed07ec85a081144f2a366bff3352728edce92eb3a3ff10c4f12)
check_type(argname="argument x", value=x, expected_type=type_hints["x"])
return typing.cast(builtins.bool, jsii.sinvoke(cls, "isReference", [x]))
@builtins.property
@jsii.member(jsii_name="displayName")
def display_name(self) -> builtins.str:
return typing.cast(builtins.str, jsii.get(self, "displayName"))
@builtins.property
@jsii.member(jsii_name="target")
def target(self) -> "IConstruct":
return typing.cast("IConstruct", jsii.get(self, "target"))
class _ReferenceProxy(Reference):
pass
# Adding a "__jsii_proxy_class__(): typing.Type" function to the abstract class
typing.cast(typing.Any, Reference).__jsii_proxy_class__ = lambda : _ReferenceProxy
@jsii.enum(jsii_type="@alicloud/ros-cdk-core.RemovalPolicy")
class RemovalPolicy(enum.Enum):
DESTROY = "DESTROY"
RETAIN = "RETAIN"
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-core.RemovalPolicyOptions",
jsii_struct_bases=[],
name_mapping={
"apply_to_update_replace_policy": "applyToUpdateReplacePolicy",
"default_policy": "defaultPolicy",
},
)
class RemovalPolicyOptions:
def __init__(
self,
*,
apply_to_update_replace_policy: typing.Optional[builtins.bool] = None,
default_policy: typing.Optional[RemovalPolicy] = None,
) -> None:
'''
:param apply_to_update_replace_policy: -
:param default_policy: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__555f312cbc4130456a07898da4b77d3db0176039426274e8555cce2bfbd8dfc7)
check_type(argname="argument apply_to_update_replace_policy", value=apply_to_update_replace_policy, expected_type=type_hints["apply_to_update_replace_policy"])
check_type(argname="argument default_policy", value=default_policy, expected_type=type_hints["default_policy"])
self._values: typing.Dict[builtins.str, typing.Any] = {}
if apply_to_update_replace_policy is not None:
self._values["apply_to_update_replace_policy"] = apply_to_update_replace_policy
if default_policy is not None:
self._values["default_policy"] = default_policy
@builtins.property
def apply_to_update_replace_policy(self) -> typing.Optional[builtins.bool]:
result = self._values.get("apply_to_update_replace_policy")
return typing.cast(typing.Optional[builtins.bool], result)
@builtins.property
def default_policy(self) -> typing.Optional[RemovalPolicy]:
result = self._values.get("default_policy")
return typing.cast(typing.Optional[RemovalPolicy], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "RemovalPolicyOptions(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-core.ResolveOptions",
jsii_struct_bases=[],
name_mapping={"resolver": "resolver", "scope": "scope", "preparing": "preparing"},
)
class ResolveOptions:
def __init__(
self,
*,
resolver: ITokenResolver,
scope: "IConstruct",
preparing: typing.Optional[builtins.bool] = None,
) -> None:
'''Options to the resolve() operation.
NOT the same as the ResolveContext; ResolveContext is exposed to Token
implementors and resolution hooks, whereas this struct is just to bundle
a number of things that would otherwise be arguments to resolve() in a
readable way.
:param resolver: The resolver to apply to any resolvable tokens found.
:param scope: The scope from which resolution is performed.
:param preparing: Whether the resolution is being executed during the prepare phase or not. Default: false
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__1cf5324bcb826f8eda6917454783379af5c03bb9882d50455f1f28ea76eabbf3)
check_type(argname="argument resolver", value=resolver, expected_type=type_hints["resolver"])
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument preparing", value=preparing, expected_type=type_hints["preparing"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"resolver": resolver,
"scope": scope,
}
if preparing is not None:
self._values["preparing"] = preparing
@builtins.property
def resolver(self) -> ITokenResolver:
'''The resolver to apply to any resolvable tokens found.'''
result = self._values.get("resolver")
assert result is not None, "Required property 'resolver' is missing"
return typing.cast(ITokenResolver, result)
@builtins.property
def scope(self) -> "IConstruct":
'''The scope from which resolution is performed.'''
result = self._values.get("scope")
assert result is not None, "Required property 'scope' is missing"
return typing.cast("IConstruct", result)
@builtins.property
def preparing(self) -> typing.Optional[builtins.bool]:
'''Whether the resolution is being executed during the prepare phase or not.
:default: false
'''
result = self._values.get("preparing")
return typing.cast(typing.Optional[builtins.bool], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "ResolveOptions(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-core.ResourceProps",
jsii_struct_bases=[],
name_mapping={"physical_name": "physicalName"},
)
class ResourceProps:
def __init__(self, *, physical_name: typing.Optional[builtins.str] = None) -> None:
'''Construction properties for {@link Resource}.
:param physical_name: The value passed in by users to the physical name prop of the resource. - ``undefined`` implies that a physical name will be allocated during deployment. - a concrete value implies a specific physical name - ``PhysicalName.GENERATE_IF_NEEDED`` is a marker that indicates that a physical will only be generated by the CDK if it is needed for cross-environment references. Otherwise, it will be allocated. Default: - The physical name will be allocated at deployment time
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__5eb39483257934b924a474a55b25ee60c39f38148113cb72ba8962bb0da42ada)
check_type(argname="argument physical_name", value=physical_name, expected_type=type_hints["physical_name"])
self._values: typing.Dict[builtins.str, typing.Any] = {}
if physical_name is not None:
self._values["physical_name"] = physical_name
@builtins.property
def physical_name(self) -> typing.Optional[builtins.str]:
'''The value passed in by users to the physical name prop of the resource.
- ``undefined`` implies that a physical name will be allocated during deployment.
- a concrete value implies a specific physical name
- ``PhysicalName.GENERATE_IF_NEEDED`` is a marker that indicates that a physical will only be generated
by the CDK if it is needed for cross-environment references. Otherwise, it will be allocated.
:default: - The physical name will be allocated at deployment time
'''
result = self._values.get("physical_name")
return typing.cast(typing.Optional[builtins.str], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "ResourceProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-core.RosConditionProps",
jsii_struct_bases=[],
name_mapping={"expression": "expression"},
)
class RosConditionProps:
def __init__(
self,
*,
expression: typing.Optional[IRosConditionExpression] = None,
) -> None:
'''
:param expression: The expression that the condition will evaluate. Default: - None.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__f534de3d8e5fcb3d98fa2b9d753eded2ae1398e9c0cfaa50692ce7724b85d774)
check_type(argname="argument expression", value=expression, expected_type=type_hints["expression"])
self._values: typing.Dict[builtins.str, typing.Any] = {}
if expression is not None:
self._values["expression"] = expression
@builtins.property
def expression(self) -> typing.Optional[IRosConditionExpression]:
'''The expression that the condition will evaluate.
:default: - None.
'''
result = self._values.get("expression")
return typing.cast(typing.Optional[IRosConditionExpression], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "RosConditionProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
@jsii.enum(jsii_type="@alicloud/ros-cdk-core.RosDeletionPolicy")
class RosDeletionPolicy(enum.Enum):
'''With the DeletionPolicy attribute you can preserve or (in some cases) backup a resource when its stack is deleted.
You specify a DeletionPolicy attribute for each resource that you want to control. If a resource has no DeletionPolicy
attribute, ROS deletes the resource by default.
'''
DELETE = "DELETE"
'''ROS will deletes the resource and all its content if applicable during stack deletion.
You can add this deletion policy to any resource type.
'''
RETAIN = "RETAIN"
'''ROS keeps the resource without deleting the resource or its contents when its stack is deleted.
You can add this deletion policy to any resource type.
'''
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-core.RosMappingProps",
jsii_struct_bases=[],
name_mapping={"mapping": "mapping"},
)
class RosMappingProps:
def __init__(
self,
*,
mapping: typing.Optional[typing.Mapping[builtins.str, typing.Mapping[builtins.str, typing.Any]]] = None,
) -> None:
'''
:param mapping: Mapping of key to a set of corresponding set of named values. The key identifies a map of name-value pairs and must be unique within the mapping. For example, if you want to set values based on a region, you can create a mapping that uses the region name as a key and contains the values you want to specify for each specific region. Default: - No mapping.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__dcd93622adc1517313de11a1d1758998640b5ec2e8e86746a8317929c727ae61)
check_type(argname="argument mapping", value=mapping, expected_type=type_hints["mapping"])
self._values: typing.Dict[builtins.str, typing.Any] = {}
if mapping is not None:
self._values["mapping"] = mapping
@builtins.property
def mapping(
self,
) -> typing.Optional[typing.Mapping[builtins.str, typing.Mapping[builtins.str, typing.Any]]]:
'''Mapping of key to a set of corresponding set of named values.
The key identifies a map of name-value pairs and must be unique within the mapping.
For example, if you want to set values based on a region, you can create a mapping
that uses the region name as a key and contains the values you want to specify for
each specific region.
:default: - No mapping.
'''
result = self._values.get("mapping")
return typing.cast(typing.Optional[typing.Mapping[builtins.str, typing.Mapping[builtins.str, typing.Any]]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "RosMappingProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-core.RosOutputProps",
jsii_struct_bases=[],
name_mapping={
"value": "value",
"condition": "condition",
"description": "description",
"export_name": "exportName",
},
)
class RosOutputProps:
def __init__(
self,
*,
value: typing.Any,
condition: typing.Optional["RosCondition"] = None,
description: typing.Optional[builtins.str] = None,
export_name: typing.Optional[builtins.str] = None,
) -> None:
'''
:param value: The value of the property returned by Resource Orchestration Service. The value of an output can include literals, parameter references, pseudo-parameters, a mapping value, or intrinsic functions.
:param condition: A condition to associate with this output value. If the condition evaluates to ``false``, this output value will not be included in the stack. Default: - No condition is associated with the output.
:param description: A String type that describes the output value. The description can be a maximum of 4 K in length. Default: - No description.
:param export_name: The name used to export the value of this output across stacks. To import the value from another stack, use ``Fn.importValue(exportName)``. Default: - the output is not exported
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__ee818edecc8dc711db71a3f783f7d205fa34f9482dad186f363524140313425c)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
check_type(argname="argument condition", value=condition, expected_type=type_hints["condition"])
check_type(argname="argument description", value=description, expected_type=type_hints["description"])
check_type(argname="argument export_name", value=export_name, expected_type=type_hints["export_name"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"value": value,
}
if condition is not None:
self._values["condition"] = condition
if description is not None:
self._values["description"] = description
if export_name is not None:
self._values["export_name"] = export_name
@builtins.property
def value(self) -> typing.Any:
'''The value of the property returned by Resource Orchestration Service.
The value of an output can include literals, parameter references, pseudo-parameters,
a mapping value, or intrinsic functions.
'''
result = self._values.get("value")
assert result is not None, "Required property 'value' is missing"
return typing.cast(typing.Any, result)
@builtins.property
def condition(self) -> typing.Optional["RosCondition"]:
'''A condition to associate with this output value.
If the condition evaluates
to ``false``, this output value will not be included in the stack.
:default: - No condition is associated with the output.
'''
result = self._values.get("condition")
return typing.cast(typing.Optional["RosCondition"], result)
@builtins.property
def description(self) -> typing.Optional[builtins.str]:
'''A String type that describes the output value.
The description can be a maximum of 4 K in length.
:default: - No description.
'''
result = self._values.get("description")
return typing.cast(typing.Optional[builtins.str], result)
@builtins.property
def export_name(self) -> typing.Optional[builtins.str]:
'''The name used to export the value of this output across stacks.
To import the value from another stack, use ``Fn.importValue(exportName)``.
:default: - the output is not exported
'''
result = self._values.get("export_name")
return typing.cast(typing.Optional[builtins.str], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "RosOutputProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-core.RosParameterProps",
jsii_struct_bases=[],
name_mapping={
"allowed_pattern": "allowedPattern",
"allowed_values": "allowedValues",
"association_property": "associationProperty",
"association_property_metadata": "associationPropertyMetadata",
"confirm": "confirm",
"constraint_description": "constraintDescription",
"default_value": "defaultValue",
"description": "description",
"label": "label",
"max_length": "maxLength",
"max_value": "maxValue",
"min_length": "minLength",
"min_value": "minValue",
"no_echo": "noEcho",
"text_area": "textArea",
"type": "type",
},
)
class RosParameterProps:
def __init__(
self,
*,
allowed_pattern: typing.Optional[builtins.str] = None,
allowed_values: typing.Optional[typing.Sequence[typing.Any]] = None,
association_property: typing.Optional[builtins.str] = None,
association_property_metadata: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
confirm: typing.Optional[builtins.bool] = None,
constraint_description: typing.Optional[typing.Union[builtins.str, typing.Mapping[builtins.str, builtins.str]]] = None,
default_value: typing.Any = None,
description: typing.Optional[typing.Union[builtins.str, typing.Mapping[builtins.str, builtins.str]]] = None,
label: typing.Optional[builtins.str] = None,
max_length: typing.Optional[jsii.Number] = None,
max_value: typing.Optional[jsii.Number] = None,
min_length: typing.Optional[jsii.Number] = None,
min_value: typing.Optional[jsii.Number] = None,
no_echo: typing.Optional[builtins.bool] = None,
text_area: typing.Optional[builtins.bool] = None,
type: typing.Optional["RosParameterType"] = None,
) -> None:
'''
:param allowed_pattern: -
:param allowed_values: -
:param association_property: -
:param association_property_metadata: -
:param confirm: -
:param constraint_description: -
:param default_value: -
:param description: -
:param label: -
:param max_length: -
:param max_value: -
:param min_length: -
:param min_value: -
:param no_echo: -
:param text_area: -
:param type: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__c39b9c0a543f07fdf20a7f9378ee395653a40289a7101cf922b7de73c8a5047b)
check_type(argname="argument allowed_pattern", value=allowed_pattern, expected_type=type_hints["allowed_pattern"])
check_type(argname="argument allowed_values", value=allowed_values, expected_type=type_hints["allowed_values"])
check_type(argname="argument association_property", value=association_property, expected_type=type_hints["association_property"])
check_type(argname="argument association_property_metadata", value=association_property_metadata, expected_type=type_hints["association_property_metadata"])
check_type(argname="argument confirm", value=confirm, expected_type=type_hints["confirm"])
check_type(argname="argument constraint_description", value=constraint_description, expected_type=type_hints["constraint_description"])
check_type(argname="argument default_value", value=default_value, expected_type=type_hints["default_value"])
check_type(argname="argument description", value=description, expected_type=type_hints["description"])
check_type(argname="argument label", value=label, expected_type=type_hints["label"])
check_type(argname="argument max_length", value=max_length, expected_type=type_hints["max_length"])
check_type(argname="argument max_value", value=max_value, expected_type=type_hints["max_value"])
check_type(argname="argument min_length", value=min_length, expected_type=type_hints["min_length"])
check_type(argname="argument min_value", value=min_value, expected_type=type_hints["min_value"])
check_type(argname="argument no_echo", value=no_echo, expected_type=type_hints["no_echo"])
check_type(argname="argument text_area", value=text_area, expected_type=type_hints["text_area"])
check_type(argname="argument type", value=type, expected_type=type_hints["type"])
self._values: typing.Dict[builtins.str, typing.Any] = {}
if allowed_pattern is not None:
self._values["allowed_pattern"] = allowed_pattern
if allowed_values is not None:
self._values["allowed_values"] = allowed_values
if association_property is not None:
self._values["association_property"] = association_property
if association_property_metadata is not None:
self._values["association_property_metadata"] = association_property_metadata
if confirm is not None:
self._values["confirm"] = confirm
if constraint_description is not None:
self._values["constraint_description"] = constraint_description
if default_value is not None:
self._values["default_value"] = default_value
if description is not None:
self._values["description"] = description
if label is not None:
self._values["label"] = label
if max_length is not None:
self._values["max_length"] = max_length
if max_value is not None:
self._values["max_value"] = max_value
if min_length is not None:
self._values["min_length"] = min_length
if min_value is not None:
self._values["min_value"] = min_value
if no_echo is not None:
self._values["no_echo"] = no_echo
if text_area is not None:
self._values["text_area"] = text_area
if type is not None:
self._values["type"] = type
@builtins.property
def allowed_pattern(self) -> typing.Optional[builtins.str]:
result = self._values.get("allowed_pattern")
return typing.cast(typing.Optional[builtins.str], result)
@builtins.property
def allowed_values(self) -> typing.Optional[typing.List[typing.Any]]:
result = self._values.get("allowed_values")
return typing.cast(typing.Optional[typing.List[typing.Any]], result)
@builtins.property
def association_property(self) -> typing.Optional[builtins.str]:
result = self._values.get("association_property")
return typing.cast(typing.Optional[builtins.str], result)
@builtins.property
def association_property_metadata(
self,
) -> typing.Optional[typing.Mapping[builtins.str, typing.Any]]:
result = self._values.get("association_property_metadata")
return typing.cast(typing.Optional[typing.Mapping[builtins.str, typing.Any]], result)
@builtins.property
def confirm(self) -> typing.Optional[builtins.bool]:
result = self._values.get("confirm")
return typing.cast(typing.Optional[builtins.bool], result)
@builtins.property
def constraint_description(
self,
) -> typing.Optional[typing.Union[builtins.str, typing.Mapping[builtins.str, builtins.str]]]:
result = self._values.get("constraint_description")
return typing.cast(typing.Optional[typing.Union[builtins.str, typing.Mapping[builtins.str, builtins.str]]], result)
@builtins.property
def default_value(self) -> typing.Any:
result = self._values.get("default_value")
return typing.cast(typing.Any, result)
@builtins.property
def description(
self,
) -> typing.Optional[typing.Union[builtins.str, typing.Mapping[builtins.str, builtins.str]]]:
result = self._values.get("description")
return typing.cast(typing.Optional[typing.Union[builtins.str, typing.Mapping[builtins.str, builtins.str]]], result)
@builtins.property
def label(self) -> typing.Optional[builtins.str]:
result = self._values.get("label")
return typing.cast(typing.Optional[builtins.str], result)
@builtins.property
def max_length(self) -> typing.Optional[jsii.Number]:
result = self._values.get("max_length")
return typing.cast(typing.Optional[jsii.Number], result)
@builtins.property
def max_value(self) -> typing.Optional[jsii.Number]:
result = self._values.get("max_value")
return typing.cast(typing.Optional[jsii.Number], result)
@builtins.property
def min_length(self) -> typing.Optional[jsii.Number]:
result = self._values.get("min_length")
return typing.cast(typing.Optional[jsii.Number], result)
@builtins.property
def min_value(self) -> typing.Optional[jsii.Number]:
result = self._values.get("min_value")
return typing.cast(typing.Optional[jsii.Number], result)
@builtins.property
def no_echo(self) -> typing.Optional[builtins.bool]:
result = self._values.get("no_echo")
return typing.cast(typing.Optional[builtins.bool], result)
@builtins.property
def text_area(self) -> typing.Optional[builtins.bool]:
result = self._values.get("text_area")
return typing.cast(typing.Optional[builtins.bool], result)
@builtins.property
def type(self) -> typing.Optional["RosParameterType"]:
result = self._values.get("type")
return typing.cast(typing.Optional["RosParameterType"], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "RosParameterProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
@jsii.enum(jsii_type="@alicloud/ros-cdk-core.RosParameterType")
class RosParameterType(enum.Enum):
STRING = "STRING"
NUMBER = "NUMBER"
JSON = "JSON"
BOOLEAN = "BOOLEAN"
COMMA_DELIMITED_LIST = "COMMA_DELIMITED_LIST"
OOS_PARAMETER = "OOS_PARAMETER"
OOS_SECRET_PARAMETER = "OOS_SECRET_PARAMETER"
class RosPseudo(metaclass=jsii.JSIIMeta, jsii_type="@alicloud/ros-cdk-core.RosPseudo"):
'''Accessor for pseudo parameters.'''
@jsii.python.classproperty
@jsii.member(jsii_name="accountId")
def account_id(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "accountId"))
@jsii.python.classproperty
@jsii.member(jsii_name="index")
def index(cls) -> jsii.Number:
return typing.cast(jsii.Number, jsii.sget(cls, "index"))
@jsii.python.classproperty
@jsii.member(jsii_name="noValue")
def no_value(cls) -> IResolvable:
return typing.cast(IResolvable, jsii.sget(cls, "noValue"))
@jsii.python.classproperty
@jsii.member(jsii_name="region")
def region(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "region"))
@jsii.python.classproperty
@jsii.member(jsii_name="stackId")
def stack_id(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "stackId"))
@jsii.python.classproperty
@jsii.member(jsii_name="stackName")
def stack_name(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "stackName"))
@jsii.python.classproperty
@jsii.member(jsii_name="tenantId")
def tenant_id(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "tenantId"))
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-core.RosResourceProps",
jsii_struct_bases=[],
name_mapping={"type": "type", "properties": "properties"},
)
class RosResourceProps:
def __init__(
self,
*,
type: builtins.str,
properties: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
) -> None:
'''
:param type: ROS template resource type (e.g. ``ALIYUN::ECS::Instance``).
:param properties: Resource properties. Default: - No resource properties.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__8ddbb242164b50fd9890ea53698b2754f764c707d0eda9dcea236241f154b189)
check_type(argname="argument type", value=type, expected_type=type_hints["type"])
check_type(argname="argument properties", value=properties, expected_type=type_hints["properties"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"type": type,
}
if properties is not None:
self._values["properties"] = properties
@builtins.property
def type(self) -> builtins.str:
'''ROS template resource type (e.g. ``ALIYUN::ECS::Instance``).'''
result = self._values.get("type")
assert result is not None, "Required property 'type' is missing"
return typing.cast(builtins.str, result)
@builtins.property
def properties(self) -> typing.Optional[typing.Mapping[builtins.str, typing.Any]]:
'''Resource properties.
:default: - No resource properties.
'''
result = self._values.get("properties")
return typing.cast(typing.Optional[typing.Mapping[builtins.str, typing.Any]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "RosResourceProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-core.RosTag",
jsii_struct_bases=[],
name_mapping={"key": "key", "value": "value"},
)
class RosTag:
def __init__(
self,
*,
key: builtins.str,
value: typing.Optional[builtins.str] = None,
) -> None:
'''
:param key: -
:param value: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__48ebd8113f5a95e7206754d99c94b514bab899631027b98c5b25c87874858e36)
check_type(argname="argument key", value=key, expected_type=type_hints["key"])
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"key": key,
}
if value is not None:
self._values["value"] = value
@builtins.property
def key(self) -> builtins.str:
result = self._values.get("key")
assert result is not None, "Required property 'key' is missing"
return typing.cast(builtins.str, result)
@builtins.property
def value(self) -> typing.Optional[builtins.str]:
result = self._values.get("value")
return typing.cast(typing.Optional[builtins.str], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "RosTag(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-core.StackProps",
jsii_struct_bases=[],
name_mapping={
"description": "description",
"enable_resource_property_constraint": "enableResourcePropertyConstraint",
"metadata": "metadata",
"stack_name": "stackName",
"synthesizer": "synthesizer",
"tags": "tags",
"version": "version",
},
)
class StackProps:
def __init__(
self,
*,
description: typing.Optional[builtins.str] = None,
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
metadata: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
stack_name: typing.Optional[builtins.str] = None,
synthesizer: typing.Optional[IStackSynthesizer] = None,
tags: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
version: typing.Optional[builtins.str] = None,
) -> None:
'''
:param description: A description of the stack. Default: - No description.
:param enable_resource_property_constraint: -
:param metadata: -
:param stack_name: Name to deploy the stack with. Default: - Derived from construct path.
:param synthesizer: Synthesis method to use while deploying this stack. Default: - ``DefaultStackSynthesizer``
:param tags: Stack tags that will be applied to all the taggable resources and the stack itself. Default: {}
:param version: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__a951b9e38e4266f7795d9cf17d13c5cab9723d247372544c2ea0f1e1034a0ddd)
check_type(argname="argument description", value=description, expected_type=type_hints["description"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
check_type(argname="argument metadata", value=metadata, expected_type=type_hints["metadata"])
check_type(argname="argument stack_name", value=stack_name, expected_type=type_hints["stack_name"])
check_type(argname="argument synthesizer", value=synthesizer, expected_type=type_hints["synthesizer"])
check_type(argname="argument tags", value=tags, expected_type=type_hints["tags"])
check_type(argname="argument version", value=version, expected_type=type_hints["version"])
self._values: typing.Dict[builtins.str, typing.Any] = {}
if description is not None:
self._values["description"] = description
if enable_resource_property_constraint is not None:
self._values["enable_resource_property_constraint"] = enable_resource_property_constraint
if metadata is not None:
self._values["metadata"] = metadata
if stack_name is not None:
self._values["stack_name"] = stack_name
if synthesizer is not None:
self._values["synthesizer"] = synthesizer
if tags is not None:
self._values["tags"] = tags
if version is not None:
self._values["version"] = version
@builtins.property
def description(self) -> typing.Optional[builtins.str]:
'''A description of the stack.
:default: - No description.
'''
result = self._values.get("description")
return typing.cast(typing.Optional[builtins.str], result)
@builtins.property
def enable_resource_property_constraint(self) -> typing.Optional[builtins.bool]:
result = self._values.get("enable_resource_property_constraint")
return typing.cast(typing.Optional[builtins.bool], result)
@builtins.property
def metadata(self) -> typing.Optional[typing.Mapping[builtins.str, typing.Any]]:
result = self._values.get("metadata")
return typing.cast(typing.Optional[typing.Mapping[builtins.str, typing.Any]], result)
@builtins.property
def stack_name(self) -> typing.Optional[builtins.str]:
'''Name to deploy the stack with.
:default: - Derived from construct path.
'''
result = self._values.get("stack_name")
return typing.cast(typing.Optional[builtins.str], result)
@builtins.property
def synthesizer(self) -> typing.Optional[IStackSynthesizer]:
'''Synthesis method to use while deploying this stack.
:default: - ``DefaultStackSynthesizer``
'''
result = self._values.get("synthesizer")
return typing.cast(typing.Optional[IStackSynthesizer], result)
@builtins.property
def tags(self) -> typing.Optional[typing.Mapping[builtins.str, builtins.str]]:
'''Stack tags that will be applied to all the taggable resources and the stack itself.
:default: {}
'''
result = self._values.get("tags")
return typing.cast(typing.Optional[typing.Mapping[builtins.str, builtins.str]], result)
@builtins.property
def version(self) -> typing.Optional[builtins.str]:
result = self._values.get("version")
return typing.cast(typing.Optional[builtins.str], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "StackProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-core.StageProps",
jsii_struct_bases=[],
name_mapping={"outdir": "outdir"},
)
class StageProps:
def __init__(self, *, outdir: typing.Optional[builtins.str] = None) -> None:
'''Initialization props for a stage.
:param outdir: The output directory into which to emit synthesized artifacts. Can only be specified if this stage is the root stage the app. If this is specified and this stage is nested within another stage, an error will be thrown. Default - for nested stages, outdir will be determined as a relative directory to the outdir of the app. For apps, if outdir is not specified, a temporary directory will be created.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__0b4d117a06de3b8d93c347567af09a0e7660f43182f1b89b3d9b139dfc7315a8)
check_type(argname="argument outdir", value=outdir, expected_type=type_hints["outdir"])
self._values: typing.Dict[builtins.str, typing.Any] = {}
if outdir is not None:
self._values["outdir"] = outdir
@builtins.property
def outdir(self) -> typing.Optional[builtins.str]:
'''The output directory into which to emit synthesized artifacts.
Can only be specified if this stage is the root stage the app. If this is
specified and this stage is nested within another stage, an error will be
thrown.
Default - for nested stages, outdir will be determined as a relative
directory to the outdir of the app. For apps, if outdir is not specified, a
temporary directory will be created.
'''
result = self._values.get("outdir")
return typing.cast(typing.Optional[builtins.str], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "StageProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-core.StageSynthesisOptions",
jsii_struct_bases=[],
name_mapping={"skip_validation": "skipValidation"},
)
class StageSynthesisOptions:
def __init__(
self,
*,
skip_validation: typing.Optional[builtins.bool] = None,
) -> None:
'''Options for assemly synthesis.
:param skip_validation: Should we skip construct validation. Default: - false
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__4840d4380846528233f8217e18a55e03a4a174196e2c0e4f2e2111b8cfd9d593)
check_type(argname="argument skip_validation", value=skip_validation, expected_type=type_hints["skip_validation"])
self._values: typing.Dict[builtins.str, typing.Any] = {}
if skip_validation is not None:
self._values["skip_validation"] = skip_validation
@builtins.property
def skip_validation(self) -> typing.Optional[builtins.bool]:
'''Should we skip construct validation.
:default: - false
'''
result = self._values.get("skip_validation")
return typing.cast(typing.Optional[builtins.bool], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "StageSynthesisOptions(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
@jsii.implements(IFragmentConcatenator)
class StringConcat(
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-core.StringConcat",
):
'''Converts all fragments to strings and concats those.
Drops 'undefined's.
'''
def __init__(self) -> None:
jsii.create(self.__class__, self, [])
@jsii.member(jsii_name="join")
def join(self, left: typing.Any, right: typing.Any) -> typing.Any:
'''Join the fragment on the left and on the right.
:param left: -
:param right: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__aeb329831e76fa2de1f9eedf7841ce46f3da80065f0977e8f9f2d47cf23f4827)
check_type(argname="argument left", value=left, expected_type=type_hints["left"])
check_type(argname="argument right", value=right, expected_type=type_hints["right"])
return typing.cast(typing.Any, jsii.invoke(self, "join", [left, right]))
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-core.SynthesisOptions",
jsii_struct_bases=[_ros_cdk_cxapi_45dace6b.AssemblyBuildOptions],
name_mapping={
"runtime_info": "runtimeInfo",
"outdir": "outdir",
"skip_validation": "skipValidation",
},
)
class SynthesisOptions(_ros_cdk_cxapi_45dace6b.AssemblyBuildOptions):
def __init__(
self,
*,
runtime_info: typing.Optional[typing.Union[_ros_cdk_cxapi_45dace6b.RuntimeInfo, typing.Dict[builtins.str, typing.Any]]] = None,
outdir: typing.Optional[builtins.str] = None,
skip_validation: typing.Optional[builtins.bool] = None,
) -> None:
'''(deprecated) Options for synthesis.
:param runtime_info: Include the specified runtime information (module versions) in manifest. Default: - if this option is not specified, runtime info will not be included
:param outdir: (deprecated) The output directory into which to synthesize the cloud assembly. Default: - creates a temporary directory
:param skip_validation: (deprecated) Whether synthesis should skip the validation phase. Default: false
:deprecated: use ``app.synth()`` or ``stage.synth()`` instead
:stability: deprecated
'''
if isinstance(runtime_info, dict):
runtime_info = _ros_cdk_cxapi_45dace6b.RuntimeInfo(**runtime_info)
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__b34253714854164c90ac2f1ce4bd38e20e18b53c45053e143999cad2d528be12)
check_type(argname="argument runtime_info", value=runtime_info, expected_type=type_hints["runtime_info"])
check_type(argname="argument outdir", value=outdir, expected_type=type_hints["outdir"])
check_type(argname="argument skip_validation", value=skip_validation, expected_type=type_hints["skip_validation"])
self._values: typing.Dict[builtins.str, typing.Any] = {}
if runtime_info is not None:
self._values["runtime_info"] = runtime_info
if outdir is not None:
self._values["outdir"] = outdir
if skip_validation is not None:
self._values["skip_validation"] = skip_validation
@builtins.property
def runtime_info(self) -> typing.Optional[_ros_cdk_cxapi_45dace6b.RuntimeInfo]:
'''Include the specified runtime information (module versions) in manifest.
:default: - if this option is not specified, runtime info will not be included
'''
result = self._values.get("runtime_info")
return typing.cast(typing.Optional[_ros_cdk_cxapi_45dace6b.RuntimeInfo], result)
@builtins.property
def outdir(self) -> typing.Optional[builtins.str]:
'''(deprecated) The output directory into which to synthesize the cloud assembly.
:default: - creates a temporary directory
:stability: deprecated
'''
result = self._values.get("outdir")
return typing.cast(typing.Optional[builtins.str], result)
@builtins.property
def skip_validation(self) -> typing.Optional[builtins.bool]:
'''(deprecated) Whether synthesis should skip the validation phase.
:default: false
:stability: deprecated
'''
result = self._values.get("skip_validation")
return typing.cast(typing.Optional[builtins.bool], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "SynthesisOptions(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class TagManager(
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-core.TagManager",
):
'''TagManager facilitates a common implementation of tagging for Constructs.'''
def __init__(
self,
tag_type: "TagType",
resource_type_name: builtins.str,
tag_structure: typing.Any = None,
*,
tag_property_name: typing.Optional[builtins.str] = None,
) -> None:
'''
:param tag_type: -
:param resource_type_name: -
:param tag_structure: -
:param tag_property_name: The name of the property in ROS for these tags. Normally this is ``tags``, but Cognito UserPool uses UserPoolTags Default: "tags"
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__b31f0916603b9ac0a19041d432d8b63a66c9d635884be9ce7cfe64043d13b996)
check_type(argname="argument tag_type", value=tag_type, expected_type=type_hints["tag_type"])
check_type(argname="argument resource_type_name", value=resource_type_name, expected_type=type_hints["resource_type_name"])
check_type(argname="argument tag_structure", value=tag_structure, expected_type=type_hints["tag_structure"])
options = TagManagerOptions(tag_property_name=tag_property_name)
jsii.create(self.__class__, self, [tag_type, resource_type_name, tag_structure, options])
@jsii.member(jsii_name="isTaggable")
@builtins.classmethod
def is_taggable(cls, construct: typing.Any) -> builtins.bool:
'''Check whether the given construct is Taggable.
:param construct: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__5e3db5dabbad4d55b94d26d442069e119d50daaa4b8d2f279a7dbb32281bf0cd)
check_type(argname="argument construct", value=construct, expected_type=type_hints["construct"])
return typing.cast(builtins.bool, jsii.sinvoke(cls, "isTaggable", [construct]))
@jsii.member(jsii_name="applyTagAspectHere")
def apply_tag_aspect_here(
self,
include: typing.Optional[typing.Sequence[builtins.str]] = None,
exclude: typing.Optional[typing.Sequence[builtins.str]] = None,
) -> builtins.bool:
'''Determine if the aspect applies here.
Looks at the include and exclude resourceTypeName arrays to determine if
the aspect applies here
:param include: -
:param exclude: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__4e52e20f19c15005b1419702493d03ce70ff0090e04c7b0116e7842aaea82195)
check_type(argname="argument include", value=include, expected_type=type_hints["include"])
check_type(argname="argument exclude", value=exclude, expected_type=type_hints["exclude"])
return typing.cast(builtins.bool, jsii.invoke(self, "applyTagAspectHere", [include, exclude]))
@jsii.member(jsii_name="hasTags")
def has_tags(self) -> builtins.bool:
'''Returns true if there are any tags defined.'''
return typing.cast(builtins.bool, jsii.invoke(self, "hasTags", []))
@jsii.member(jsii_name="removeTag")
def remove_tag(self, key: builtins.str, priority: jsii.Number) -> None:
'''Removes the specified tag from the array if it exists.
:param key: The tag to remove.
:param priority: The priority of the remove operation.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__607bb507ff316ca9882e67bbdda771afd44a804d1822223bddac5091599672e3)
check_type(argname="argument key", value=key, expected_type=type_hints["key"])
check_type(argname="argument priority", value=priority, expected_type=type_hints["priority"])
return typing.cast(None, jsii.invoke(self, "removeTag", [key, priority]))
@jsii.member(jsii_name="renderTags")
def render_tags(self) -> typing.Any:
'''Renders tags into the proper format based on TagType.'''
return typing.cast(typing.Any, jsii.invoke(self, "renderTags", []))
@jsii.member(jsii_name="setTag")
def set_tag(
self,
key: builtins.str,
value: builtins.str,
priority: typing.Optional[jsii.Number] = None,
apply_to_launched_instances: typing.Optional[builtins.bool] = None,
) -> None:
'''Adds the specified tag to the array of tags.
:param key: -
:param value: -
:param priority: -
:param apply_to_launched_instances: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__1b5c4a3cfda8aa538d53e13c5614c2be4dcc0dd1693e8a3c09b4896ee2915fa8)
check_type(argname="argument key", value=key, expected_type=type_hints["key"])
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
check_type(argname="argument priority", value=priority, expected_type=type_hints["priority"])
check_type(argname="argument apply_to_launched_instances", value=apply_to_launched_instances, expected_type=type_hints["apply_to_launched_instances"])
return typing.cast(None, jsii.invoke(self, "setTag", [key, value, priority, apply_to_launched_instances]))
@jsii.member(jsii_name="tagValues")
def tag_values(self) -> typing.Mapping[builtins.str, builtins.str]:
'''Render the tags in a readable format.'''
return typing.cast(typing.Mapping[builtins.str, builtins.str], jsii.invoke(self, "tagValues", []))
@builtins.property
@jsii.member(jsii_name="tagPropertyName")
def tag_property_name(self) -> builtins.str:
'''The property name for tag values.
Normally this is ``tags`` but some resources choose a different name. Cognito
UserPool uses UserPoolTags
'''
return typing.cast(builtins.str, jsii.get(self, "tagPropertyName"))
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-core.TagManagerOptions",
jsii_struct_bases=[],
name_mapping={"tag_property_name": "tagPropertyName"},
)
class TagManagerOptions:
def __init__(
self,
*,
tag_property_name: typing.Optional[builtins.str] = None,
) -> None:
'''Options to configure TagManager behavior.
:param tag_property_name: The name of the property in ROS for these tags. Normally this is ``tags``, but Cognito UserPool uses UserPoolTags Default: "tags"
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__762aea27829aa2022727347af6041130cc95adf01466f33b366e43fc81c7d366)
check_type(argname="argument tag_property_name", value=tag_property_name, expected_type=type_hints["tag_property_name"])
self._values: typing.Dict[builtins.str, typing.Any] = {}
if tag_property_name is not None:
self._values["tag_property_name"] = tag_property_name
@builtins.property
def tag_property_name(self) -> typing.Optional[builtins.str]:
'''The name of the property in ROS for these tags.
Normally this is ``tags``, but Cognito UserPool uses UserPoolTags
:default: "tags"
'''
result = self._values.get("tag_property_name")
return typing.cast(typing.Optional[builtins.str], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "TagManagerOptions(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
@jsii.enum(jsii_type="@alicloud/ros-cdk-core.TagType")
class TagType(enum.Enum):
STANDARD = "STANDARD"
AUTOSCALING_GROUP = "AUTOSCALING_GROUP"
MAP = "MAP"
KEY_VALUE = "KEY_VALUE"
NOT_TAGGABLE = "NOT_TAGGABLE"
class Token(metaclass=jsii.JSIIMeta, jsii_type="@alicloud/ros-cdk-core.Token"):
'''Represents a special or lazily-evaluated value.
Can be used to delay evaluation of a certain value in case, for example,
that it requires some context or late-bound data. Can also be used to
mark values that need special processing at document rendering time.
Tokens can be embedded into strings while retaining their original
semantics.
'''
@jsii.member(jsii_name="asAny")
@builtins.classmethod
def as_any(cls, value: typing.Any) -> IResolvable:
'''Return a resolvable representation of the given value.
:param value: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__10cbda2ba292cace9348c3269b4a0e4ef2c137fd31c2cfe347e37b9a82a42113)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
return typing.cast(IResolvable, jsii.sinvoke(cls, "asAny", [value]))
@jsii.member(jsii_name="asList")
@builtins.classmethod
def as_list(
cls,
value: typing.Any,
*,
display_hint: typing.Optional[builtins.str] = None,
) -> typing.List[builtins.str]:
'''Return a reversible list representation of this token.
:param value: -
:param display_hint: A hint for the Token's purpose when stringifying it.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__8f4e057c19741202d697745f96cdac2507420fb69665f906cfbf139e83e5c25f)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
options = EncodingOptions(display_hint=display_hint)
return typing.cast(typing.List[builtins.str], jsii.sinvoke(cls, "asList", [value, options]))
@jsii.member(jsii_name="asNumber")
@builtins.classmethod
def as_number(cls, value: typing.Any) -> jsii.Number:
'''Return a reversible number representation of this token.
:param value: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__e810b924d685cb48f32839a0b7f6c794e8e7479f053d6175afb6b297c374c257)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
return typing.cast(jsii.Number, jsii.sinvoke(cls, "asNumber", [value]))
@jsii.member(jsii_name="asString")
@builtins.classmethod
def as_string(
cls,
value: typing.Any,
*,
display_hint: typing.Optional[builtins.str] = None,
) -> builtins.str:
'''Return a reversible string representation of this token.
If the Token is initialized with a literal, the stringified value of the
literal is returned. Otherwise, a special quoted string representation
of the Token is returned that can be embedded into other strings.
Strings with quoted Tokens in them can be restored back into
complex values with the Tokens restored by calling ``resolve()``
on the string.
:param value: -
:param display_hint: A hint for the Token's purpose when stringifying it.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__42e46304e3c03d9f33a2ee730e211b7adc4b55bc70bb89dc7321d0d2f309c2f3)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
options = EncodingOptions(display_hint=display_hint)
return typing.cast(builtins.str, jsii.sinvoke(cls, "asString", [value, options]))
@jsii.member(jsii_name="isUnresolved")
@builtins.classmethod
def is_unresolved(cls, obj: typing.Any) -> builtins.bool:
'''Returns true if obj represents an unresolved value.
One of these must be true:
- ``obj`` is an IResolvable
- ``obj`` is a string containing at least one encoded ``IResolvable``
- ``obj`` is either an encoded number or list
This does NOT recurse into lists or objects to see if they
containing resolvables.
:param obj: The object to test.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__44124ba50108ab8e08c87dd89f6eb94b1a0664a5a3b1da6f8700b15789bf11e3)
check_type(argname="argument obj", value=obj, expected_type=type_hints["obj"])
return typing.cast(builtins.bool, jsii.sinvoke(cls, "isUnresolved", [obj]))
class Tokenization(
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-core.Tokenization",
):
'''Less oft-needed functions to manipulate Tokens.'''
@jsii.member(jsii_name="isResolvable")
@builtins.classmethod
def is_resolvable(cls, obj: typing.Any) -> builtins.bool:
'''Return whether the given object is an IResolvable object.
This is different from Token.isUnresolved() which will also check for
encoded Tokens, whereas this method will only do a type check on the given
object.
:param obj: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__40a96ccdbe485dab06de95cb233d33fad660624b380a8a8fb2344c6aaa56d74a)
check_type(argname="argument obj", value=obj, expected_type=type_hints["obj"])
return typing.cast(builtins.bool, jsii.sinvoke(cls, "isResolvable", [obj]))
@jsii.member(jsii_name="resolve")
@builtins.classmethod
def resolve(
cls,
obj: typing.Any,
*,
resolver: ITokenResolver,
scope: "IConstruct",
preparing: typing.Optional[builtins.bool] = None,
) -> typing.Any:
'''Resolves an object by evaluating all tokens and removing any undefined or empty objects or arrays.
Values can only be primitives, arrays or tokens. Other objects (i.e. with methods) will be rejected.
:param obj: The object to resolve.
:param resolver: The resolver to apply to any resolvable tokens found.
:param scope: The scope from which resolution is performed.
:param preparing: Whether the resolution is being executed during the prepare phase or not. Default: false
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__c89018313fbf500beba9c940ccfdded3a6dd1cb684bcf03e9daef7e54d3978fe)
check_type(argname="argument obj", value=obj, expected_type=type_hints["obj"])
options = ResolveOptions(resolver=resolver, scope=scope, preparing=preparing)
return typing.cast(typing.Any, jsii.sinvoke(cls, "resolve", [obj, options]))
@jsii.member(jsii_name="reverseList")
@builtins.classmethod
def reverse_list(
cls,
l: typing.Sequence[builtins.str],
) -> typing.Optional[IResolvable]:
'''Un-encode a Tokenized value from a list.
:param l: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__9e55de9d18756386134ebce512c21523d92c378766278fc50534a8cd1668af16)
check_type(argname="argument l", value=l, expected_type=type_hints["l"])
return typing.cast(typing.Optional[IResolvable], jsii.sinvoke(cls, "reverseList", [l]))
@jsii.member(jsii_name="reverseNumber")
@builtins.classmethod
def reverse_number(cls, n: jsii.Number) -> typing.Optional[IResolvable]:
'''Un-encode a Tokenized value from a number.
:param n: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__e5e35a2fe0dd0bc9b2fdc457c232db0df1e729aec4917cfa407e15a0421c7439)
check_type(argname="argument n", value=n, expected_type=type_hints["n"])
return typing.cast(typing.Optional[IResolvable], jsii.sinvoke(cls, "reverseNumber", [n]))
@jsii.member(jsii_name="reverseString")
@builtins.classmethod
def reverse_string(cls, s: builtins.str) -> "TokenizedStringFragments":
'''Un-encode a string potentially containing encoded tokens.
:param s: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__4498b1ae96d2081b3636f64315f9a32e7d913a0ebb0c9043445603ef9c73ecfa)
check_type(argname="argument s", value=s, expected_type=type_hints["s"])
return typing.cast("TokenizedStringFragments", jsii.sinvoke(cls, "reverseString", [s]))
@jsii.member(jsii_name="stringifyNumber")
@builtins.classmethod
def stringify_number(cls, x: jsii.Number) -> builtins.str:
'''Stringify a number directly or lazily if it's a Token.
If it is an object (i.e., { Ref: 'SomeLogicalId' }), return it as-is.
:param x: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__4baaf0fdb93d747169ccfac8fe3c052c1e366aaa3cf94c4c3ed6cf21994123fb)
check_type(argname="argument x", value=x, expected_type=type_hints["x"])
return typing.cast(builtins.str, jsii.sinvoke(cls, "stringifyNumber", [x]))
class TokenizedStringFragments(
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-core.TokenizedStringFragments",
):
'''Fragments of a concatenated string containing stringified Tokens.'''
def __init__(self) -> None:
jsii.create(self.__class__, self, [])
@jsii.member(jsii_name="addIntrinsic")
def add_intrinsic(self, value: typing.Any) -> None:
'''
:param value: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__299944495831f0351a5c3fbe9fda834ddf89ee24168fc7a0f7401221decb1d5a)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
return typing.cast(None, jsii.invoke(self, "addIntrinsic", [value]))
@jsii.member(jsii_name="addLiteral")
def add_literal(self, lit: typing.Any) -> None:
'''
:param lit: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__2afff4a4b2f29e3e273f323f6b9d7e749e21718257d27356f4e9425c85d64467)
check_type(argname="argument lit", value=lit, expected_type=type_hints["lit"])
return typing.cast(None, jsii.invoke(self, "addLiteral", [lit]))
@jsii.member(jsii_name="addToken")
def add_token(self, token: IResolvable) -> None:
'''
:param token: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__3e46e28eb8bebe2734ab7401ad99908b2f4d641e7cffad9589a1c9df06b57557)
check_type(argname="argument token", value=token, expected_type=type_hints["token"])
return typing.cast(None, jsii.invoke(self, "addToken", [token]))
@jsii.member(jsii_name="join")
def join(self, concat: IFragmentConcatenator) -> typing.Any:
'''Combine the string fragments using the given joiner.
If there are any
:param concat: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__c80dc9e0477ad2aef93147913606ac3e6d84dacc0d042dcdc512372c14420f07)
check_type(argname="argument concat", value=concat, expected_type=type_hints["concat"])
return typing.cast(typing.Any, jsii.invoke(self, "join", [concat]))
@jsii.member(jsii_name="mapTokens")
def map_tokens(self, mapper: ITokenMapper) -> "TokenizedStringFragments":
'''Apply a transformation function to all tokens in the string.
:param mapper: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__67ffc6b31d0552ac1f075e597446ec4e3590af7972656e2a81c0453e5d48f60f)
check_type(argname="argument mapper", value=mapper, expected_type=type_hints["mapper"])
return typing.cast("TokenizedStringFragments", jsii.invoke(self, "mapTokens", [mapper]))
@builtins.property
@jsii.member(jsii_name="firstValue")
def first_value(self) -> typing.Any:
return typing.cast(typing.Any, jsii.get(self, "firstValue"))
@builtins.property
@jsii.member(jsii_name="length")
def length(self) -> jsii.Number:
return typing.cast(jsii.Number, jsii.get(self, "length"))
@builtins.property
@jsii.member(jsii_name="tokens")
def tokens(self) -> typing.List[IResolvable]:
'''Return all Tokens from this string.'''
return typing.cast(typing.List[IResolvable], jsii.get(self, "tokens"))
@builtins.property
@jsii.member(jsii_name="firstToken")
def first_token(self) -> typing.Optional[IResolvable]:
return typing.cast(typing.Optional[IResolvable], jsii.get(self, "firstToken"))
class TreeInspector(
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-core.TreeInspector",
):
'''Inspector that maintains an attribute bag.'''
def __init__(self) -> None:
jsii.create(self.__class__, self, [])
@jsii.member(jsii_name="addAttribute")
def add_attribute(self, key: builtins.str, value: typing.Any) -> None:
'''Adds attribute to bag.
Keys should be added by convention to prevent conflicts
:param key: - key for metadata.
:param value: - value of metadata.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__8160540b1b0781396fbb49de8909f485bc6847f12b06c284899426a5ba73d702)
check_type(argname="argument key", value=key, expected_type=type_hints["key"])
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
return typing.cast(None, jsii.invoke(self, "addAttribute", [key, value]))
@builtins.property
@jsii.member(jsii_name="attributes")
def attributes(self) -> typing.Mapping[builtins.str, typing.Any]:
'''Represents the bag of attributes as key-value pairs.'''
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "attributes"))
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-core.ValidationError",
jsii_struct_bases=[],
name_mapping={"message": "message", "source": "source"},
)
class ValidationError:
def __init__(self, *, message: builtins.str, source: "Construct") -> None:
'''An error returned during the validation phase.
:param message: The error message.
:param source: The construct which emitted the error.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__24c461a233468bdd35c3de4534cc3efeef61b40de176800f40e33fe5d9b63935)
check_type(argname="argument message", value=message, expected_type=type_hints["message"])
check_type(argname="argument source", value=source, expected_type=type_hints["source"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"message": message,
"source": source,
}
@builtins.property
def message(self) -> builtins.str:
'''The error message.'''
result = self._values.get("message")
assert result is not None, "Required property 'message' is missing"
return typing.cast(builtins.str, result)
@builtins.property
def source(self) -> "Construct":
'''The construct which emitted the error.'''
result = self._values.get("source")
assert result is not None, "Required property 'source' is missing"
return typing.cast("Construct", result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "ValidationError(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class ValidationResult(
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-core.ValidationResult",
):
'''Representation of validation results.
Models a tree of validation errors so that we have as much information as possible
about the failure that occurred.
'''
def __init__(
self,
error_message: typing.Optional[builtins.str] = None,
results: typing.Optional["ValidationResults"] = None,
) -> None:
'''
:param error_message: -
:param results: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__8464e23dc0647f104591d2538171583569e436394676dc7eacc14605f4bc6c6f)
check_type(argname="argument error_message", value=error_message, expected_type=type_hints["error_message"])
check_type(argname="argument results", value=results, expected_type=type_hints["results"])
jsii.create(self.__class__, self, [error_message, results])
@jsii.member(jsii_name="assertSuccess")
def assert_success(self) -> None:
'''Turn a failed validation into an exception.'''
return typing.cast(None, jsii.invoke(self, "assertSuccess", []))
@jsii.member(jsii_name="errorTree")
def error_tree(self) -> builtins.str:
'''Return a string rendering of the tree of validation failures.'''
return typing.cast(builtins.str, jsii.invoke(self, "errorTree", []))
@jsii.member(jsii_name="prefix")
def prefix(self, message: builtins.str) -> "ValidationResult":
'''Wrap this result with an error message, if it concerns an error.
:param message: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__14b5bac0e79db41ff39720d1056b6d3ad3381b18f0245a6992c93703c07bc82f)
check_type(argname="argument message", value=message, expected_type=type_hints["message"])
return typing.cast("ValidationResult", jsii.invoke(self, "prefix", [message]))
@builtins.property
@jsii.member(jsii_name="errorMessage")
def error_message(self) -> builtins.str:
return typing.cast(builtins.str, jsii.get(self, "errorMessage"))
@builtins.property
@jsii.member(jsii_name="isSuccess")
def is_success(self) -> builtins.bool:
return typing.cast(builtins.bool, jsii.get(self, "isSuccess"))
@builtins.property
@jsii.member(jsii_name="results")
def results(self) -> "ValidationResults":
return typing.cast("ValidationResults", jsii.get(self, "results"))
class ValidationResults(
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-core.ValidationResults",
):
'''A collection of validation results.'''
def __init__(
self,
results: typing.Optional[typing.Sequence[ValidationResult]] = None,
) -> None:
'''
:param results: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__d22e62cd44b29ae7387d4d18bcbc2e8767111e1b9f70ad6d9bbaaa972ec3b410)
check_type(argname="argument results", value=results, expected_type=type_hints["results"])
jsii.create(self.__class__, self, [results])
@jsii.member(jsii_name="collect")
def collect(self, result: ValidationResult) -> None:
'''
:param result: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__ee64811eef3876aca433a599fde8c5d35b893f421e7c1492cdbaf75d4a580c38)
check_type(argname="argument result", value=result, expected_type=type_hints["result"])
return typing.cast(None, jsii.invoke(self, "collect", [result]))
@jsii.member(jsii_name="errorTreeList")
def error_tree_list(self) -> builtins.str:
return typing.cast(builtins.str, jsii.invoke(self, "errorTreeList", []))
@jsii.member(jsii_name="wrap")
def wrap(self, message: builtins.str) -> ValidationResult:
'''Wrap up all validation results into a single tree node.
If there are failures in the collection, add a message, otherwise
return a success.
:param message: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__097ed477d8f3d33cc0e8be9230f76e3de9bcc8e9f3f4aa640fb62bd5ea9e213c)
check_type(argname="argument message", value=message, expected_type=type_hints["message"])
return typing.cast(ValidationResult, jsii.invoke(self, "wrap", [message]))
@builtins.property
@jsii.member(jsii_name="isSuccess")
def is_success(self) -> builtins.bool:
return typing.cast(builtins.bool, jsii.get(self, "isSuccess"))
@builtins.property
@jsii.member(jsii_name="results")
def results(self) -> typing.List[ValidationResult]:
return typing.cast(typing.List[ValidationResult], jsii.get(self, "results"))
@results.setter
def results(self, value: typing.List[ValidationResult]) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__4403f3c33afef1e6ba1ccbadc87ac1ddd05aae6b7a400b3cbd85a043d7d85462)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "results", value)
@jsii.implements(IDependable)
class ConcreteDependable(
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-core.ConcreteDependable",
):
'''(experimental) A set of constructs to be used as a dependable.
This class can be used when a set of constructs which are disjoint in the
construct tree needs to be combined to be used as a single dependable.
:stability: experimental
'''
def __init__(self) -> None:
'''
:stability: experimental
'''
jsii.create(self.__class__, self, [])
@jsii.member(jsii_name="add")
def add(self, construct: "IConstruct") -> None:
'''(experimental) Add a construct to the dependency roots.
:param construct: -
:stability: experimental
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__2aff3187c70abf274ed13cd4a3f2e4998d0f0992886e51edb0da1d043b8c4479)
check_type(argname="argument construct", value=construct, expected_type=type_hints["construct"])
return typing.cast(None, jsii.invoke(self, "add", [construct]))
@jsii.implements(IStackSynthesizer)
class DefaultStackSynthesizer(
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-core.DefaultStackSynthesizer",
):
'''Uses conventionally named roles and reify asset storage locations.'''
def __init__(self) -> None:
jsii.create(self.__class__, self, [])
@jsii.member(jsii_name="bind")
def bind(self, stack: "Stack") -> None:
'''Bind to the stack this environment is going to be used on.
Must be called before any of the other methods are called.
:param stack: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__056834e8ea5e467b3e578dab4687464feb942970071b2e92b431cb79e887b6e4)
check_type(argname="argument stack", value=stack, expected_type=type_hints["stack"])
return typing.cast(None, jsii.invoke(self, "bind", [stack]))
@jsii.member(jsii_name="synthesizeStackArtifacts")
def synthesize_stack_artifacts(self, session: ISynthesisSession) -> None:
'''Synthesize all artifacts required for the stack into the session.
:param session: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__c57938c57f0e21ffd21d8acfc12cedae1a940974abf5c9d97f6e3a44fef3f31a)
check_type(argname="argument session", value=session, expected_type=type_hints["session"])
return typing.cast(None, jsii.invoke(self, "synthesizeStackArtifacts", [session]))
@jsii.python.classproperty
@jsii.member(jsii_name="DEFAULT_QUALIFIER")
def DEFAULT_QUALIFIER(cls) -> builtins.str:
'''Default ARN qualifier.'''
return typing.cast(builtins.str, jsii.sget(cls, "DEFAULT_QUALIFIER"))
@builtins.property
@jsii.member(jsii_name="stack")
def _stack(self) -> typing.Optional["Stack"]:
return typing.cast(typing.Optional["Stack"], jsii.get(self, "stack"))
@jsii.implements(ITokenResolver)
class DefaultTokenResolver(
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-core.DefaultTokenResolver",
):
'''(experimental) Default resolver implementation.
:stability: experimental
'''
def __init__(self, concat: IFragmentConcatenator) -> None:
'''
:param concat: -
:stability: experimental
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__9727b4179c0e167b591e6d6381af6777aa5c0bc173a9be06c520752e6276a79b)
check_type(argname="argument concat", value=concat, expected_type=type_hints["concat"])
jsii.create(self.__class__, self, [concat])
@jsii.member(jsii_name="resolveList")
def resolve_list(
self,
xs: typing.Sequence[builtins.str],
context: IResolveContext,
) -> typing.Any:
'''(experimental) Resolve a tokenized list.
:param xs: -
:param context: -
:stability: experimental
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__216b9096fbe63ca7f074fc29e40563204d6f77fcf26ca8d257635a47aaf5654c)
check_type(argname="argument xs", value=xs, expected_type=type_hints["xs"])
check_type(argname="argument context", value=context, expected_type=type_hints["context"])
return typing.cast(typing.Any, jsii.invoke(self, "resolveList", [xs, context]))
@jsii.member(jsii_name="resolveString")
def resolve_string(
self,
fragments: TokenizedStringFragments,
context: IResolveContext,
) -> typing.Any:
'''(experimental) Resolve string fragments to Tokens.
:param fragments: -
:param context: -
:stability: experimental
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__94afe6ae9a614e95657ec50260cbe8a8f37f3334a6f8e36774cc6d50076adce9)
check_type(argname="argument fragments", value=fragments, expected_type=type_hints["fragments"])
check_type(argname="argument context", value=context, expected_type=type_hints["context"])
return typing.cast(typing.Any, jsii.invoke(self, "resolveString", [fragments, context]))
@jsii.member(jsii_name="resolveToken")
def resolve_token(
self,
t: IResolvable,
context: IResolveContext,
post_processor: IPostProcessor,
) -> typing.Any:
'''(experimental) Default Token resolution.
Resolve the Token, recurse into whatever it returns,
then finally post-process it.
:param t: -
:param context: -
:param post_processor: -
:stability: experimental
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__c53a6ef11bc0db98771275f3ebe02ae5f19946dcc1e5c5d6d3b3d064bc41fc0c)
check_type(argname="argument t", value=t, expected_type=type_hints["t"])
check_type(argname="argument context", value=context, expected_type=type_hints["context"])
check_type(argname="argument post_processor", value=post_processor, expected_type=type_hints["post_processor"])
return typing.cast(typing.Any, jsii.invoke(self, "resolveToken", [t, context, post_processor]))
class FnAdd(
Intrinsic,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-core.FnAdd",
):
def __init__(self, values: typing.Any) -> None:
'''Creates an ``Add`` function.
:param values: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__686e2b42bbe4af2a65edd2cbf32a76d1c722ba8453b459409936c8b9aa9fbf03)
check_type(argname="argument values", value=values, expected_type=type_hints["values"])
jsii.create(self.__class__, self, [values])
@jsii.implements(IRosConditionExpression)
class FnAnd(
Intrinsic,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-core.FnAnd",
):
'''Returns true if all the specified conditions evaluate to true, or returns false if any one of the conditions evaluates to false.
``Fn::And`` acts as an AND operator. The minimum number of
conditions that you can include is 2, and the maximum is 10.
'''
def __init__(
self,
*condition: typing.Union[builtins.str, IRosConditionExpression],
) -> None:
'''
:param condition: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__45110e0d6534b98ed8e6e9281dc23a01599642f85573bf97ad8d584b97f59491)
check_type(argname="argument condition", value=condition, expected_type=typing.Tuple[type_hints["condition"], ...]) # pyright: ignore [reportGeneralTypeIssues]
jsii.create(self.__class__, self, [*condition])
class FnAvg(
Intrinsic,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-core.FnAvg",
):
def __init__(self, value: typing.Any) -> None:
'''Creates an ``Avg`` function.
:param value: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__b9524542b26c45613494832a6e6412d4cdfe45869ceeabd7ee930da6b0ef7ef6)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.create(self.__class__, self, [value])
class FnBase64Decode(
Intrinsic,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-core.FnBase64Decode",
):
def __init__(self, data: typing.Any) -> None:
'''
:param data: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__52065ec56e8eae2266f840354d908795d211fda0f7050a5d39c062982a080ba9)
check_type(argname="argument data", value=data, expected_type=type_hints["data"])
jsii.create(self.__class__, self, [data])
class FnBase64Encode(
Intrinsic,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-core.FnBase64Encode",
):
'''The intrinsic function ``Fn::Base64`` returns the Base64 representation of the input string.'''
def __init__(self, data: typing.Any) -> None:
'''Creates an ``Fn::Base64`` function.
:param data: The string value you want to convert to Base64.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__40e0d55844e1804e912770b8e7c076cfb38b59071e09baebb42b3e5e0e337fe0)
check_type(argname="argument data", value=data, expected_type=type_hints["data"])
jsii.create(self.__class__, self, [data])
class FnCalculate(
Intrinsic,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-core.FnCalculate",
):
def __init__(self, value: typing.Any) -> None:
'''Creates an ``Calculate`` function.
:param value: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__26465fde8e7163abd6f7cb2de91952795d430f22b34a8d6cf28a0ef4761de891)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.create(self.__class__, self, [value])
@jsii.implements(IRosConditionExpression)
class FnEquals(
Intrinsic,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-core.FnEquals",
):
'''Compares if two values are equal.
Returns true if the two values are equal or false
if they aren't.
'''
def __init__(self, lhs: typing.Any, rhs: typing.Any) -> None:
'''Creates an ``Fn::Equals`` condition function.
:param lhs: A value of any type that you want to compare.
:param rhs: A value of any type that you want to compare.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__b3cc295f516f290459b1196f5b3f00e46e3c192dc4ac112e357e96a209e33fad)
check_type(argname="argument lhs", value=lhs, expected_type=type_hints["lhs"])
check_type(argname="argument rhs", value=rhs, expected_type=type_hints["rhs"])
jsii.create(self.__class__, self, [lhs, rhs])
class FnFindInMap(
Intrinsic,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-core.FnFindInMap",
):
'''The intrinsic function ``Fn::FindInMap`` returns the value corresponding to keys in a two-level map that is declared in the Mappings section.'''
def __init__(self, value: typing.Any) -> None:
'''Creates an ``Fn::FindInMap`` function.
param mapName The logical name of a mapping declared in the Mappings section that contains the keys and values.
param topLevelKey The top-level key name. Its value is a list of key-value pairs.
param secondLevelKey The second-level key name, which is set to one of the keys from the list assigned to TopLevelKey.
:param value: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__dd98760b6a01e88e5ed5377b56f290262fd96f6703c0328839b0e0668e6ddafa)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.create(self.__class__, self, [value])
class FnGetAZs(
Intrinsic,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-core.FnGetAZs",
):
'''The intrinsic function ``Fn::GetAZs`` returns an array that lists Availability Zones for a specified region.
Because customers have access to different Availability Zones, the intrinsic
function ``Fn::GetAZs`` enables template authors to write templates that adapt to the calling
user's access. That way you don't have to hard-code a full list of Availability Zones for a
specified region.
'''
def __init__(self, region: typing.Any) -> None:
'''Creates an ``Fn::GetAZs`` function.
:param region: The name of the region for which you want to get the Availability Zones.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__99a58fd57d7de4274f57bce0fac8696676b644b6bd94046816eaa33980856884)
check_type(argname="argument region", value=region, expected_type=type_hints["region"])
jsii.create(self.__class__, self, [region])
class FnGetAtt(
Intrinsic,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-core.FnGetAtt",
):
'''The ``Fn::GetAtt`` intrinsic function returns the value of an attribute from a resource in the template.'''
def __init__(
self,
logical_name_of_resource: builtins.str,
attribute_name: builtins.str,
) -> None:
'''Creates a ``Fn::GetAtt`` function.
:param logical_name_of_resource: The logical name (also called logical ID) of the resource that contains the attribute that you want.
:param attribute_name: The name of the resource-specific attribute whose value you want. See the resource's reference page for details about the attributes available for that resource type.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__0bf228358201491aaacfb32677b98c44e0d2791cbef92d2c13a4a1b612a88544)
check_type(argname="argument logical_name_of_resource", value=logical_name_of_resource, expected_type=type_hints["logical_name_of_resource"])
check_type(argname="argument attribute_name", value=attribute_name, expected_type=type_hints["attribute_name"])
jsii.create(self.__class__, self, [logical_name_of_resource, attribute_name])
class FnGetJsonValue(
Intrinsic,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-core.FnGetJsonValue",
):
def __init__(self, value: typing.Any) -> None:
'''Creates an ``GetJsonValue`` function.
:param value: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__5a2e3c1b3ac88b16338cbf206af8919482beb8d247ee3ff3215f49de03ddf0de)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.create(self.__class__, self, [value])
class FnGetStackOutput(
Intrinsic,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-core.FnGetStackOutput",
):
def __init__(self, value: typing.Any) -> None:
'''Creates an ``GetStackOutput`` function.
:param value: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__16e5baaf8cdfb71cdcdc61ee86e19fbe34de66252cc13ec6e10d05b56b2cae67)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.create(self.__class__, self, [value])
@jsii.implements(IRosConditionExpression)
class FnIf(Intrinsic, metaclass=jsii.JSIIMeta, jsii_type="@alicloud/ros-cdk-core.FnIf"):
'''Returns one value if the specified condition evaluates to true and another value if the specified condition evaluates to false.'''
def __init__(
self,
condition: typing.Union[builtins.str, IRosConditionExpression],
value_if_true: typing.Any,
value_if_false: typing.Any,
) -> None:
'''Creates an ``Fn::If`` condition function.
:param condition: A reference to a condition in the Conditions section. Use the condition's name to reference it.
:param value_if_true: A value to be returned if the specified condition evaluates to true.
:param value_if_false: A value to be returned if the specified condition evaluates to false.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__bd45b41054d6fd402e50eb7829f1b272ebdac9695a6aa57470cb2b3361cd658f)
check_type(argname="argument condition", value=condition, expected_type=type_hints["condition"])
check_type(argname="argument value_if_true", value=value_if_true, expected_type=type_hints["value_if_true"])
check_type(argname="argument value_if_false", value=value_if_false, expected_type=type_hints["value_if_false"])
jsii.create(self.__class__, self, [condition, value_if_true, value_if_false])
@jsii.implements(IResolvable)
class FnJoin(metaclass=jsii.JSIIMeta, jsii_type="@alicloud/ros-cdk-core.FnJoin"):
'''The intrinsic function ``Fn::Join`` appends a set of values into a single value, separated by the specified delimiter.
If a delimiter is the empty string, the set of values are concatenated
with no delimiter.
'''
def __init__(
self,
delimiter: builtins.str,
list_of_values: typing.Sequence[typing.Any],
) -> None:
'''Creates an ``Fn::Join`` function.
:param delimiter: The value you want to occur between fragments. The delimiter will occur between fragments only. It will not terminate the final value.
:param list_of_values: The list of values you want combined.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__e0122df383b5bc5fa6367cdb94a99ac0174bb8f1f325bd5ed5b2f6ecc4dca2a6)
check_type(argname="argument delimiter", value=delimiter, expected_type=type_hints["delimiter"])
check_type(argname="argument list_of_values", value=list_of_values, expected_type=type_hints["list_of_values"])
jsii.create(self.__class__, self, [delimiter, list_of_values])
@jsii.member(jsii_name="resolve")
def resolve(self, context: IResolveContext) -> typing.Any:
'''Produce the Token's value at resolution time.
:param context: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__61ef76dd29f6e730b8a873263bec53e01d984484dab8e4c18002a13641acee47)
check_type(argname="argument context", value=context, expected_type=type_hints["context"])
return typing.cast(typing.Any, jsii.invoke(self, "resolve", [context]))
@jsii.member(jsii_name="toJSON")
def to_json(self) -> builtins.str:
return typing.cast(builtins.str, jsii.invoke(self, "toJSON", []))
@jsii.member(jsii_name="toString")
def to_string(self) -> builtins.str:
'''Return a string representation of this resolvable object.
Returns a reversible string representation.
'''
return typing.cast(builtins.str, jsii.invoke(self, "toString", []))
@builtins.property
@jsii.member(jsii_name="creationStack")
def creation_stack(self) -> typing.List[builtins.str]:
'''The creation stack of this resolvable which will be appended to errors thrown during resolution.
If this returns an empty array the stack will not be attached.
'''
return typing.cast(typing.List[builtins.str], jsii.get(self, "creationStack"))
class FnJq(Intrinsic, metaclass=jsii.JSIIMeta, jsii_type="@alicloud/ros-cdk-core.FnJq"):
def __init__(self, value: typing.Any) -> None:
'''Creates an ``Jq`` function.
:param value: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__8eb62c800fcae67b10a7b5c30ccb3c039f73b92a810339966810785336b14d0e)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.create(self.__class__, self, [value])
class FnListMerge(
Intrinsic,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-core.FnListMerge",
):
def __init__(self, value: typing.Any) -> None:
'''Creates an ``ListMerge`` function.
:param value: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__e8c35bdce19ff8d2ea687c9a63e379a6babcc6ff8119fd475f25f1b5ea1c25ee)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.create(self.__class__, self, [value])
class FnMax(
Intrinsic,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-core.FnMax",
):
def __init__(self, values: typing.Any) -> None:
'''Creates an ``Max`` function.
:param values: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__9c01b3caf582f9af877e56cc694bb360a2085322725b78786274d824cdaf2072)
check_type(argname="argument values", value=values, expected_type=type_hints["values"])
jsii.create(self.__class__, self, [values])
class FnMergeMapToList(
Intrinsic,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-core.FnMergeMapToList",
):
def __init__(self, map_list: typing.Any) -> None:
'''Creates an ``FnMergeMapToList`` function.
:param map_list: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__a615ab5ca96cf38319d0e6b4a376abfa40a4feb616ea507c962ee6cb7b1690bd)
check_type(argname="argument map_list", value=map_list, expected_type=type_hints["map_list"])
jsii.create(self.__class__, self, [map_list])
class FnMin(
Intrinsic,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-core.FnMin",
):
def __init__(self, values: typing.Any) -> None:
'''Creates an ``Min`` function.
:param values: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__b9b3bd114c9b3dc0c6ac49a5be7ec7f0bcbbb1ff5fa2912854055f81c5b00296)
check_type(argname="argument values", value=values, expected_type=type_hints["values"])
jsii.create(self.__class__, self, [values])
@jsii.implements(IRosConditionExpression)
class FnNot(
Intrinsic,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-core.FnNot",
):
'''Returns true for a condition that evaluates to false or returns false for a condition that evaluates to true.
``Fn::Not`` acts as a NOT operator.
'''
def __init__(
self,
condition: typing.Union[builtins.str, IRosConditionExpression],
) -> None:
'''Creates an ``Fn::Not`` condition function.
:param condition: A condition such as ``Fn::Equals`` that evaluates to true or false.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__aa8f0c940a166a4c70ea31088c6453e4302d5d801015d2550db27f2ec81e930b)
check_type(argname="argument condition", value=condition, expected_type=type_hints["condition"])
jsii.create(self.__class__, self, [condition])
@jsii.implements(IRosConditionExpression)
class FnOr(Intrinsic, metaclass=jsii.JSIIMeta, jsii_type="@alicloud/ros-cdk-core.FnOr"):
'''Returns true if any one of the specified conditions evaluate to true, or returns false if all of the conditions evaluates to false.
``Fn::Or`` acts as an OR operator. The minimum number
of conditions that you can include is 2, and the maximum is 10.
'''
def __init__(
self,
*condition: typing.Union[builtins.str, IRosConditionExpression],
) -> None:
'''Creates an ``Fn::Or`` condition function.
:param condition: A condition that evaluates to true or false.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__adf2e03c690c3cb28b74e88982a4889d3b0d5b54d92b5a3556624ce9a9f7fd8a)
check_type(argname="argument condition", value=condition, expected_type=typing.Tuple[type_hints["condition"], ...]) # pyright: ignore [reportGeneralTypeIssues]
jsii.create(self.__class__, self, [*condition])
class FnRef(
Intrinsic,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-core.FnRef",
):
'''The intrinsic function ``Ref`` returns the value of the specified parameter or resource.
When you specify a parameter's logical name, it returns the value of the parameter.
When you specify a resource's logical name, it returns a value that you can typically use to refer to that resource, such as a physical ID.
'''
def __init__(self, logical_name: builtins.str) -> None:
'''Creates an ``Ref`` function.
:param logical_name: The logical name of a parameter/resource for which you want to retrieve its value.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__61889f70542841a7dcc6f9a86f78d58f369a603f32fea0e24af9a0038e420cf1)
check_type(argname="argument logical_name", value=logical_name, expected_type=type_hints["logical_name"])
jsii.create(self.__class__, self, [logical_name])
class FnReplace(
Intrinsic,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-core.FnReplace",
):
def __init__(self, value: typing.Any) -> None:
'''Creates an ``Replace`` function.
:param value: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__0250eb79836dc506c39f785b743b8af41f55a581763ad1190d251682df8b0555)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.create(self.__class__, self, [value])
class FnSelect(
Intrinsic,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-core.FnSelect",
):
'''The intrinsic function ``Fn::Select`` returns a single object from a list of objects by index.'''
def __init__(self, value: typing.Any) -> None:
'''Creates an ``Fn::Select`` function.
param index The index of the object to retrieve. This must be a value from zero to N-1, where N represents the number of elements in the array.
param array The list of objects to select from. This list must not be null, nor can it have null entries.
:param value: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__29fbee6c85e18606ce841248ed899786d11cbeef5717939d92fbf8662a5a02e5)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.create(self.__class__, self, [value])
class FnSelectMapList(
Intrinsic,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-core.FnSelectMapList",
):
def __init__(self, value: typing.Any) -> None:
'''Creates an ``FnMergeMapToList`` function.
:param value: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__7943bda42cbb6b91580503ce70079765bd1027495853a52b7c78d1715d76e8ef)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.create(self.__class__, self, [value])
class FnSplit(
Intrinsic,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-core.FnSplit",
):
'''To split a string into a list of string values so that you can select an element from the resulting string list, use the ``Fn::Split`` intrinsic function.
Specify the location of splits
with a delimiter, such as , (a comma). After you split a string, use the ``Fn::Select`` function
to pick a specific element.
'''
def __init__(self, value: typing.Any) -> None:
'''Create an ``Fn::Split`` function.
param delimiter A string value that determines where the source string is divided.
param source The string value that you want to split.
:param value: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__2102430162bd15106fa9023902fbaf95aa0321bdc3212c478770febe2a0dc945)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.create(self.__class__, self, [value])
class FnStr(
Intrinsic,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-core.FnStr",
):
def __init__(self, value: typing.Any) -> None:
'''Creates an ``Str`` function.
:param value: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__b00749cf94b050e10d4ab91960af1d49a86a78183b31830079457c840eb9cb2f)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.create(self.__class__, self, [value])
class FnSub(
Intrinsic,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-core.FnSub",
):
'''The intrinsic function ``Fn::Sub`` substitutes variables in an input string with values that you specify.
In your templates, you can use this function to construct commands or outputs
that include values that aren't available until you create or update a stack.
'''
def __init__(self, value: typing.Any) -> None:
'''Creates an ``Fn::Sub`` function.
param body A string with variables that Ros Template substitutes with their
associated values at runtime. Write variables as ${MyVarName}. Variables
can be template parameter names, resource logical IDs, resource attributes,
or a variable in a key-value map. If you specify only template parameter names,
resource logical IDs, and resource attributes, don't specify a key-value map.
param variables The name of a variable that you included in the String parameter.
The value that Ros Template substitutes for the associated variable name at runtime.
:param value: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__1d91ade8c7dd39fea016dc553268e72b597d83596b15dfa5cf4baa2671204f76)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.create(self.__class__, self, [value])
@jsii.interface(jsii_type="@alicloud/ros-cdk-core.IConstruct")
class IConstruct(
_constructs_77d1e7e8.IConstruct,
IDependable,
typing_extensions.Protocol,
):
'''Represents a construct.'''
@builtins.property
@jsii.member(jsii_name="node")
def node(self) -> ConstructNode:
'''The construct tree node for this construct.'''
...
class _IConstructProxy(
jsii.proxy_for(_constructs_77d1e7e8.IConstruct), # type: ignore[misc]
jsii.proxy_for(IDependable), # type: ignore[misc]
):
'''Represents a construct.'''
__jsii_type__: typing.ClassVar[str] = "@alicloud/ros-cdk-core.IConstruct"
@builtins.property
@jsii.member(jsii_name="node")
def node(self) -> ConstructNode:
'''The construct tree node for this construct.'''
return typing.cast(ConstructNode, jsii.get(self, "node"))
# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface
typing.cast(typing.Any, IConstruct).__jsii_proxy_class__ = lambda : _IConstructProxy
@jsii.interface(jsii_type="@alicloud/ros-cdk-core.IResource")
class IResource(IConstruct, typing_extensions.Protocol):
'''Interface for the Resource construct.'''
@builtins.property
@jsii.member(jsii_name="stack")
def stack(self) -> "Stack":
'''The stack in which this resource is defined.'''
...
class _IResourceProxy(
jsii.proxy_for(IConstruct), # type: ignore[misc]
):
'''Interface for the Resource construct.'''
__jsii_type__: typing.ClassVar[str] = "@alicloud/ros-cdk-core.IResource"
@builtins.property
@jsii.member(jsii_name="stack")
def stack(self) -> "Stack":
'''The stack in which this resource is defined.'''
return typing.cast("Stack", jsii.get(self, "stack"))
# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface
typing.cast(typing.Any, IResource).__jsii_proxy_class__ = lambda : _IResourceProxy
@jsii.implements(IConstruct)
class Construct(
_constructs_77d1e7e8.Construct,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-core.Construct",
):
'''Represents the building block of the construct graph.
All constructs besides the root construct must be created within the scope of
another construct.
'''
def __init__(self, scope: "Construct", id: builtins.str) -> None:
'''
:param scope: -
:param id: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__5ecfb8f7a776d0de65e015ad8172e9f8a178dfc04f8dec1b2457d86c1bcce877)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
jsii.create(self.__class__, self, [scope, id])
@jsii.member(jsii_name="isConstruct")
@builtins.classmethod
def is_construct(cls, x: typing.Any) -> builtins.bool:
'''Return whether the given object is a Construct.
:param x: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__d81f1bc767e0d25084ea165ce16fa1c230bffea60cbe788385d3a0c0464589a7)
check_type(argname="argument x", value=x, expected_type=type_hints["x"])
return typing.cast(builtins.bool, jsii.sinvoke(cls, "isConstruct", [x]))
@jsii.member(jsii_name="onPrepare")
def _on_prepare(self) -> None:
'''Perform final modifications before synthesis.
This method can be implemented by derived constructs in order to perform
final changes before synthesis. prepare() will be called after child
constructs have been prepared.
This is an advanced framework feature. Only use this if you
understand the implications.
'''
return typing.cast(None, jsii.invoke(self, "onPrepare", []))
@jsii.member(jsii_name="onSynthesize")
def _on_synthesize(self, session: _constructs_77d1e7e8.ISynthesisSession) -> None:
'''Allows this construct to emit artifacts into the cloud assembly during synthesis.
This method is usually implemented by framework-level constructs such as ``Stack`` and ``Asset``
as they participate in synthesizing the cloud assembly.
:param session: The synthesis session.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__4197923b6ab33eb87eae536a39bd7d210a48cd7dc85d241d4a8085cdf3f7dc33)
check_type(argname="argument session", value=session, expected_type=type_hints["session"])
return typing.cast(None, jsii.invoke(self, "onSynthesize", [session]))
@jsii.member(jsii_name="onValidate")
def _on_validate(self) -> typing.List[builtins.str]:
'''Validate the current construct.
This method can be implemented by derived constructs in order to perform
validation logic. It is called on all constructs before synthesis.
:return: An array of validation error messages, or an empty array if the construct is valid.
'''
return typing.cast(typing.List[builtins.str], jsii.invoke(self, "onValidate", []))
@jsii.member(jsii_name="prepare")
def _prepare(self) -> None:
'''Perform final modifications before synthesis.
This method can be implemented by derived constructs in order to perform
final changes before synthesis. prepare() will be called after child
constructs have been prepared.
This is an advanced framework feature. Only use this if you
understand the implications.
'''
return typing.cast(None, jsii.invoke(self, "prepare", []))
@jsii.member(jsii_name="synthesize")
def _synthesize(self, session: ISynthesisSession) -> None:
'''Allows this construct to emit artifacts into the cloud assembly during synthesis.
This method is usually implemented by framework-level constructs such as ``Stack`` and ``Asset``
as they participate in synthesizing the cloud assembly.
:param session: The synthesis session.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__2f7caf605f353ebe34c5a2ec53efdef2cfa7107d02aeed0f97d720b59659e706)
check_type(argname="argument session", value=session, expected_type=type_hints["session"])
return typing.cast(None, jsii.invoke(self, "synthesize", [session]))
@jsii.member(jsii_name="validate")
def _validate(self) -> typing.List[builtins.str]:
'''Validate the current construct.
This method can be implemented by derived constructs in order to perform
validation logic. It is called on all constructs before synthesis.
:return: An array of validation error messages, or an empty array if the construct is valid.
'''
return typing.cast(typing.List[builtins.str], jsii.invoke(self, "validate", []))
@builtins.property
@jsii.member(jsii_name="node")
def node(self) -> ConstructNode:
'''The construct tree node associated with this construct.'''
return typing.cast(ConstructNode, jsii.get(self, "node"))
@jsii.implements(IResource)
class Resource(
Construct,
metaclass=jsii.JSIIAbstractClass,
jsii_type="@alicloud/ros-cdk-core.Resource",
):
'''A construct which represents a resource.'''
def __init__(
self,
scope: Construct,
id: builtins.str,
*,
physical_name: typing.Optional[builtins.str] = None,
) -> None:
'''
:param scope: -
:param id: -
:param physical_name: The value passed in by users to the physical name prop of the resource. - ``undefined`` implies that a physical name will be allocated during deployment. - a concrete value implies a specific physical name - ``PhysicalName.GENERATE_IF_NEEDED`` is a marker that indicates that a physical will only be generated by the CDK if it is needed for cross-environment references. Otherwise, it will be allocated. Default: - The physical name will be allocated at deployment time
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__033bb68d0358ede779f4100fe0f171f4f4096ee9aaa265cd7450816e13f088d8)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
props = ResourceProps(physical_name=physical_name)
jsii.create(self.__class__, self, [scope, id, props])
@jsii.member(jsii_name="addCondition")
def add_condition(self, condition: "RosCondition") -> None:
'''
:param condition: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__0aa8adb2d892faa138aee5c2af9a6cbbbfc9d54b43889d0799eebf9400b57059)
check_type(argname="argument condition", value=condition, expected_type=type_hints["condition"])
return typing.cast(None, jsii.invoke(self, "addCondition", [condition]))
@jsii.member(jsii_name="addCount")
def add_count(self, count: typing.Union[jsii.Number, IResolvable]) -> None:
'''
:param count: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__9a26f834a04528bb7b9d99cd6a3b1c1f5afa6975f3da82cac68b4b711b4c0f75)
check_type(argname="argument count", value=count, expected_type=type_hints["count"])
return typing.cast(None, jsii.invoke(self, "addCount", [count]))
@jsii.member(jsii_name="addDependency")
def add_dependency(self, resource: "Resource") -> None:
'''
:param resource: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__72092dbfe054fc98599cfa5aeeb4d43af094fa113e4c033759d9d0e9e97c531c)
check_type(argname="argument resource", value=resource, expected_type=type_hints["resource"])
return typing.cast(None, jsii.invoke(self, "addDependency", [resource]))
@jsii.member(jsii_name="addResourceDesc")
def add_resource_desc(self, desc: builtins.str) -> None:
'''
:param desc: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__d2de7567d682f0d1123dbb1b9b79114ec2ae9f54c7129f94c03a3d2eda6e46f0)
check_type(argname="argument desc", value=desc, expected_type=type_hints["desc"])
return typing.cast(None, jsii.invoke(self, "addResourceDesc", [desc]))
@jsii.member(jsii_name="applyRemovalPolicy")
def apply_removal_policy(self, policy: RemovalPolicy) -> None:
'''
:param policy: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__c6f59019a6cdb5178ab386365e04a087fe7d1567a3b3f2ad94de5f8bdf660ae7)
check_type(argname="argument policy", value=policy, expected_type=type_hints["policy"])
return typing.cast(None, jsii.invoke(self, "applyRemovalPolicy", [policy]))
@jsii.member(jsii_name="generatePhysicalName")
def _generate_physical_name(self) -> builtins.str:
return typing.cast(builtins.str, jsii.invoke(self, "generatePhysicalName", []))
@jsii.member(jsii_name="getAtt")
def get_att(self, name: builtins.str) -> IResolvable:
'''
:param name: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__5e2160cb5dc7359592892c674d564da7c8414d648c824034201bd3dd82ec0bec)
check_type(argname="argument name", value=name, expected_type=type_hints["name"])
return typing.cast(IResolvable, jsii.invoke(self, "getAtt", [name]))
@jsii.member(jsii_name="setMetadata")
def set_metadata(self, key: builtins.str, value: typing.Any) -> None:
'''
:param key: -
:param value: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__6a9029d185d924daa02b18c58064fef6c16d7b34e4f28fccbe1b8eab51797cd4)
check_type(argname="argument key", value=key, expected_type=type_hints["key"])
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
return typing.cast(None, jsii.invoke(self, "setMetadata", [key, value]))
@builtins.property
@jsii.member(jsii_name="physicalName")
def _physical_name(self) -> builtins.str:
'''(experimental) Returns a string-encoded token that resolves to the physical name that should be passed to the ROS resource.
This value will resolve to one of the following:
- a concrete value (e.g. ``"my-awesome-bucket"``)
- ``undefined``, when a name should be generated by ROS
- a concrete name generated automatically during synthesis, in
cross-environment scenarios.
:stability: experimental
'''
return typing.cast(builtins.str, jsii.get(self, "physicalName"))
@builtins.property
@jsii.member(jsii_name="stack")
def stack(self) -> "Stack":
'''The stack in which this resource is defined.'''
return typing.cast("Stack", jsii.get(self, "stack"))
@builtins.property
@jsii.member(jsii_name="resource")
def resource(self) -> typing.Optional["RosResource"]:
return typing.cast(typing.Optional["RosResource"], jsii.get(self, "resource"))
@resource.setter
def resource(self, value: typing.Optional["RosResource"]) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__f9d9dbf8b7f0d7f6cdf67a80e6264fd20b981f29db775ecb90841534c8fff724)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "resource", value)
class _ResourceProxy(Resource):
pass
# Adding a "__jsii_proxy_class__(): typing.Type" function to the abstract class
typing.cast(typing.Any, Resource).__jsii_proxy_class__ = lambda : _ResourceProxy
class RosElement(
Construct,
metaclass=jsii.JSIIAbstractClass,
jsii_type="@alicloud/ros-cdk-core.RosElement",
):
'''An element of a stack.'''
def __init__(self, scope: Construct, id: builtins.str) -> None:
'''Creates an entity and binds it to a tree.
Note that the root of the tree must be a Stack object (not just any Root).
:param scope: The parent construct.
:param id: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__47cdb0909e8e294d54ce6c8ae50dfb95c5fdf1709eb8ea16fdce2ef2e8f73e7b)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
jsii.create(self.__class__, self, [scope, id])
@jsii.member(jsii_name="isRosElement")
@builtins.classmethod
def is_ros_element(cls, x: typing.Any) -> builtins.bool:
'''Returns ``true`` if a construct is a stack element (i.e. part of the synthesized template).
Uses duck-typing instead of ``instanceof`` to allow stack elements from different
versions of this library to be included in the same stack.
:param x: -
:return: The construct as a stack element or undefined if it is not a stack element.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__3d40a5c72ddbab2cda8b7e6ef044a141113184fda4c3aa8716c67666d897bd3e)
check_type(argname="argument x", value=x, expected_type=type_hints["x"])
return typing.cast(builtins.bool, jsii.sinvoke(cls, "isRosElement", [x]))
@jsii.member(jsii_name="overrideLogicalId")
def override_logical_id(self, new_logical_id: builtins.str) -> None:
'''Overrides the auto-generated logical ID with a specific ID.
:param new_logical_id: The new logical ID to use for this stack element.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__08dd30761a553a2adc5e01c01d68f30e8ddea800911818c648f0a49c635f69fb)
check_type(argname="argument new_logical_id", value=new_logical_id, expected_type=type_hints["new_logical_id"])
return typing.cast(None, jsii.invoke(self, "overrideLogicalId", [new_logical_id]))
@builtins.property
@jsii.member(jsii_name="creationStack")
def creation_stack(self) -> typing.List[builtins.str]:
'''
:return:
the stack trace of the point where this Resource was created from, sourced
from the +metadata+ entry typed +aliyun:ros:logicalId+, and with the bottom-most
node +internal+ entries filtered.
'''
return typing.cast(typing.List[builtins.str], jsii.get(self, "creationStack"))
@builtins.property
@jsii.member(jsii_name="logicalId")
def logical_id(self) -> builtins.str:
'''The logical ID for this stack element.
The logical ID of the element
is calculated from the path of the resource node in the construct tree.
To override this value, use ``overrideLogicalId(newLogicalId)``.
:return:
the logical ID as a stringified token. This value will only get
resolved during synthesis.
'''
return typing.cast(builtins.str, jsii.get(self, "logicalId"))
@builtins.property
@jsii.member(jsii_name="stack")
def stack(self) -> "Stack":
'''The stack in which this element is defined.
RosElements must be defined within a stack scope (directly or indirectly).
'''
return typing.cast("Stack", jsii.get(self, "stack"))
class _RosElementProxy(RosElement):
pass
# Adding a "__jsii_proxy_class__(): typing.Type" function to the abstract class
typing.cast(typing.Any, RosElement).__jsii_proxy_class__ = lambda : _RosElementProxy
class RosInfo(
RosElement,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-core.RosInfo",
):
def __init__(
self,
scope: Construct,
id: builtins.str,
info: typing.Union[builtins.str, typing.Mapping[builtins.str, typing.Any]],
) -> None:
'''Creates properties for this stack.
:param scope: The parent construct.
:param id: -
:param info: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__7300de86255b954db919450213cdd6104ff126ec38b173084a8af111ebb6bf42)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument info", value=info, expected_type=type_hints["info"])
jsii.create(self.__class__, self, [scope, id, info])
@jsii.python.classproperty
@jsii.member(jsii_name="description")
def description(cls) -> builtins.str: # pyright: ignore [reportGeneralTypeIssues]
return typing.cast(builtins.str, jsii.sget(cls, "description"))
@description.setter # type: ignore[no-redef]
def description(cls, value: builtins.str) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__8b371b50c0476a22f7da554b0ef5e1b89dc247a8bb992c6f86b2ed7c09e0892e)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.sset(cls, "description", value)
@jsii.python.classproperty
@jsii.member(jsii_name="formatVersion")
def format_version(cls) -> builtins.str: # pyright: ignore [reportGeneralTypeIssues]
return typing.cast(builtins.str, jsii.sget(cls, "formatVersion"))
@format_version.setter # type: ignore[no-redef]
def format_version(cls, value: builtins.str) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__aa96b151c96eada05a9d3b279fb66e4cb84bb539d53d0fa549a3a8b5409590e9)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.sset(cls, "formatVersion", value)
@jsii.python.classproperty
@jsii.member(jsii_name="metadata")
def metadata(cls) -> builtins.str: # pyright: ignore [reportGeneralTypeIssues]
return typing.cast(builtins.str, jsii.sget(cls, "metadata"))
@metadata.setter # type: ignore[no-redef]
def metadata(cls, value: builtins.str) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__2e410986d9d6502c50d2359c177f56480efe88b9aaac9a2dc2b6b21f61681483)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.sset(cls, "metadata", value)
@jsii.python.classproperty
@jsii.member(jsii_name="v20150901")
def v20150901(cls) -> builtins.str: # pyright: ignore [reportGeneralTypeIssues]
return typing.cast(builtins.str, jsii.sget(cls, "v20150901"))
@v20150901.setter # type: ignore[no-redef]
def v20150901(cls, value: builtins.str) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__94e885e07ee948b0adff014e19a0ee4e877f020a16bf7c546ccca03bdd02e8d0)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.sset(cls, "v20150901", value)
class RosOutput(
RosElement,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-core.RosOutput",
):
def __init__(
self,
scope: Construct,
id: builtins.str,
*,
value: typing.Any,
condition: typing.Optional["RosCondition"] = None,
description: typing.Optional[builtins.str] = None,
export_name: typing.Optional[builtins.str] = None,
) -> None:
'''Creates an RosOutput value for this stack.
:param scope: The parent construct.
:param id: -
:param value: The value of the property returned by Resource Orchestration Service. The value of an output can include literals, parameter references, pseudo-parameters, a mapping value, or intrinsic functions.
:param condition: A condition to associate with this output value. If the condition evaluates to ``false``, this output value will not be included in the stack. Default: - No condition is associated with the output.
:param description: A String type that describes the output value. The description can be a maximum of 4 K in length. Default: - No description.
:param export_name: The name used to export the value of this output across stacks. To import the value from another stack, use ``Fn.importValue(exportName)``. Default: - the output is not exported
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__ddd2ed831ba9eeda3b15433187523442a685f4956efb14117d5dafc98c124d14)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
props = RosOutputProps(
value=value,
condition=condition,
description=description,
export_name=export_name,
)
jsii.create(self.__class__, self, [scope, id, props])
@jsii.member(jsii_name="addCondition")
def add_condition(self, condition: "RosCondition") -> None:
'''
:param condition: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__b7aaa28eb232cdee9e75f6952c8ab6cf5980c389158bbcfa89b4f4432767c575)
check_type(argname="argument condition", value=condition, expected_type=type_hints["condition"])
return typing.cast(None, jsii.invoke(self, "addCondition", [condition]))
class RosParameter(
RosElement,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-core.RosParameter",
):
'''A ROS parameter.
Parameters enable you to input custom values to your template each time you create or
update a stack.
'''
def __init__(
self,
scope: Construct,
id: builtins.str,
*,
allowed_pattern: typing.Optional[builtins.str] = None,
allowed_values: typing.Optional[typing.Sequence[typing.Any]] = None,
association_property: typing.Optional[builtins.str] = None,
association_property_metadata: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
confirm: typing.Optional[builtins.bool] = None,
constraint_description: typing.Optional[typing.Union[builtins.str, typing.Mapping[builtins.str, builtins.str]]] = None,
default_value: typing.Any = None,
description: typing.Optional[typing.Union[builtins.str, typing.Mapping[builtins.str, builtins.str]]] = None,
label: typing.Optional[builtins.str] = None,
max_length: typing.Optional[jsii.Number] = None,
max_value: typing.Optional[jsii.Number] = None,
min_length: typing.Optional[jsii.Number] = None,
min_value: typing.Optional[jsii.Number] = None,
no_echo: typing.Optional[builtins.bool] = None,
text_area: typing.Optional[builtins.bool] = None,
type: typing.Optional[RosParameterType] = None,
) -> None:
'''
:param scope: -
:param id: -
:param allowed_pattern: -
:param allowed_values: -
:param association_property: -
:param association_property_metadata: -
:param confirm: -
:param constraint_description: -
:param default_value: -
:param description: -
:param label: -
:param max_length: -
:param max_value: -
:param min_length: -
:param min_value: -
:param no_echo: -
:param text_area: -
:param type: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__c1eedc66bdf3ec0f47726c50b7cb3a20ea4c777331c44e83e7720074022f7d61)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
props = RosParameterProps(
allowed_pattern=allowed_pattern,
allowed_values=allowed_values,
association_property=association_property,
association_property_metadata=association_property_metadata,
confirm=confirm,
constraint_description=constraint_description,
default_value=default_value,
description=description,
label=label,
max_length=max_length,
max_value=max_value,
min_length=min_length,
min_value=min_value,
no_echo=no_echo,
text_area=text_area,
type=type,
)
jsii.create(self.__class__, self, [scope, id, props])
@jsii.member(jsii_name="resolve")
def resolve(self, _context: IResolveContext) -> typing.Any:
'''
:param _context: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__a28eb848a0f55c965d4c5b981426497b24a126948abc9ce0a408838596a87de2)
check_type(argname="argument _context", value=_context, expected_type=type_hints["_context"])
return typing.cast(typing.Any, jsii.invoke(self, "resolve", [_context]))
@jsii.member(jsii_name="validateProperties")
def validate_properties(
self,
*,
allowed_pattern: typing.Optional[builtins.str] = None,
allowed_values: typing.Optional[typing.Sequence[typing.Any]] = None,
association_property: typing.Optional[builtins.str] = None,
association_property_metadata: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
confirm: typing.Optional[builtins.bool] = None,
constraint_description: typing.Optional[typing.Union[builtins.str, typing.Mapping[builtins.str, builtins.str]]] = None,
default_value: typing.Any = None,
description: typing.Optional[typing.Union[builtins.str, typing.Mapping[builtins.str, builtins.str]]] = None,
label: typing.Optional[builtins.str] = None,
max_length: typing.Optional[jsii.Number] = None,
max_value: typing.Optional[jsii.Number] = None,
min_length: typing.Optional[jsii.Number] = None,
min_value: typing.Optional[jsii.Number] = None,
no_echo: typing.Optional[builtins.bool] = None,
text_area: typing.Optional[builtins.bool] = None,
type: typing.Optional[RosParameterType] = None,
) -> None:
'''
:param allowed_pattern: -
:param allowed_values: -
:param association_property: -
:param association_property_metadata: -
:param confirm: -
:param constraint_description: -
:param default_value: -
:param description: -
:param label: -
:param max_length: -
:param max_value: -
:param min_length: -
:param min_value: -
:param no_echo: -
:param text_area: -
:param type: -
'''
props = RosParameterProps(
allowed_pattern=allowed_pattern,
allowed_values=allowed_values,
association_property=association_property,
association_property_metadata=association_property_metadata,
confirm=confirm,
constraint_description=constraint_description,
default_value=default_value,
description=description,
label=label,
max_length=max_length,
max_value=max_value,
min_length=min_length,
min_value=min_value,
no_echo=no_echo,
text_area=text_area,
type=type,
)
return typing.cast(None, jsii.invoke(self, "validateProperties", [props]))
@jsii.python.classproperty
@jsii.member(jsii_name="TYPE_ALLOWED_VALUES")
def TYPE_ALLOWED_VALUES(cls) -> typing.List[builtins.str]:
return typing.cast(typing.List[builtins.str], jsii.sget(cls, "TYPE_ALLOWED_VALUES"))
@builtins.property
@jsii.member(jsii_name="noEcho")
def no_echo(self) -> builtins.bool:
'''Indicates if this parameter is configured with "NoEcho" enabled.'''
return typing.cast(builtins.bool, jsii.get(self, "noEcho"))
@builtins.property
@jsii.member(jsii_name="value")
def value(self) -> IResolvable:
'''The parameter value as a Token.'''
return typing.cast(IResolvable, jsii.get(self, "value"))
@builtins.property
@jsii.member(jsii_name="valueAsAny")
def value_as_any(self) -> typing.Any:
'''The parameter value, if it represents a string.'''
return typing.cast(typing.Any, jsii.get(self, "valueAsAny"))
@builtins.property
@jsii.member(jsii_name="valueAsBoolean")
def value_as_boolean(self) -> typing.Any:
'''The parameter value, if it represents a string.'''
return typing.cast(typing.Any, jsii.get(self, "valueAsBoolean"))
@builtins.property
@jsii.member(jsii_name="valueAsList")
def value_as_list(self) -> typing.List[builtins.str]:
'''The parameter value, if it represents a string list.'''
return typing.cast(typing.List[builtins.str], jsii.get(self, "valueAsList"))
@builtins.property
@jsii.member(jsii_name="valueAsNumber")
def value_as_number(self) -> jsii.Number:
'''The parameter value, if it represents a number.'''
return typing.cast(jsii.Number, jsii.get(self, "valueAsNumber"))
@builtins.property
@jsii.member(jsii_name="valueAsString")
def value_as_string(self) -> builtins.str:
'''The parameter value, if it represents a string.'''
return typing.cast(builtins.str, jsii.get(self, "valueAsString"))
class AssociationProperty(
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-core.RosParameter.AssociationProperty",
):
def __init__(self) -> None:
jsii.create(self.__class__, self, [])
@jsii.python.classproperty
@jsii.member(jsii_name="ALB_ACL_ID")
def ALB_ACL_ID(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "ALB_ACL_ID"))
@jsii.python.classproperty
@jsii.member(jsii_name="ALB_INSTANCE_ID")
def ALB_INSTANCE_ID(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "ALB_INSTANCE_ID"))
@jsii.python.classproperty
@jsii.member(jsii_name="ALB_LOAD_BALANCER_ID")
def ALB_LOAD_BALANCER_ID(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "ALB_LOAD_BALANCER_ID"))
@jsii.python.classproperty
@jsii.member(jsii_name="ALERT")
def ALERT(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "ALERT"))
@jsii.python.classproperty
@jsii.member(jsii_name="ARRAY_ITEMS")
def ARRAY_ITEMS(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "ARRAY_ITEMS"))
@jsii.python.classproperty
@jsii.member(jsii_name="ARRAY_TABLE")
def ARRAY_TABLE(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "ARRAY_TABLE"))
@jsii.python.classproperty
@jsii.member(jsii_name="BOOLEAN")
def BOOLEAN(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "BOOLEAN"))
@jsii.python.classproperty
@jsii.member(jsii_name="CAS_CERTIFICATE")
def CAS_CERTIFICATE(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "CAS_CERTIFICATE"))
@jsii.python.classproperty
@jsii.member(jsii_name="CAS_CERTIFICATE_ID")
def CAS_CERTIFICATE_ID(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "CAS_CERTIFICATE_ID"))
@jsii.python.classproperty
@jsii.member(jsii_name="CASCADER")
def CASCADER(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "CASCADER"))
@jsii.python.classproperty
@jsii.member(jsii_name="CHARGE_TYPE")
def CHARGE_TYPE(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "CHARGE_TYPE"))
@jsii.python.classproperty
@jsii.member(jsii_name="CMS_ALARM_RULE")
def CMS_ALARM_RULE(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "CMS_ALARM_RULE"))
@jsii.python.classproperty
@jsii.member(jsii_name="CMS_ALARM_SILENCE_TIME")
def CMS_ALARM_SILENCE_TIME(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "CMS_ALARM_SILENCE_TIME"))
@jsii.python.classproperty
@jsii.member(jsii_name="CMS_ALARM_TRIGGER_RESOURCES")
def CMS_ALARM_TRIGGER_RESOURCES(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "CMS_ALARM_TRIGGER_RESOURCES"))
@jsii.python.classproperty
@jsii.member(jsii_name="CMS_EVENT_FILTER_RULE")
def CMS_EVENT_FILTER_RULE(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "CMS_EVENT_FILTER_RULE"))
@jsii.python.classproperty
@jsii.member(jsii_name="CMS_EVENT_LEVEL")
def CMS_EVENT_LEVEL(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "CMS_EVENT_LEVEL"))
@jsii.python.classproperty
@jsii.member(jsii_name="CMS_EVENT_NAME")
def CMS_EVENT_NAME(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "CMS_EVENT_NAME"))
@jsii.python.classproperty
@jsii.member(jsii_name="CMS_PRODUCT_TYPE")
def CMS_PRODUCT_TYPE(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "CMS_PRODUCT_TYPE"))
@jsii.python.classproperty
@jsii.member(jsii_name="CODE")
def CODE(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "CODE"))
@jsii.python.classproperty
@jsii.member(jsii_name="COMMA_DELIMITED_LIST")
def COMMA_DELIMITED_LIST(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "COMMA_DELIMITED_LIST"))
@jsii.python.classproperty
@jsii.member(jsii_name="COMPUTER_NEST_SERVICE_ID")
def COMPUTER_NEST_SERVICE_ID(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "COMPUTER_NEST_SERVICE_ID"))
@jsii.python.classproperty
@jsii.member(jsii_name="COMPUTER_NEST_SERVICE_INSTANCE_ID")
def COMPUTER_NEST_SERVICE_INSTANCE_ID(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "COMPUTER_NEST_SERVICE_INSTANCE_ID"))
@jsii.python.classproperty
@jsii.member(jsii_name="COMPUTER_NEST_SUPPLIER_SERVICE_VERSION")
def COMPUTER_NEST_SUPPLIER_SERVICE_VERSION(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "COMPUTER_NEST_SUPPLIER_SERVICE_VERSION"))
@jsii.python.classproperty
@jsii.member(jsii_name="CRON")
def CRON(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "CRON"))
@jsii.python.classproperty
@jsii.member(jsii_name="CS_CLUSTER_ID")
def CS_CLUSTER_ID(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "CS_CLUSTER_ID"))
@jsii.python.classproperty
@jsii.member(jsii_name="CS_CLUSTER_NODE_POOL")
def CS_CLUSTER_NODE_POOL(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "CS_CLUSTER_NODE_POOL"))
@jsii.python.classproperty
@jsii.member(jsii_name="DATE_PICKER")
def DATE_PICKER(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "DATE_PICKER"))
@jsii.python.classproperty
@jsii.member(jsii_name="DATE_TIME")
def DATE_TIME(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "DATE_TIME"))
@jsii.python.classproperty
@jsii.member(jsii_name="ECS_AUTO_SNAPSHOT_POLICY_ID")
def ECS_AUTO_SNAPSHOT_POLICY_ID(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "ECS_AUTO_SNAPSHOT_POLICY_ID"))
@jsii.python.classproperty
@jsii.member(jsii_name="ECS_COMMAND_ID")
def ECS_COMMAND_ID(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "ECS_COMMAND_ID"))
@jsii.python.classproperty
@jsii.member(jsii_name="ECS_DATA_DISK_CATEGORY")
def ECS_DATA_DISK_CATEGORY(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "ECS_DATA_DISK_CATEGORY"))
@jsii.python.classproperty
@jsii.member(jsii_name="ECS_DISK_ID")
def ECS_DISK_ID(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "ECS_DISK_ID"))
@jsii.python.classproperty
@jsii.member(jsii_name="ECS_IMAGE_ID")
def ECS_IMAGE_ID(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "ECS_IMAGE_ID"))
@jsii.python.classproperty
@jsii.member(jsii_name="ECS_INSTANCE")
def ECS_INSTANCE(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "ECS_INSTANCE"))
@jsii.python.classproperty
@jsii.member(jsii_name="ECS_INSTANCE_ATTRIBUTE_SELECTOR")
def ECS_INSTANCE_ATTRIBUTE_SELECTOR(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "ECS_INSTANCE_ATTRIBUTE_SELECTOR"))
@jsii.python.classproperty
@jsii.member(jsii_name="ECS_INSTANCE_ID")
def ECS_INSTANCE_ID(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "ECS_INSTANCE_ID"))
@jsii.python.classproperty
@jsii.member(jsii_name="ECS_INSTANCE_IMAGE_ID")
def ECS_INSTANCE_IMAGE_ID(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "ECS_INSTANCE_IMAGE_ID"))
@jsii.python.classproperty
@jsii.member(jsii_name="ECS_INSTANCE_MAX_BANDWIDTH_IN")
def ECS_INSTANCE_MAX_BANDWIDTH_IN(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "ECS_INSTANCE_MAX_BANDWIDTH_IN"))
@jsii.python.classproperty
@jsii.member(jsii_name="ECS_INSTANCE_PASSWORD")
def ECS_INSTANCE_PASSWORD(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "ECS_INSTANCE_PASSWORD"))
@jsii.python.classproperty
@jsii.member(jsii_name="ECS_INSTANCE_PROPERTY_EDITOR")
def ECS_INSTANCE_PROPERTY_EDITOR(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "ECS_INSTANCE_PROPERTY_EDITOR"))
@jsii.python.classproperty
@jsii.member(jsii_name="ECS_INSTANCE_RENEW_PERIOD")
def ECS_INSTANCE_RENEW_PERIOD(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "ECS_INSTANCE_RENEW_PERIOD"))
@jsii.python.classproperty
@jsii.member(jsii_name="ECS_INSTANCE_STOP_MODE")
def ECS_INSTANCE_STOP_MODE(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "ECS_INSTANCE_STOP_MODE"))
@jsii.python.classproperty
@jsii.member(jsii_name="ECS_INSTANCE_TYPE")
def ECS_INSTANCE_TYPE(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "ECS_INSTANCE_TYPE"))
@jsii.python.classproperty
@jsii.member(jsii_name="ECS_INSTANCE_TYPE_AVAILABLE_INSTANCE_TYPE")
def ECS_INSTANCE_TYPE_AVAILABLE_INSTANCE_TYPE(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "ECS_INSTANCE_TYPE_AVAILABLE_INSTANCE_TYPE"))
@jsii.python.classproperty
@jsii.member(jsii_name="ECS_INSTANCE_ZONE_ID")
def ECS_INSTANCE_ZONE_ID(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "ECS_INSTANCE_ZONE_ID"))
@jsii.python.classproperty
@jsii.member(jsii_name="ECS_KEY_PAIR_NAME")
def ECS_KEY_PAIR_NAME(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "ECS_KEY_PAIR_NAME"))
@jsii.python.classproperty
@jsii.member(jsii_name="ECS_LAUNCH_TEMPLATE_ID")
def ECS_LAUNCH_TEMPLATE_ID(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "ECS_LAUNCH_TEMPLATE_ID"))
@jsii.python.classproperty
@jsii.member(jsii_name="ECS_LAUNCH_TEMPLATE_VERSION")
def ECS_LAUNCH_TEMPLATE_VERSION(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "ECS_LAUNCH_TEMPLATE_VERSION"))
@jsii.python.classproperty
@jsii.member(jsii_name="ECS_MANAGED_INSTANCE_ID")
def ECS_MANAGED_INSTANCE_ID(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "ECS_MANAGED_INSTANCE_ID"))
@jsii.python.classproperty
@jsii.member(jsii_name="ECS_RAM_ROLE")
def ECS_RAM_ROLE(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "ECS_RAM_ROLE"))
@jsii.python.classproperty
@jsii.member(jsii_name="ECS_REGION_ID")
def ECS_REGION_ID(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "ECS_REGION_ID"))
@jsii.python.classproperty
@jsii.member(jsii_name="ECS_RESOURCE_GROUP_ID")
def ECS_RESOURCE_GROUP_ID(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "ECS_RESOURCE_GROUP_ID"))
@jsii.python.classproperty
@jsii.member(jsii_name="ECS_SECURITY_GROUP_ID")
def ECS_SECURITY_GROUP_ID(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "ECS_SECURITY_GROUP_ID"))
@jsii.python.classproperty
@jsii.member(jsii_name="ECS_SNAPSHOT_ID")
def ECS_SNAPSHOT_ID(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "ECS_SNAPSHOT_ID"))
@jsii.python.classproperty
@jsii.member(jsii_name="ECS_SYSTEM_DISK_CATEGORY")
def ECS_SYSTEM_DISK_CATEGORY(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "ECS_SYSTEM_DISK_CATEGORY"))
@jsii.python.classproperty
@jsii.member(jsii_name="ECS_TAG")
def ECS_TAG(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "ECS_TAG"))
@jsii.python.classproperty
@jsii.member(jsii_name="ECS_TARGET_REGION_IDS")
def ECS_TARGET_REGION_IDS(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "ECS_TARGET_REGION_IDS"))
@jsii.python.classproperty
@jsii.member(jsii_name="ECS_VPC_ID")
def ECS_VPC_ID(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "ECS_VPC_ID"))
@jsii.python.classproperty
@jsii.member(jsii_name="ECS_VSWITCH")
def ECS_VSWITCH(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "ECS_VSWITCH"))
@jsii.python.classproperty
@jsii.member(jsii_name="ECS_VSWITCH_ID")
def ECS_VSWITCH_ID(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "ECS_VSWITCH_ID"))
@jsii.python.classproperty
@jsii.member(jsii_name="ECS_ZONE_ID")
def ECS_ZONE_ID(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "ECS_ZONE_ID"))
@jsii.python.classproperty
@jsii.member(jsii_name="EDITABLE")
def EDITABLE(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "EDITABLE"))
@jsii.python.classproperty
@jsii.member(jsii_name="EDITABLE_POPOVER")
def EDITABLE_POPOVER(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "EDITABLE_POPOVER"))
@jsii.python.classproperty
@jsii.member(jsii_name="EHPC_CLUSTER_ID")
def EHPC_CLUSTER_ID(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "EHPC_CLUSTER_ID"))
@jsii.python.classproperty
@jsii.member(jsii_name="EHPC_FILE_SYSTEM_ID")
def EHPC_FILE_SYSTEM_ID(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "EHPC_FILE_SYSTEM_ID"))
@jsii.python.classproperty
@jsii.member(jsii_name="EHPC_FILE_SYSTEM_MOUNT_TARGET_DOMAIN")
def EHPC_FILE_SYSTEM_MOUNT_TARGET_DOMAIN(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "EHPC_FILE_SYSTEM_MOUNT_TARGET_DOMAIN"))
@jsii.python.classproperty
@jsii.member(jsii_name="ELASTICSEARCH_INSTANCE_TYPE")
def ELASTICSEARCH_INSTANCE_TYPE(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "ELASTICSEARCH_INSTANCE_TYPE"))
@jsii.python.classproperty
@jsii.member(jsii_name="ESS_AUTO_SCALING_GROUP_ID")
def ESS_AUTO_SCALING_GROUP_ID(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "ESS_AUTO_SCALING_GROUP_ID"))
@jsii.python.classproperty
@jsii.member(jsii_name="ESS_SCALING_CONFIGURATION_ID")
def ESS_SCALING_CONFIGURATION_ID(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "ESS_SCALING_CONFIGURATION_ID"))
@jsii.python.classproperty
@jsii.member(jsii_name="FILE_CONTENT")
def FILE_CONTENT(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "FILE_CONTENT"))
@jsii.python.classproperty
@jsii.member(jsii_name="FORM_GRID")
def FORM_GRID(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "FORM_GRID"))
@jsii.python.classproperty
@jsii.member(jsii_name="FORM_GROUP_COLLAPSE_PAN")
def FORM_GROUP_COLLAPSE_PAN(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "FORM_GROUP_COLLAPSE_PAN"))
@jsii.python.classproperty
@jsii.member(jsii_name="FORM_ITEM")
def FORM_ITEM(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "FORM_ITEM"))
@jsii.python.classproperty
@jsii.member(jsii_name="FORM_ITEM_GROUP")
def FORM_ITEM_GROUP(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "FORM_ITEM_GROUP"))
@jsii.python.classproperty
@jsii.member(jsii_name="FORM_LAYOUT")
def FORM_LAYOUT(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "FORM_LAYOUT"))
@jsii.python.classproperty
@jsii.member(jsii_name="GMT_ZONE")
def GMT_ZONE(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "GMT_ZONE"))
@jsii.python.classproperty
@jsii.member(jsii_name="INFLUX_DB_INSTANCE_TYPE")
def INFLUX_DB_INSTANCE_TYPE(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "INFLUX_DB_INSTANCE_TYPE"))
@jsii.python.classproperty
@jsii.member(jsii_name="INPUT")
def INPUT(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "INPUT"))
@jsii.python.classproperty
@jsii.member(jsii_name="INTEGER")
def INTEGER(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "INTEGER"))
@jsii.python.classproperty
@jsii.member(jsii_name="JSON")
def JSON(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "JSON"))
@jsii.python.classproperty
@jsii.member(jsii_name="LIST")
def LIST(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "LIST"))
@jsii.python.classproperty
@jsii.member(jsii_name="LIST_PARAMETER")
def LIST_PARAMETER(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "LIST_PARAMETER"))
@jsii.python.classproperty
@jsii.member(jsii_name="LIST_PARAMETERS")
def LIST_PARAMETERS(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "LIST_PARAMETERS"))
@jsii.python.classproperty
@jsii.member(jsii_name="MONGODB_INSTANCE_TYPE")
def MONGODB_INSTANCE_TYPE(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "MONGODB_INSTANCE_TYPE"))
@jsii.python.classproperty
@jsii.member(jsii_name="NEST_SERVICE_ID")
def NEST_SERVICE_ID(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "NEST_SERVICE_ID"))
@jsii.python.classproperty
@jsii.member(jsii_name="NEST_SERVICE_VERSION")
def NEST_SERVICE_VERSION(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "NEST_SERVICE_VERSION"))
@jsii.python.classproperty
@jsii.member(jsii_name="NLB_INSTANCE_ID")
def NLB_INSTANCE_ID(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "NLB_INSTANCE_ID"))
@jsii.python.classproperty
@jsii.member(jsii_name="NLB_LOAD_BALANCER_ID")
def NLB_LOAD_BALANCER_ID(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "NLB_LOAD_BALANCER_ID"))
@jsii.python.classproperty
@jsii.member(jsii_name="NLB_ZONE_ID")
def NLB_ZONE_ID(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "NLB_ZONE_ID"))
@jsii.python.classproperty
@jsii.member(jsii_name="NUMBER")
def NUMBER(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "NUMBER"))
@jsii.python.classproperty
@jsii.member(jsii_name="NUMBER_PICKER")
def NUMBER_PICKER(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "NUMBER_PICKER"))
@jsii.python.classproperty
@jsii.member(jsii_name="OOS_COMMAND_CONTENT")
def OOS_COMMAND_CONTENT(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "OOS_COMMAND_CONTENT"))
@jsii.python.classproperty
@jsii.member(jsii_name="OOS_COMPONENT_BANDWIDTH_UPGRADE_DURATION_HOUR")
def OOS_COMPONENT_BANDWIDTH_UPGRADE_DURATION_HOUR(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "OOS_COMPONENT_BANDWIDTH_UPGRADE_DURATION_HOUR"))
@jsii.python.classproperty
@jsii.member(jsii_name="OOS_COMPONENT_CLEAN_UP_INFO")
def OOS_COMPONENT_CLEAN_UP_INFO(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "OOS_COMPONENT_CLEAN_UP_INFO"))
@jsii.python.classproperty
@jsii.member(jsii_name="OOS_COMPONENT_ON_OFF_TIME_LINE")
def OOS_COMPONENT_ON_OFF_TIME_LINE(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "OOS_COMPONENT_ON_OFF_TIME_LINE"))
@jsii.python.classproperty
@jsii.member(jsii_name="OOS_COMPONENT_ON_OFF_TIMES")
def OOS_COMPONENT_ON_OFF_TIMES(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "OOS_COMPONENT_ON_OFF_TIMES"))
@jsii.python.classproperty
@jsii.member(jsii_name="OOS_COMPONENT_OPERATION_TYPE")
def OOS_COMPONENT_OPERATION_TYPE(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "OOS_COMPONENT_OPERATION_TYPE"))
@jsii.python.classproperty
@jsii.member(jsii_name="OOS_COMPONENT_PRIVATE_TEMPLATE_NAME")
def OOS_COMPONENT_PRIVATE_TEMPLATE_NAME(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "OOS_COMPONENT_PRIVATE_TEMPLATE_NAME"))
@jsii.python.classproperty
@jsii.member(jsii_name="OOS_COMPONENT_SECTION_TYPE")
def OOS_COMPONENT_SECTION_TYPE(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "OOS_COMPONENT_SECTION_TYPE"))
@jsii.python.classproperty
@jsii.member(jsii_name="OOS_COMPONENT_TARGET_IMAGE_NAME")
def OOS_COMPONENT_TARGET_IMAGE_NAME(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "OOS_COMPONENT_TARGET_IMAGE_NAME"))
@jsii.python.classproperty
@jsii.member(jsii_name="OOS_COMPONENT_TIMER_TRIGGER")
def OOS_COMPONENT_TIMER_TRIGGER(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "OOS_COMPONENT_TIMER_TRIGGER"))
@jsii.python.classproperty
@jsii.member(jsii_name="OOS_COMPONENT_TRANSIT_INSTANCE")
def OOS_COMPONENT_TRANSIT_INSTANCE(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "OOS_COMPONENT_TRANSIT_INSTANCE"))
@jsii.python.classproperty
@jsii.member(jsii_name="OOS_FILE_URL")
def OOS_FILE_URL(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "OOS_FILE_URL"))
@jsii.python.classproperty
@jsii.member(jsii_name="OOS_PACKAGE_NAME")
def OOS_PACKAGE_NAME(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "OOS_PACKAGE_NAME"))
@jsii.python.classproperty
@jsii.member(jsii_name="OOS_PACKAGE_VERSION")
def OOS_PACKAGE_VERSION(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "OOS_PACKAGE_VERSION"))
@jsii.python.classproperty
@jsii.member(jsii_name="OOS_PARAMETER_VALUE")
def OOS_PARAMETER_VALUE(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "OOS_PARAMETER_VALUE"))
@jsii.python.classproperty
@jsii.member(jsii_name="OOS_SECRET_PARAMETER_VALUE")
def OOS_SECRET_PARAMETER_VALUE(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "OOS_SECRET_PARAMETER_VALUE"))
@jsii.python.classproperty
@jsii.member(jsii_name="OOS_SERVICE_ROLE")
def OOS_SERVICE_ROLE(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "OOS_SERVICE_ROLE"))
@jsii.python.classproperty
@jsii.member(jsii_name="OOS_TEMPLATE_NAME")
def OOS_TEMPLATE_NAME(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "OOS_TEMPLATE_NAME"))
@jsii.python.classproperty
@jsii.member(jsii_name="OOS_TEMPLATE_VERSION")
def OOS_TEMPLATE_VERSION(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "OOS_TEMPLATE_VERSION"))
@jsii.python.classproperty
@jsii.member(jsii_name="OSS_BUCKET_NAME")
def OSS_BUCKET_NAME(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "OSS_BUCKET_NAME"))
@jsii.python.classproperty
@jsii.member(jsii_name="OSS_BUCKET_OBJECT")
def OSS_BUCKET_OBJECT(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "OSS_BUCKET_OBJECT"))
@jsii.python.classproperty
@jsii.member(jsii_name="OSS_OBJECT_NAME")
def OSS_OBJECT_NAME(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "OSS_OBJECT_NAME"))
@jsii.python.classproperty
@jsii.member(jsii_name="PARSE_TEXT")
def PARSE_TEXT(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "PARSE_TEXT"))
@jsii.python.classproperty
@jsii.member(jsii_name="PASSWORD")
def PASSWORD(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "PASSWORD"))
@jsii.python.classproperty
@jsii.member(jsii_name="PAY_PERIOD")
def PAY_PERIOD(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "PAY_PERIOD"))
@jsii.python.classproperty
@jsii.member(jsii_name="PAY_PERIOD_UNIT")
def PAY_PERIOD_UNIT(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "PAY_PERIOD_UNIT"))
@jsii.python.classproperty
@jsii.member(jsii_name="POLARDB_DB_CLUSTER_ID")
def POLARDB_DB_CLUSTER_ID(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "POLARDB_DB_CLUSTER_ID"))
@jsii.python.classproperty
@jsii.member(jsii_name="RADIO")
def RADIO(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "RADIO"))
@jsii.python.classproperty
@jsii.member(jsii_name="RAM_ROLE")
def RAM_ROLE(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "RAM_ROLE"))
@jsii.python.classproperty
@jsii.member(jsii_name="RAM_USER")
def RAM_USER(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "RAM_USER"))
@jsii.python.classproperty
@jsii.member(jsii_name="RATE_CONTROL")
def RATE_CONTROL(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "RATE_CONTROL"))
@jsii.python.classproperty
@jsii.member(jsii_name="RDS_ENGINE_ID")
def RDS_ENGINE_ID(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "RDS_ENGINE_ID"))
@jsii.python.classproperty
@jsii.member(jsii_name="RDS_ENGINE_VERSION")
def RDS_ENGINE_VERSION(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "RDS_ENGINE_VERSION"))
@jsii.python.classproperty
@jsii.member(jsii_name="RDS_INSTANCE_ACCOUNT_PASSWORD")
def RDS_INSTANCE_ACCOUNT_PASSWORD(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "RDS_INSTANCE_ACCOUNT_PASSWORD"))
@jsii.python.classproperty
@jsii.member(jsii_name="RDS_INSTANCE_ID")
def RDS_INSTANCE_ID(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "RDS_INSTANCE_ID"))
@jsii.python.classproperty
@jsii.member(jsii_name="RDS_INSTANCE_TYPE")
def RDS_INSTANCE_TYPE(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "RDS_INSTANCE_TYPE"))
@jsii.python.classproperty
@jsii.member(jsii_name="READ_ONLY")
def READ_ONLY(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "READ_ONLY"))
@jsii.python.classproperty
@jsii.member(jsii_name="READ_ONLY_ITEM")
def READ_ONLY_ITEM(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "READ_ONLY_ITEM"))
@jsii.python.classproperty
@jsii.member(jsii_name="REDIS_INSTANCE_ID")
def REDIS_INSTANCE_ID(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "REDIS_INSTANCE_ID"))
@jsii.python.classproperty
@jsii.member(jsii_name="REDIS_INSTANCE_TYPE")
def REDIS_INSTANCE_TYPE(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "REDIS_INSTANCE_TYPE"))
@jsii.python.classproperty
@jsii.member(jsii_name="REGION_ID")
def REGION_ID(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "REGION_ID"))
@jsii.python.classproperty
@jsii.member(jsii_name="RESOURCE_MANAGER_ACCOUNT")
def RESOURCE_MANAGER_ACCOUNT(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "RESOURCE_MANAGER_ACCOUNT"))
@jsii.python.classproperty
@jsii.member(jsii_name="RESOURCE_MANAGER_FOLDER")
def RESOURCE_MANAGER_FOLDER(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "RESOURCE_MANAGER_FOLDER"))
@jsii.python.classproperty
@jsii.member(jsii_name="ROS_TYPE_META_LIST")
def ROS_TYPE_META_LIST(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "ROS_TYPE_META_LIST"))
@jsii.python.classproperty
@jsii.member(jsii_name="SELECT")
def SELECT(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "SELECT"))
@jsii.python.classproperty
@jsii.member(jsii_name="SERVICE_CATA_LOG_LAUNCH_OPTION_PORTFOLIO_ID")
def SERVICE_CATA_LOG_LAUNCH_OPTION_PORTFOLIO_ID(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "SERVICE_CATA_LOG_LAUNCH_OPTION_PORTFOLIO_ID"))
@jsii.python.classproperty
@jsii.member(jsii_name="SERVICE_CATA_LOG_LAUNCH_PRODUCT_VERSION_ID")
def SERVICE_CATA_LOG_LAUNCH_PRODUCT_VERSION_ID(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "SERVICE_CATA_LOG_LAUNCH_PRODUCT_VERSION_ID"))
@jsii.python.classproperty
@jsii.member(jsii_name="SLB_ACL_ID")
def SLB_ACL_ID(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "SLB_ACL_ID"))
@jsii.python.classproperty
@jsii.member(jsii_name="SLB_CERTIFICATE")
def SLB_CERTIFICATE(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "SLB_CERTIFICATE"))
@jsii.python.classproperty
@jsii.member(jsii_name="SLB_INSTANCE_ID")
def SLB_INSTANCE_ID(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "SLB_INSTANCE_ID"))
@jsii.python.classproperty
@jsii.member(jsii_name="SLB_INSTANCE_TYPE")
def SLB_INSTANCE_TYPE(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "SLB_INSTANCE_TYPE"))
@jsii.python.classproperty
@jsii.member(jsii_name="SLB_LOAD_BALANCER_ID")
def SLB_LOAD_BALANCER_ID(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "SLB_LOAD_BALANCER_ID"))
@jsii.python.classproperty
@jsii.member(jsii_name="STRING")
def STRING(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "STRING"))
@jsii.python.classproperty
@jsii.member(jsii_name="SWITCH")
def SWITCH(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "SWITCH"))
@jsii.python.classproperty
@jsii.member(jsii_name="TAGS")
def TAGS(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "TAGS"))
@jsii.python.classproperty
@jsii.member(jsii_name="TARGETS")
def TARGETS(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "TARGETS"))
@jsii.python.classproperty
@jsii.member(jsii_name="TEMPLATE_NAME")
def TEMPLATE_NAME(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "TEMPLATE_NAME"))
@jsii.python.classproperty
@jsii.member(jsii_name="TEMPLATE_PARAMETER")
def TEMPLATE_PARAMETER(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "TEMPLATE_PARAMETER"))
@jsii.python.classproperty
@jsii.member(jsii_name="TEXT_AREA")
def TEXT_AREA(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "TEXT_AREA"))
@jsii.python.classproperty
@jsii.member(jsii_name="TIME")
def TIME(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "TIME"))
@jsii.python.classproperty
@jsii.member(jsii_name="TIME_TRIGGER")
def TIME_TRIGGER(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "TIME_TRIGGER"))
@jsii.python.classproperty
@jsii.member(jsii_name="TIME_TRIGGER_WEEKLY")
def TIME_TRIGGER_WEEKLY(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "TIME_TRIGGER_WEEKLY"))
@jsii.python.classproperty
@jsii.member(jsii_name="TIME_ZONE")
def TIME_ZONE(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "TIME_ZONE"))
@jsii.python.classproperty
@jsii.member(jsii_name="USER_ACCOUNT_IDS")
def USER_ACCOUNT_IDS(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "USER_ACCOUNT_IDS"))
@jsii.python.classproperty
@jsii.member(jsii_name="VPC_CIDR_BLOCK")
def VPC_CIDR_BLOCK(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "VPC_CIDR_BLOCK"))
@jsii.python.classproperty
@jsii.member(jsii_name="VPC_NAT_GATEWAY_ID")
def VPC_NAT_GATEWAY_ID(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "VPC_NAT_GATEWAY_ID"))
@jsii.python.classproperty
@jsii.member(jsii_name="VPC_ROUTER_ROUTE_TABLE_ID")
def VPC_ROUTER_ROUTE_TABLE_ID(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "VPC_ROUTER_ROUTE_TABLE_ID"))
@jsii.python.classproperty
@jsii.member(jsii_name="VPC_VSWITCH_ID")
def VPC_VSWITCH_ID(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "VPC_VSWITCH_ID"))
@jsii.python.classproperty
@jsii.member(jsii_name="VPC_ZONE_ID")
def VPC_ZONE_ID(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "VPC_ZONE_ID"))
@jsii.python.classproperty
@jsii.member(jsii_name="VSWITCH_CIDR_BLOCK")
def VSWITCH_CIDR_BLOCK(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "VSWITCH_CIDR_BLOCK"))
@jsii.python.classproperty
@jsii.member(jsii_name="ZONE_ID")
def ZONE_ID(cls) -> builtins.str:
return typing.cast(builtins.str, jsii.sget(cls, "ZONE_ID"))
class RosRefElement(
RosElement,
metaclass=jsii.JSIIAbstractClass,
jsii_type="@alicloud/ros-cdk-core.RosRefElement",
):
'''Base class for referenceable template constructs which are not Resources.
These constructs are things like Conditions and Parameters, can be
referenced by taking the ``.ref`` attribute.
Resource constructs do not inherit from RosRefElement because they have their
own, more specific types returned from the .ref attribute. Also, some
resources aren't referenceable at all (such as BucketPolicies or GatewayAttachments).
'''
def __init__(self, scope: Construct, id: builtins.str) -> None:
'''Creates an entity and binds it to a tree.
Note that the root of the tree must be a Stack object (not just any Root).
:param scope: The parent construct.
:param id: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__bc68be0ccd998c03d226dee9f58b58db58d51777d1dcb148ca8580210f62d8da)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
jsii.create(self.__class__, self, [scope, id])
@builtins.property
@jsii.member(jsii_name="ref")
def ref(self) -> builtins.str:
'''Return a string that will be resolved to a RosTemplate ``{ Ref }`` for this element.
If, by any chance, the intrinsic reference of a resource is not a string, you could
coerce it to an IResolvable through ``Lazy.any({ produce: resource.ref })``.
'''
return typing.cast(builtins.str, jsii.get(self, "ref"))
class _RosRefElementProxy(
RosRefElement,
jsii.proxy_for(RosElement), # type: ignore[misc]
):
pass
# Adding a "__jsii_proxy_class__(): typing.Type" function to the abstract class
typing.cast(typing.Any, RosRefElement).__jsii_proxy_class__ = lambda : _RosRefElementProxy
class RosResource(
RosRefElement,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-core.RosResource",
):
'''Represents a ROS resource.'''
def __init__(
self,
scope: Construct,
id: builtins.str,
*,
type: builtins.str,
properties: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
) -> None:
'''Creates a resource construct.
:param scope: -
:param id: -
:param type: ROS template resource type (e.g. ``ALIYUN::ECS::Instance``).
:param properties: Resource properties. Default: - No resource properties.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__941346c4ba544e38c6d484ee04db6f28c2e03e3998827ec04c07caeb8e3513b9)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
props = RosResourceProps(type=type, properties=properties)
jsii.create(self.__class__, self, [scope, id, props])
@jsii.member(jsii_name="isRosResource")
@builtins.classmethod
def is_ros_resource(cls, construct: IConstruct) -> builtins.bool:
'''Check whether the given construct is a RosResource.
:param construct: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__26a7a5bd0c2c812f4b7c3483c22ba2665d748cd34851f26f18d362f3b7641568)
check_type(argname="argument construct", value=construct, expected_type=type_hints["construct"])
return typing.cast(builtins.bool, jsii.sinvoke(cls, "isRosResource", [construct]))
@jsii.member(jsii_name="addCondition")
def add_condition(self, con: "RosCondition") -> None:
'''
:param con: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__3bab3990b90c81f3ea564fe13bb7a16fd3f3b943f93b68220c584761a015331f)
check_type(argname="argument con", value=con, expected_type=type_hints["con"])
return typing.cast(None, jsii.invoke(self, "addCondition", [con]))
@jsii.member(jsii_name="addCount")
def add_count(self, count: typing.Union[jsii.Number, IResolvable]) -> None:
'''
:param count: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__6dcfa9031021a07adecdb44494c0f0c80c2d66bd014996148e6443d50d8f4755)
check_type(argname="argument count", value=count, expected_type=type_hints["count"])
return typing.cast(None, jsii.invoke(self, "addCount", [count]))
@jsii.member(jsii_name="addDeletionOverride")
def add_deletion_override(self, path: builtins.str) -> None:
'''Syntactic sugar for ``addOverride(path, undefined)``.
:param path: The path of the value to delete.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__5dc20ad26961aac937f4a09fe1babbdd7982bf6c0e340f79c2662c20030cd319)
check_type(argname="argument path", value=path, expected_type=type_hints["path"])
return typing.cast(None, jsii.invoke(self, "addDeletionOverride", [path]))
@jsii.member(jsii_name="addDependsOn")
def add_depends_on(self, target: "RosResource") -> None:
'''Indicates that this resource depends on another resource and cannot be provisioned unless the other resource has been successfully provisioned.
This can be used for resources across stacks (or nested stack) boundaries
and the dependency will automatically be transferred to the relevant scope.
:param target: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__4fcdc2057253d1e8056633ce513f71b142942e1b4c71bbd14bffbb951ce349db)
check_type(argname="argument target", value=target, expected_type=type_hints["target"])
return typing.cast(None, jsii.invoke(self, "addDependsOn", [target]))
@jsii.member(jsii_name="addDesc")
def add_desc(self, desc: builtins.str) -> None:
'''
:param desc: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__5603f5e790e6800ca247898c0a76a748b08bdccea54b2f8d8ef44dcd446d54b3)
check_type(argname="argument desc", value=desc, expected_type=type_hints["desc"])
return typing.cast(None, jsii.invoke(self, "addDesc", [desc]))
@jsii.member(jsii_name="addMetaData")
def add_meta_data(self, key: builtins.str, value: typing.Any) -> None:
'''
:param key: -
:param value: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__e8d8fdbfca26a1b9c08967852905c7f2c18defd647238b134e1b34d1f98622c7)
check_type(argname="argument key", value=key, expected_type=type_hints["key"])
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
return typing.cast(None, jsii.invoke(self, "addMetaData", [key, value]))
@jsii.member(jsii_name="addOverride")
def add_override(self, path: builtins.str, value: typing.Any) -> None:
'''Adds an override to the synthesized ROS resource.
To add a
property override, either use ``addPropertyOverride`` or prefix ``path`` with
"Properties." (i.e. ``Properties.TopicName``).
If the override is nested, separate each nested level using a dot (.) in the path parameter.
If there is an array as part of the nesting, specify the index in the path.
For example::
addOverride('Properties.GlobalSecondaryIndexes.0.Projection.NonKeyAttributes', ['myattribute'])
addOverride('Properties.GlobalSecondaryIndexes.1.ProjectionType', 'INCLUDE')
would add the overrides Example::
"Properties": {
"GlobalSecondaryIndexes": [
{
"Projection": {
"NonKeyAttributes": [ "myattribute" ]
...
}
...
},
{
"ProjectionType": "INCLUDE"
...
},
]
...
}
:param path: - The path of the property, you can use dot notation to override values in complex types. Any intermdediate keys will be created as needed.
:param value: - The value. Could be primitive or complex.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__de4d904e391329b12281f41d993ef7bec66f72067ac6df107010c7da6ad60fc6)
check_type(argname="argument path", value=path, expected_type=type_hints["path"])
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
return typing.cast(None, jsii.invoke(self, "addOverride", [path, value]))
@jsii.member(jsii_name="addPropertyDeletionOverride")
def add_property_deletion_override(self, property_path: builtins.str) -> None:
'''Adds an override that deletes the value of a property from the resource definition.
:param property_path: The path to the property.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__e73a34b5fd578a1a0e6d239f8de7f429c7c7cb23dd01e234b26d2537a37db7e1)
check_type(argname="argument property_path", value=property_path, expected_type=type_hints["property_path"])
return typing.cast(None, jsii.invoke(self, "addPropertyDeletionOverride", [property_path]))
@jsii.member(jsii_name="addPropertyOverride")
def add_property_override(
self,
property_path: builtins.str,
value: typing.Any,
) -> None:
'''Adds an override to a resource property.
Syntactic sugar for ``addOverride("Properties.<...>", value)``.
:param property_path: The path of the property.
:param value: The value.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__3d3152a58d03df66e61a691c9a3e2407cd03751db0aa384483e63e6239031b34)
check_type(argname="argument property_path", value=property_path, expected_type=type_hints["property_path"])
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
return typing.cast(None, jsii.invoke(self, "addPropertyOverride", [property_path, value]))
@jsii.member(jsii_name="addRosDependency")
def add_ros_dependency(self, target: builtins.str) -> None:
'''
:param target: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__571aed41b9b5890cca2490033e2ffea5957ed69b0a36cc932074ac2aff4688ec)
check_type(argname="argument target", value=target, expected_type=type_hints["target"])
return typing.cast(None, jsii.invoke(self, "addRosDependency", [target]))
@jsii.member(jsii_name="applyRemovalPolicy")
def apply_removal_policy(
self,
policy: typing.Optional[RemovalPolicy] = None,
*,
apply_to_update_replace_policy: typing.Optional[builtins.bool] = None,
default_policy: typing.Optional[RemovalPolicy] = None,
) -> None:
'''Sets the deletion policy of the resource based on the removal policy specified.
:param policy: -
:param apply_to_update_replace_policy: -
:param default_policy: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__f11f6c0e586fc49c3773a537af49ac2e497dcc49ecdecb8c4d92702a8e66a7e4)
check_type(argname="argument policy", value=policy, expected_type=type_hints["policy"])
options = RemovalPolicyOptions(
apply_to_update_replace_policy=apply_to_update_replace_policy,
default_policy=default_policy,
)
return typing.cast(None, jsii.invoke(self, "applyRemovalPolicy", [policy, options]))
@jsii.member(jsii_name="getAtt")
def get_att(self, attribute_name: builtins.str) -> Reference:
'''Returns a token for an runtime attribute of this resource.
Ideally, use generated attribute accessors (e.g. ``resource.arn``), but this can be used for future compatibility
in case there is no generated attribute.
:param attribute_name: The name of the attribute.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__01a8a56058b17a312f5ffb8ca87bdfeb2749ff430a4213b4a7dda2c476ab0ef4)
check_type(argname="argument attribute_name", value=attribute_name, expected_type=type_hints["attribute_name"])
return typing.cast(Reference, jsii.invoke(self, "getAtt", [attribute_name]))
@jsii.member(jsii_name="renderProperties")
def _render_properties(
self,
props: typing.Mapping[builtins.str, typing.Any],
) -> typing.Mapping[builtins.str, typing.Any]:
'''
:param props: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__980668d774fee5ae667c0a3cf02ce68aedfdf3b8f92d10348ec1a94883c0c78b)
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))
@jsii.member(jsii_name="toString")
def to_string(self) -> builtins.str:
'''Returns a string representation of this construct.
:return: a string representation of this resource
'''
return typing.cast(builtins.str, jsii.invoke(self, "toString", []))
@jsii.member(jsii_name="validateProperties")
def _validate_properties(self, _properties: typing.Any) -> None:
'''
:param _properties: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__6e75c1ebcfe210720730289132506828c5a1e5c261f68ef912e260fdd4f28fd4)
check_type(argname="argument _properties", value=_properties, expected_type=type_hints["_properties"])
return typing.cast(None, jsii.invoke(self, "validateProperties", [_properties]))
@builtins.property
@jsii.member(jsii_name="rosOptions")
def ros_options(self) -> IRosResourceOptions:
'''Options for this resource, such as condition, update policy etc.'''
return typing.cast(IRosResourceOptions, jsii.get(self, "rosOptions"))
@builtins.property
@jsii.member(jsii_name="rosProperties")
def _ros_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "rosProperties"))
@builtins.property
@jsii.member(jsii_name="rosResourceType")
def ros_resource_type(self) -> builtins.str:
'''ROS resource type.'''
return typing.cast(builtins.str, jsii.get(self, "rosResourceType"))
@builtins.property
@jsii.member(jsii_name="updatedProperites")
def _updated_properites(self) -> typing.Mapping[builtins.str, typing.Any]:
'''Return properties modified after initiation.
Resources that expose mutable properties should override this function to
collect and return the properties object for this resource.
'''
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "updatedProperites"))
@jsii.implements(ITaggable)
class Stack(
Construct,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-core.Stack",
):
'''A root construct which represents a single ROS stack.'''
def __init__(
self,
scope: typing.Optional[Construct] = None,
id: typing.Optional[builtins.str] = None,
*,
description: typing.Optional[builtins.str] = None,
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
metadata: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
stack_name: typing.Optional[builtins.str] = None,
synthesizer: typing.Optional[IStackSynthesizer] = None,
tags: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
version: typing.Optional[builtins.str] = None,
) -> None:
'''Creates a new stack.
:param scope: Parent of this stack, usually a Program instance.
:param id: The construct ID of this stack. If ``stackName`` is not explicitly defined, this id (and any parent IDs) will be used to determine the physical ID of the stack.
:param description: A description of the stack. Default: - No description.
:param enable_resource_property_constraint: -
:param metadata: -
:param stack_name: Name to deploy the stack with. Default: - Derived from construct path.
:param synthesizer: Synthesis method to use while deploying this stack. Default: - ``DefaultStackSynthesizer``
:param tags: Stack tags that will be applied to all the taggable resources and the stack itself. Default: {}
:param version: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__1dc168842bc69954d0e07ab74e7ad20f5227249df44949f4a202402c806ebe86)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
props = StackProps(
description=description,
enable_resource_property_constraint=enable_resource_property_constraint,
metadata=metadata,
stack_name=stack_name,
synthesizer=synthesizer,
tags=tags,
version=version,
)
jsii.create(self.__class__, self, [scope, id, props])
@jsii.member(jsii_name="isStack")
@builtins.classmethod
def is_stack(cls, x: typing.Any) -> builtins.bool:
'''Return whether the given object is a Stack.
We do attribute detection since we can't reliably use 'instanceof'.
:param x: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__0bc7e129e09b4feddab62e4966768ba39cbaed884489a9137f10d40ac2bf7db0)
check_type(argname="argument x", value=x, expected_type=type_hints["x"])
return typing.cast(builtins.bool, jsii.sinvoke(cls, "isStack", [x]))
@jsii.member(jsii_name="of")
@builtins.classmethod
def of(cls, construct: IConstruct) -> "Stack":
'''Looks up the first stack scope in which ``construct`` is defined.
Fails if there is no stack up the tree.
:param construct: The construct to start the search from.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__b94641c207370c83802c8c71ec1c1b6f5bfe8e7d3d68b538d8e81241a823e1e6)
check_type(argname="argument construct", value=construct, expected_type=type_hints["construct"])
return typing.cast("Stack", jsii.sinvoke(cls, "of", [construct]))
@jsii.member(jsii_name="addDependency")
def add_dependency(
self,
target: "Stack",
reason: typing.Optional[builtins.str] = None,
) -> None:
'''Add a dependency between this stack and another stack.
This can be used to define dependencies between any two stacks within an
app, and also supports nested stacks.
:param target: -
:param reason: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__b4506fefa5dd69433347eb17079b665a7e5aeed444aaa064f41f02e964b224b2)
check_type(argname="argument target", value=target, expected_type=type_hints["target"])
check_type(argname="argument reason", value=reason, expected_type=type_hints["reason"])
return typing.cast(None, jsii.invoke(self, "addDependency", [target, reason]))
@jsii.member(jsii_name="allocateLogicalId")
def _allocate_logical_id(self, ros_element: RosElement) -> builtins.str:
'''Returns the naming scheme used to allocate logical IDs.
By default, uses
the ``HashedAddressingScheme`` but this method can be overridden to customize
this behavior.
In order to make sure logical IDs are unique and stable, we hash the resource
construct tree path (i.e. toplevel/secondlevel/.../myresource) and add it as
a suffix to the path components joined without a separator (ROS
IDs only allow alphanumeric characters).
The result will be:
<path.join('')><md5(path.join('/')>
"human" "hash"
If the "human" part of the ID exceeds 240 characters, we simply trim it so
the total ID doesn't exceed 255 character limit.
We only take 8 characters from the md5 hash (0.000005 chance of collision).
Special cases:
- If the path only contains a single component (i.e. it's a top-level
resource), we won't add the hash to it. The hash is not needed for
disamiguation and also, it allows for a more straightforward migration an
existing ROS template to a CDK stack without logical ID changes
(or renames).
- For aesthetic reasons, if the last components of the path are the same
(i.e. ``L1/L2/Pipeline/Pipeline``), they will be de-duplicated to make the
resulting human portion of the ID more pleasing: ``L1L2Pipeline<HASH>``
instead of ``L1L2PipelinePipeline<HASH>``
- If a component is named "Default" it will be omitted from the path. This
allows refactoring higher level abstractions around constructs without affecting
the IDs of already deployed resources.
- If a component is named "Resource" it will be omitted from the user-visible
path, but included in the hash. This reduces visual noise in the human readable
part of the identifier.
:param ros_element: The element for which the logical ID is allocated.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__0af605d4b0354a6812eb679f03dc7800afa36dba79ee386d95519a3db2ca6977)
check_type(argname="argument ros_element", value=ros_element, expected_type=type_hints["ros_element"])
return typing.cast(builtins.str, jsii.invoke(self, "allocateLogicalId", [ros_element]))
@jsii.member(jsii_name="getLogicalId")
def get_logical_id(self, element: RosElement) -> builtins.str:
'''Allocates a stack-unique logical identity for a specific resource.
This method is called when a ``RosElement`` is created and used to render the
initial logical identity of resources. Logical ID renames are applied at
this stage.
This method uses the protected method ``allocateLogicalId`` to render the
logical ID for an element. To modify the naming scheme, extend the ``Stack``
class and override this method.
:param element: The ROS element for which a logical identity is needed.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__7bfdee0d9f37059144839af82465d446909bf1e3490f99384d011f1a8324a431)
check_type(argname="argument element", value=element, expected_type=type_hints["element"])
return typing.cast(builtins.str, jsii.invoke(self, "getLogicalId", [element]))
@jsii.member(jsii_name="prepareCrossReference")
def _prepare_cross_reference(
self,
_source_stack: "Stack",
reference: Reference,
) -> IResolvable:
'''(deprecated) Deprecated.
:param _source_stack: -
:param reference: -
:return: reference itself without any change
:deprecated: cross reference handling has been moved to ``App.prepare()``.
:stability: deprecated
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__af7bd001d5b018cf8e304d958695046f54f29932881a260dc73b7e680abb1f87)
check_type(argname="argument _source_stack", value=_source_stack, expected_type=type_hints["_source_stack"])
check_type(argname="argument reference", value=reference, expected_type=type_hints["reference"])
return typing.cast(IResolvable, jsii.invoke(self, "prepareCrossReference", [_source_stack, reference]))
@jsii.member(jsii_name="renameLogicalId")
def rename_logical_id(self, old_id: builtins.str, new_id: builtins.str) -> None:
'''Rename a generated logical identities.
To modify the naming scheme strategy, extend the ``Stack`` class and
override the ``allocateLogicalId`` method.
:param old_id: -
:param new_id: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__bbf09e8a560a6d2a51b85d6d34d59468e862c5d2438cfb9d51a67d4e52fc7683)
check_type(argname="argument old_id", value=old_id, expected_type=type_hints["old_id"])
check_type(argname="argument new_id", value=new_id, expected_type=type_hints["new_id"])
return typing.cast(None, jsii.invoke(self, "renameLogicalId", [old_id, new_id]))
@jsii.member(jsii_name="resolve")
def resolve(self, obj: typing.Any) -> typing.Any:
'''Resolve a tokenized value in the context of the current stack.
:param obj: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__2df79660b12efbfa718154119699655340f2e0f1473b164ba21d864a85e698e4)
check_type(argname="argument obj", value=obj, expected_type=type_hints["obj"])
return typing.cast(typing.Any, jsii.invoke(self, "resolve", [obj]))
@jsii.member(jsii_name="synthesize")
def _synthesize(self, session: ISynthesisSession) -> None:
'''Allows this construct to emit artifacts into the cloud assembly during synthesis.
This method is usually implemented by framework-level constructs such as ``Stack`` and ``Asset``
as they participate in synthesizing the cloud assembly.
:param session: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__af0331c6d2a7f5ce9ffb0945062b3bd65a450e61fb33a74d8d8893038819f96e)
check_type(argname="argument session", value=session, expected_type=type_hints["session"])
return typing.cast(None, jsii.invoke(self, "synthesize", [session]))
@jsii.member(jsii_name="toJsonString")
def to_json_string(
self,
obj: typing.Any,
space: typing.Optional[jsii.Number] = None,
) -> builtins.str:
'''Convert an object, potentially containing tokens, to a JSON string.
:param obj: -
:param space: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__076a3f3e8ef5caf16f7c89a9161d7d167666b81169349270d1676da89018fb23)
check_type(argname="argument obj", value=obj, expected_type=type_hints["obj"])
check_type(argname="argument space", value=space, expected_type=type_hints["space"])
return typing.cast(builtins.str, jsii.invoke(self, "toJsonString", [obj, space]))
@builtins.property
@jsii.member(jsii_name="artifactId")
def artifact_id(self) -> builtins.str:
'''The ID of the cloud assembly artifact for this stack.'''
return typing.cast(builtins.str, jsii.get(self, "artifactId"))
@builtins.property
@jsii.member(jsii_name="dependencies")
def dependencies(self) -> typing.List["Stack"]:
'''Return the stacks this stack depends on.'''
return typing.cast(typing.List["Stack"], jsii.get(self, "dependencies"))
@builtins.property
@jsii.member(jsii_name="enableResourcePropertyConstraint")
def enable_resource_property_constraint(self) -> builtins.bool:
return typing.cast(builtins.bool, jsii.get(self, "enableResourcePropertyConstraint"))
@builtins.property
@jsii.member(jsii_name="nested")
def nested(self) -> builtins.bool:
'''Indicates if this is a nested stack, in which case ``parentStack`` will include a reference to it's parent.'''
return typing.cast(builtins.bool, jsii.get(self, "nested"))
@builtins.property
@jsii.member(jsii_name="stackId")
def stack_id(self) -> builtins.str:
'''The ID of the stack.'''
return typing.cast(builtins.str, jsii.get(self, "stackId"))
@builtins.property
@jsii.member(jsii_name="stackName")
def stack_name(self) -> builtins.str:
'''The concrete ROS physical stack name.
This is either the name defined explicitly in the ``stackName`` prop or
allocated based on the stack's location in the construct tree. Stacks that
are directly defined under the app use their construct ``id`` as their stack
name. Stacks that are defined deeper within the tree will use a hashed naming
scheme based on the construct path to ensure uniqueness.
'''
return typing.cast(builtins.str, jsii.get(self, "stackName"))
@builtins.property
@jsii.member(jsii_name="synthesizer")
def synthesizer(self) -> IStackSynthesizer:
'''(experimental) Synthesis method for this stack.
:stability: experimental
'''
return typing.cast(IStackSynthesizer, jsii.get(self, "synthesizer"))
@builtins.property
@jsii.member(jsii_name="tags")
def tags(self) -> TagManager:
'''Tags to be applied to the stack.'''
return typing.cast(TagManager, jsii.get(self, "tags"))
@builtins.property
@jsii.member(jsii_name="templateFile")
def template_file(self) -> builtins.str:
'''The name of the ROS template file emitted to the output directory during synthesis.
Example::
MyStack.template.json
'''
return typing.cast(builtins.str, jsii.get(self, "templateFile"))
@builtins.property
@jsii.member(jsii_name="templateOptions")
def template_options(self) -> ITemplateOptions:
'''Options for ROS template (like version, description).'''
return typing.cast(ITemplateOptions, jsii.get(self, "templateOptions"))
@builtins.property
@jsii.member(jsii_name="nestedStackParent")
def nested_stack_parent(self) -> typing.Optional["Stack"]:
'''If this is a nested stack, returns it's parent stack.'''
return typing.cast(typing.Optional["Stack"], jsii.get(self, "nestedStackParent"))
@builtins.property
@jsii.member(jsii_name="nestedStackResource")
def nested_stack_resource(self) -> typing.Optional[RosResource]:
'''(experimental) If this is a nested stack, this represents its ``ALIYUN::ROS::Stack`` resource.
``undefined`` for top-level (non-nested) stacks.
:stability: experimental
'''
return typing.cast(typing.Optional[RosResource], jsii.get(self, "nestedStackResource"))
@builtins.property
@jsii.member(jsii_name="parentStack")
def parent_stack(self) -> typing.Optional["Stack"]:
'''(deprecated) Returns the parent of a nested stack.
:deprecated: use ``nestedStackParent``
:stability: deprecated
'''
return typing.cast(typing.Optional["Stack"], jsii.get(self, "parentStack"))
class Stage(
Construct,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-core.Stage",
):
'''An abstract application modeling unit consisting of Stacks that should be deployed together.
Derive a subclass of 'Stage' and use it to model a single instance of your
application.
You can then instantiate your subclass multiple times to model multiple
copies of your application which should be be deployed to different
environments.
'''
def __init__(
self,
scope: Construct,
id: builtins.str,
*,
outdir: typing.Optional[builtins.str] = None,
) -> None:
'''
:param scope: -
:param id: -
:param outdir: The output directory into which to emit synthesized artifacts. Can only be specified if this stage is the root stage the app. If this is specified and this stage is nested within another stage, an error will be thrown. Default - for nested stages, outdir will be determined as a relative directory to the outdir of the app. For apps, if outdir is not specified, a temporary directory will be created.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__9d3cc5431aa000ead0553b38893e095b0fff1ca6e8cfac885d80486e937a4dbb)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
props = StageProps(outdir=outdir)
jsii.create(self.__class__, self, [scope, id, props])
@jsii.member(jsii_name="isStage")
@builtins.classmethod
def is_stage(cls, x: typing.Any) -> builtins.bool:
'''(experimental) Test whether the given construct is a stage.
:param x: -
:stability: experimental
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__57cc149bf33dfb1dd59aecbfb358c0d1cccf4e870c0cbf33c3e18336b7e6de8f)
check_type(argname="argument x", value=x, expected_type=type_hints["x"])
return typing.cast(builtins.bool, jsii.sinvoke(cls, "isStage", [x]))
@jsii.member(jsii_name="of")
@builtins.classmethod
def of(cls, construct: IConstruct) -> typing.Optional["Stage"]:
'''(experimental) Return the stage this construct is contained with, if available.
If called
on a nested stage, returns its parent.
:param construct: -
:stability: experimental
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__be7e7d60a27fba054f5fa1e6d28e319ee2e67b01f4cedf5452c2627e2aa17bc8)
check_type(argname="argument construct", value=construct, expected_type=type_hints["construct"])
return typing.cast(typing.Optional["Stage"], jsii.sinvoke(cls, "of", [construct]))
@jsii.member(jsii_name="synth")
def synth(
self,
*,
skip_validation: typing.Optional[builtins.bool] = None,
) -> _ros_cdk_cxapi_45dace6b.CloudAssembly:
'''Synthesize this stage into a cloud assembly.
Once an assembly has been synthesized, it cannot be modified. Subsequent
calls will return the same assembly.
:param skip_validation: Should we skip construct validation. Default: - false
'''
options = StageSynthesisOptions(skip_validation=skip_validation)
return typing.cast(_ros_cdk_cxapi_45dace6b.CloudAssembly, jsii.invoke(self, "synth", [options]))
@builtins.property
@jsii.member(jsii_name="artifactId")
def artifact_id(self) -> builtins.str:
'''(experimental) Artifact ID of the assembly if it is a nested stage. The root stage app will return an empty string.
Derived from the construct path.
:stability: experimental
'''
return typing.cast(builtins.str, jsii.get(self, "artifactId"))
@builtins.property
@jsii.member(jsii_name="stageName")
def stage_name(self) -> builtins.str:
'''(experimental) The name of the stage.
Based on names of the parent stages separated by
hypens.
:stability: experimental
'''
return typing.cast(builtins.str, jsii.get(self, "stageName"))
@builtins.property
@jsii.member(jsii_name="parentStage")
def parent_stage(self) -> typing.Optional["Stage"]:
'''(experimental) The parent stage or 'undefined' if this is the app.
-
:stability: experimental
'''
return typing.cast(typing.Optional["Stage"], jsii.get(self, "parentStage"))
class App(Stage, metaclass=jsii.JSIIMeta, jsii_type="@alicloud/ros-cdk-core.App"):
'''A construct which represents an entire CDK app. This construct is normally the root of the construct tree.
You would normally define an 'App' instance in your program's entrypoint,
then define constructs where the app is used as the parent scope.
After all the child constructs are defined within the app, you should call
'app.synth()' which will emit a "ros template" from this app into the
directory specified by 'outdir'.
'''
def __init__(
self,
*,
auto_synth: typing.Optional[builtins.bool] = None,
context: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
outdir: typing.Optional[builtins.str] = None,
runtime_info: typing.Optional[builtins.bool] = None,
stack_traces: typing.Optional[builtins.bool] = None,
tree_metadata: typing.Optional[builtins.bool] = None,
) -> None:
'''Initializes a CDK application.
:param auto_synth: Automatically call 'synth()' before the program exits. If you set this, you don't have to call 'synth()' explicitly. Note that this feature is only available for certain programming languages, and calling 'synth()' is still recommended. Default true if running via CDK CLI ('CDK_OUTDIR' is set), 'false' otherwise
:param context: Additional context values for the application. Context set by the CLI or the 'context' key in 'cdk.json' has precedence. Context can be read from any construct using 'node.getContext(key)'. Default: - no additional context
:param outdir: The output directory into which to emit synthesized artifacts. Default - If this value is *not* set, considers the environment variable 'CDK_OUTDIR'. If 'CDK_OUTDIR' is not defined, uses a temp directory.
:param runtime_info: Include runtime versioning information. Default: true runtime info is included unless related comtext is set.
:param stack_traces: Include construct creation stack trace. Default: true stack traces are included unless related context is set.
:param tree_metadata: Include construct tree metadata as part of the Cloud Assembly. Default: true
'''
props = AppProps(
auto_synth=auto_synth,
context=context,
outdir=outdir,
runtime_info=runtime_info,
stack_traces=stack_traces,
tree_metadata=tree_metadata,
)
jsii.create(self.__class__, self, [props])
@jsii.member(jsii_name="isApp")
@builtins.classmethod
def is_app(cls, obj: typing.Any) -> builtins.bool:
'''Checks if an object is an instance of the 'App' class.
Returns 'true' if 'obj' is an 'App'.
Param obj The object to evaluate
:param obj: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__74d0fa652e39f975ef68ff4093ff1dfd8c4919e78344e1e557ea1960f095bcd0)
check_type(argname="argument obj", value=obj, expected_type=type_hints["obj"])
return typing.cast(builtins.bool, jsii.sinvoke(cls, "isApp", [obj]))
class NestedStack(
Stack,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-core.NestedStack",
):
def __init__(
self,
scope: Construct,
id: builtins.str,
*,
parameters: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
template_body: typing.Optional[builtins.str] = None,
template_url: typing.Optional[builtins.str] = None,
timeout: typing.Optional[jsii.Number] = None,
) -> None:
'''
:param scope: -
:param id: -
:param parameters: -
:param template_body: -
:param template_url: -
:param timeout: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__2e646842a4e32a91459603425998d3a13b4b135ea05d39360f3d382a3486dc84)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
props = NestedStackProps(
parameters=parameters,
template_body=template_body,
template_url=template_url,
timeout=timeout,
)
jsii.create(self.__class__, self, [scope, id, props])
@jsii.member(jsii_name="isNestedStack")
@builtins.classmethod
def is_nested_stack(cls, x: typing.Any) -> builtins.bool:
'''
:param x: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__25b017370399ffba3a033fae3ebc112f4fdd2e6f79c636d64384b8f4a381bb0d)
check_type(argname="argument x", value=x, expected_type=type_hints["x"])
return typing.cast(builtins.bool, jsii.sinvoke(cls, "isNestedStack", [x]))
@jsii.member(jsii_name="getAtt")
def get_att(self, attribute_name: builtins.str) -> builtins.str:
'''
:param attribute_name: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__447d9f5b6c2854b6d918d5ae1853ac034d78e15222dae3f55f6c81b4e9386c88)
check_type(argname="argument attribute_name", value=attribute_name, expected_type=type_hints["attribute_name"])
return typing.cast(builtins.str, jsii.invoke(self, "getAtt", [attribute_name]))
@jsii.member(jsii_name="setParameter")
def set_parameter(self, name: builtins.str, value: typing.Any) -> None:
'''
:param name: -
:param value: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__e8acfe38a22d7972aef78bf4967459c27003e8a578a5baffcc308affdbc9c9bc)
check_type(argname="argument name", value=name, expected_type=type_hints["name"])
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
return typing.cast(None, jsii.invoke(self, "setParameter", [name, value]))
@builtins.property
@jsii.member(jsii_name="stackId")
def stack_id(self) -> builtins.str:
'''The ID of the stack.'''
return typing.cast(builtins.str, jsii.get(self, "stackId"))
@builtins.property
@jsii.member(jsii_name="stackName")
def stack_name(self) -> builtins.str:
'''The concrete ROS physical stack name.
This is either the name defined explicitly in the ``stackName`` prop or
allocated based on the stack's location in the construct tree. Stacks that
are directly defined under the app use their construct ``id`` as their stack
name. Stacks that are defined deeper within the tree will use a hashed naming
scheme based on the construct path to ensure uniqueness.
'''
return typing.cast(builtins.str, jsii.get(self, "stackName"))
@jsii.implements(IRosConditionExpression, IResolvable)
class RosCondition(
RosElement,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-core.RosCondition",
):
'''Represents a RosTemplate condition, for resources which must be conditionally created and the determination must be made at deploy time.'''
def __init__(
self,
scope: Construct,
id: builtins.str,
*,
expression: typing.Optional[IRosConditionExpression] = None,
) -> None:
'''Build a new condition.
The condition must be constructed with a condition token,
that the condition is based on.
:param scope: -
:param id: -
:param expression: The expression that the condition will evaluate. Default: - None.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__a4adeb2f3dbe000bfb1c7ec7bed924206f4df34a2bc64ad2e4e1e1504e7a7c13)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
props = RosConditionProps(expression=expression)
jsii.create(self.__class__, self, [scope, id, props])
@jsii.member(jsii_name="resolve")
def resolve(self, _context: IResolveContext) -> typing.Any:
'''Synthesizes the condition.
:param _context: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__e2ef9d8bbd99a6ab400cec2a3268734727521372a8f3dd11a561cbbfceaa382a)
check_type(argname="argument _context", value=_context, expected_type=type_hints["_context"])
return typing.cast(typing.Any, jsii.invoke(self, "resolve", [_context]))
@builtins.property
@jsii.member(jsii_name="expression")
def expression(self) -> typing.Optional[IRosConditionExpression]:
'''The condition statement.'''
return typing.cast(typing.Optional[IRosConditionExpression], jsii.get(self, "expression"))
@expression.setter
def expression(self, value: typing.Optional[IRosConditionExpression]) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__320a90f621af7519a0584bb43b35d213f2c135a2982b42bad6edb3d7ff01f842)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "expression", value)
class RosMapping(
RosRefElement,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-core.RosMapping",
):
'''Represents a mapping.'''
def __init__(
self,
scope: Construct,
id: builtins.str,
*,
mapping: typing.Optional[typing.Mapping[builtins.str, typing.Mapping[builtins.str, typing.Any]]] = None,
) -> None:
'''
:param scope: -
:param id: -
:param mapping: Mapping of key to a set of corresponding set of named values. The key identifies a map of name-value pairs and must be unique within the mapping. For example, if you want to set values based on a region, you can create a mapping that uses the region name as a key and contains the values you want to specify for each specific region. Default: - No mapping.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__339c8731b33058714cd4c46bb12532db7cb165d85986335505599f486cb0e2e1)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
props = RosMappingProps(mapping=mapping)
jsii.create(self.__class__, self, [scope, id, props])
@jsii.member(jsii_name="findInMap")
def find_in_map(self, key1: builtins.str, key2: builtins.str) -> IResolvable:
'''
:param key1: -
:param key2: -
:return: A reference to a value in the map based on the two keys.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__2700068fd9ad29f35ddcdc8992b2ffd67e016c0cc7343a6e921126ab1927e842)
check_type(argname="argument key1", value=key1, expected_type=type_hints["key1"])
check_type(argname="argument key2", value=key2, expected_type=type_hints["key2"])
return typing.cast(IResolvable, jsii.invoke(self, "findInMap", [key1, key2]))
@jsii.member(jsii_name="setValue")
def set_value(
self,
key1: builtins.str,
key2: builtins.str,
value: typing.Any,
) -> None:
'''Sets a value in the map based on the two keys.
:param key1: -
:param key2: -
:param value: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__bf0fe656246b94ac6fc706854b81700474ad2a9a16e4cb7a23e1b55588f7ec37)
check_type(argname="argument key1", value=key1, expected_type=type_hints["key1"])
check_type(argname="argument key2", value=key2, expected_type=type_hints["key2"])
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
return typing.cast(None, jsii.invoke(self, "setValue", [key1, key2, value]))
__all__ = [
"App",
"AppProps",
"ConcreteDependable",
"Construct",
"ConstructNode",
"ConstructOrder",
"DefaultStackSynthesizer",
"DefaultStackSynthesizerProps",
"DefaultTokenResolver",
"DependableTrait",
"Dependency",
"EncodingOptions",
"Fn",
"FnAdd",
"FnAnd",
"FnAvg",
"FnBase64Decode",
"FnBase64Encode",
"FnCalculate",
"FnEquals",
"FnFindInMap",
"FnGetAZs",
"FnGetAtt",
"FnGetJsonValue",
"FnGetStackOutput",
"FnIf",
"FnJoin",
"FnJq",
"FnListMerge",
"FnMax",
"FnMergeMapToList",
"FnMin",
"FnNot",
"FnOr",
"FnRef",
"FnReplace",
"FnSelect",
"FnSelectMapList",
"FnSplit",
"FnStr",
"FnSub",
"IAnyProducer",
"IConstruct",
"IDependable",
"IFragmentConcatenator",
"IInspectable",
"IListProducer",
"INumberProducer",
"IPostProcessor",
"IResolvable",
"IResolveContext",
"IResource",
"IRosConditionExpression",
"IRosResourceOptions",
"IStackSynthesizer",
"IStringProducer",
"ISynthesisSession",
"ITaggable",
"ITemplateOptions",
"ITokenMapper",
"ITokenResolver",
"Intrinsic",
"Lazy",
"LazyAnyValueOptions",
"LazyListValueOptions",
"LazyStringValueOptions",
"NestedStack",
"NestedStackProps",
"Reference",
"RemovalPolicy",
"RemovalPolicyOptions",
"ResolveOptions",
"Resource",
"ResourceProps",
"RosCondition",
"RosConditionProps",
"RosDeletionPolicy",
"RosElement",
"RosInfo",
"RosMapping",
"RosMappingProps",
"RosOutput",
"RosOutputProps",
"RosParameter",
"RosParameterProps",
"RosParameterType",
"RosPseudo",
"RosRefElement",
"RosResource",
"RosResourceProps",
"RosTag",
"Stack",
"StackProps",
"Stage",
"StageProps",
"StageSynthesisOptions",
"StringConcat",
"SynthesisOptions",
"TagManager",
"TagManagerOptions",
"TagType",
"Token",
"Tokenization",
"TokenizedStringFragments",
"TreeInspector",
"ValidationError",
"ValidationResult",
"ValidationResults",
]
publication.publish()
def _typecheckingstub__748c8a4f3f80cbb46f7db3d45e1fc62f897a813df65337c1692a26757af6df49(
*,
auto_synth: typing.Optional[builtins.bool] = None,
context: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
outdir: typing.Optional[builtins.str] = None,
runtime_info: typing.Optional[builtins.bool] = None,
stack_traces: typing.Optional[builtins.bool] = None,
tree_metadata: typing.Optional[builtins.bool] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__6a47bad65275b85b8612877823d54537652d86b16d9cc47c3f0fe2e682cad87e(
host: Construct,
scope: IConstruct,
id: builtins.str,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__6645ca4ad5ccd4cd68a4050a9e5c2511fdb248cb9310394c721b1c69950e5975(
node: ConstructNode,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__df4441eafb1cb1046b32ca5295d005d3131df919989d3b694d1ce2e3881d2b51(
node: ConstructNode,
*,
outdir: typing.Optional[builtins.str] = None,
skip_validation: typing.Optional[builtins.bool] = None,
runtime_info: typing.Optional[typing.Union[_ros_cdk_cxapi_45dace6b.RuntimeInfo, typing.Dict[builtins.str, typing.Any]]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__15d58cf30911824dccc4b726e85b99d3c5af21fbe85acb679afb5632b9b4410b(
node: ConstructNode,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__4621c8e910f9ed69913adeffe0161d40cfde5ebadeba3e7bd20a4b0cfbfee3b9(
*dependencies: IDependable,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__5828fca22ddd84c8c5f392d283078c4556c6a3104e3afda44917f05f086da22f(
message: builtins.str,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__7f520bb9a468976f66105a240b5a66c7ade94873ab55373e1ac571b500c21d6a(
message: builtins.str,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__959c55db0db52728d3f598e4c83dd98fc47eb2297c12d34642150aad945923fd(
type: builtins.str,
data: typing.Any,
from_function: typing.Any = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__570f16aaf6d6ed0a36aaf59690d63691db9c638fa7db4426ffff61a3eec2507a(
message: builtins.str,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__f373a014879a19ab5383814e7c60e2fdc9b85ff481266088ce12f7a126854d60(
order: typing.Optional[ConstructOrder] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__d4e9a97593ce9f2c58b87536455eb37e870708a060b383b357d9f6fcb2469e26(
id: builtins.str,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__5ffc85bdb046e28e24026eca3ca7feb5e1cbec09d4e2d58eb5f259741e0f5805(
key: builtins.str,
value: typing.Any,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__5cbe01369ed9844edb9ceff08f9f1d6ffdf493083e9de9b90f37b2eb7024c63c(
id: builtins.str,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__0d5e8d9fc5378c36b1914ff9ef3d1743c82cf3a6020c5d4b16ef390692134d84(
key: builtins.str,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__4528d4bf540c03795edbfe799321d679a7800f5bda281eb50419a46623ff4eb1(
child_name: builtins.str,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__1122548f7c053a88310186a509d813226fa408734e0b465c5934441a333f1cf4(
value: typing.Optional[IConstruct],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__ba524959d80a1a88eee86a3a039a209594e07b39da331bb1cafb9fc849c5a97d(
*,
qualifier: typing.Optional[builtins.str] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__be877a98a70eaf2e415053ecc3597f54d82bf1b02ab801068be53d34c3645e0b(
instance: IDependable,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__27f51d221a1d3f0592bfeaf5e954b8d1ed157c843e51a32099396c3c78cc123d(
instance: IDependable,
trait: DependableTrait,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__be971e1a5b7d053e1a29fe327cce65a823280ff9c0231b2ae0a5de6c0c9cafaa(
*,
source: IConstruct,
target: IConstruct,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__592ddd870eea1153b99934c7382cc772fd9c62743fc04f026567e47d474c14a6(
*,
display_hint: typing.Optional[builtins.str] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__c4463aa739260d8ce63c1fc5c0d0104b648438afea3cc84fd0508ce2ff89e41d(
values: typing.Union[jsii.Number, typing.Sequence[typing.Any], typing.Mapping[builtins.str, typing.Any]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__c4603e8d5b00df56f000c5dadb14d841aa452846777e902e565f1c0b2decdd8c(
ndigits: jsii.Number,
values: typing.Sequence[jsii.Number],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__5654a30fb1a45859f496027acf7a03d482124e055620291bac9e02da204e9cb6(
data: builtins.str,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__ce3856953e5d2815bfc23c0d182df0cf035b30feda4d849f172136dd500a32a0(
data: builtins.str,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__247d1bde91a0d2f5bdbe0d77b1d77116951cc7a286d8876b7ee3c841e3d01986(
values: builtins.str,
ndigits: jsii.Number,
para: typing.Sequence[jsii.Number],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__1d3b053d7bd2380d1777011cb385769042414d91dcd1ac5c5d4126a11fb6ced7(
*conditions: typing.Union[builtins.str, IRosConditionExpression],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__c32d8c967b76fe1b22006921d766d24460ced611ddaeca23b0cef97797df9dee(
lhs: typing.Any,
rhs: typing.Any,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__98d6a20e1d755c3448e9346d51da27f01a171bd61c63ea885517e0002d03b1c1(
condition_id: typing.Union[builtins.str, IRosConditionExpression],
value_if_true: typing.Any,
value_if_false: typing.Any,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__d0f1efc96374482cd77e5e775be7aaf6b0826705fbb51a9778b524db9beb7f5b(
condition: typing.Union[builtins.str, IRosConditionExpression],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__87426609e3c35a1db0e27d2a3800878e1f22676645588ff18f69707d682c3b90(
*conditions: typing.Union[builtins.str, IRosConditionExpression],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__483847ae80b6d31323ba40a393751618bf0a768d1d766b45ec2a6e9a1c81cbfa(
map_name: builtins.str,
top_level_key: builtins.str,
second_level_key: builtins.str,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__8c616186d3b472030fc6ff0709da54ba8f4263acff902f4e13dc63abddb12693(
logical_name_of_resource: builtins.str,
attribute_name: builtins.str,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__d5df40a11802df885fed03fa5ee963ab074e2dd8e1f13cd43d87df7b9facfb9c(
region: builtins.str,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__9bec0ea9134fb15498bbd9212d243dbe6cb81310293221509061e9dbe3df6313(
key: builtins.str,
json_data: typing.Any,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__ffa0ab99cd7d646eb78d61ad0b07aa230afdb88914c828db09aaab14cf714839(
stack_id: builtins.str,
output_key: builtins.str,
stack_region: typing.Optional[builtins.str] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__88f3fc6721043fc599f60ea05b463881dcf4075d5127c09179c02a1690454ef0(
delimiter: builtins.str,
list_of_values: typing.Sequence[builtins.str],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__0bf918016f24f24d6d8d161b6d860b5a0b5506fe4d57b968ce44fea4797441b7(
method: builtins.str,
script: builtins.str,
input_string: typing.Union[builtins.str, typing.Mapping[builtins.str, typing.Any]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__418ce724afaaaf93016caa6baae8868b58470039ae7a0209173008f801bd0cce(
value_list: typing.Sequence[typing.Sequence[typing.Any]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__2c2a2d4a102c055ada8b542f1e629eebbdc2c3b23b6ec2f9d3156425c6e0acfe(
values: typing.Sequence[jsii.Number],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__82b64e548b2fe149619ab5ddf83a2692c9fd8f25ee48e660845b06e12306d617(
map_list: typing.Sequence[typing.Mapping[builtins.str, typing.Sequence[typing.Any]]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__6fc4584dee600015afe6c6649a88dcc4e525cadcf95374eb87929129b2f3ef1c(
values: typing.Sequence[jsii.Number],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__5e9634d4ce38e42ffeb12b5d5faf8aa2a239fc7e2f6389ee89c22a433f482341(
logical_name: builtins.str,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__1f093db3c371af0aa55cd98c01151e474879cb90d07575abea0e5cf971413df4(
replace_data: typing.Mapping[builtins.str, typing.Any],
content: builtins.str,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__9b26926a5816f273496a6351b2085fc2ed9f3fafe5e2353790c65e10563fcf72(
index: typing.Union[builtins.str, jsii.Number],
array: typing.Any,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__14777cebe9bed53e78225c85b1b6b1636e8831c632317c0d9b6cec030eb1e31c(
key: builtins.str,
map_list: typing.Sequence[typing.Mapping[builtins.str, typing.Any]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__5e40386a7e03a946cc861ea88a3c7bc073d133b957f617719c7c9dc19f966c12(
delimiter: builtins.str,
source: builtins.str,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__00895398044099548c609b2ecdc6200196f3347f2b3473fae8a7dd295d6a55dd(
value: typing.Any,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__936318f7d306dbbfa94357c01fc7ea166b43b16cc0756f030d327ffe3a409e5c(
body: builtins.str,
variables: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__c17c877cbc31bd56fc0d0ada8af1359356a47e367984086f30dbdd1e8909805d(
context: IResolveContext,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__0c52de30a7fb0655b01843c16a129e0a7eebacf9016fd797efec15cd3678577a(
left: typing.Any,
right: typing.Any,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__1465a36c9a263cd138c4c560a149095fbdfecd574cfbe3422439e98c3fbdf2ed(
inspector: TreeInspector,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__767ea28bc08d47b0e1f0d4765fe0bc3f22c8289fee8b2e194da7d57277824f5a(
context: IResolveContext,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__0831a2456f0182fa20ecb7b158e0a1186592cd9b986aa74ba61a4a4d1bbc0611(
context: IResolveContext,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__15f5bff2f879cc4cc32197c0039cad4b57418edeed34a996ca4874cf726ea5d4(
input: typing.Any,
context: IResolveContext,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__0955aa64060a165ec5f774d258aa1859e4c9a08ded723ede00b5c1bdc9df52b3(
context: IResolveContext,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__015447ccb4a9906395b20fd902cabcd4597a590171c08295f278be5342f4e7e3(
post_processor: IPostProcessor,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__20944a7cc00f2136f1d3365c36cfc599ebe106e8d4cdddf174ebbd715657933c(
x: typing.Any,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__6b9af138a0065ab24db0137ba4df5cee7e42b723f07b919cba01deb86f6721d1(
value: typing.Optional[RosCondition],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__19ccbf023e632728666a7277d8c6574e3cf45a8648865fbe9b2af9d1ae076fb7(
value: typing.Optional[typing.Union[jsii.Number, IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__f1cddf5277a3c64108ce0c15fa5faa290e10d8d379815c3af84baaccfc3808ac(
value: typing.Optional[RosDeletionPolicy],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__35f4c58d13e139e5c6223bdbf53164654b2095b5fd91c1bf7e993bd3dc84140f(
value: typing.Optional[builtins.str],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__71a66b9935f95fe5d4e4f70341aa002ed47fa3648ffbbe393e5120f0f1087c43(
value: typing.Optional[typing.Mapping[builtins.str, typing.Any]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__4a06319e966e22b6794f594e79b9622c69452df8b350eb1db66803917ce61c9c(
stack: Stack,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__51447d13933e5456a4c6300399eb55ac5df14f92fa88bc9f6722990b9f25fe80(
session: ISynthesisSession,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__4459cd8f8716a48963ca392c9ef233a3a6f41bb3af29ad7cc2c41f450aa8713d(
context: IResolveContext,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__1c1cff4576a8245902913886959c7001a767c437b52225234ea1b9baf6a9e05d(
value: _ros_cdk_cxapi_45dace6b.CloudAssemblyBuilder,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__d2762b383cd1433befe9d900f9538105bc7ff724b6f3bd94e9babdde6b6b651f(
value: builtins.str,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__014ac8e6afd23cc5d8dbaa362ea76b16a5188f58d5d520c3fb9b08768d065850(
value: typing.Optional[builtins.str],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__bcca51c7205afe0a4756cb9a5de79e6efe34349870e4aaee85d9de6f3b426dbb(
value: typing.Optional[typing.Mapping[builtins.str, typing.Any]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__06428b1b28ed30f0c1384a6d5a13aa09e69ba4094155ef9bff2074261f64bc85(
t: IResolvable,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__6e2496293c1d52f1d1a1d7cb90d199bc2d95c0efc70ec58bef81c5e92e78c6c2(
l: typing.Sequence[builtins.str],
context: IResolveContext,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__ec6d2795c1854413fd11b04f75ac05db5d3e9ebda3e0c44fd5c5519a148c471f(
s: TokenizedStringFragments,
context: IResolveContext,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__b83a71c854922c76207ee3305ff734b2f1aaa0a7a12636de23ff86f45b756041(
t: IResolvable,
context: IResolveContext,
post_processor: IPostProcessor,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__f690835f92182062a506fffc4e9d3275914ee37a6eb328a1e03037ac62192123(
value: typing.Any,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__a9d6cb405f1dc003d11ded0e2fcf4924af28d4bb81a501991a861ccc28b25294(
message: builtins.str,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__6ed11c272182745b8f071c64a59933a914b55021a02f39aebbbdaed7955fcf4a(
_context: IResolveContext,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__855c3b8f704d5568c58b5eaf5256d1f96e8973533df785d2287a1fa17f8e0625(
producer: IAnyProducer,
*,
display_hint: typing.Optional[builtins.str] = None,
omit_empty_array: typing.Optional[builtins.bool] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__9d27bdcb87429f6c1ad1c6a63e4fa7f37ec6b156995dd935db8c0232ba62cfb1(
producer: IListProducer,
*,
display_hint: typing.Optional[builtins.str] = None,
omit_empty: typing.Optional[builtins.bool] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__eb3d27bb92f07376c0671ce2a29b9e0322a5e620e9e5d9261fcc112c7dd83880(
producer: INumberProducer,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__f6b154666a2f7bd28fa1944715b8f57b93cf5a42b94aa1cc51b4c287075e2e6f(
producer: IStringProducer,
*,
display_hint: typing.Optional[builtins.str] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__459da39148795d4a2ffdb32575cd274897146155c51dea7f0361cb43373e04b7(
*,
display_hint: typing.Optional[builtins.str] = None,
omit_empty_array: typing.Optional[builtins.bool] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__f43363319a77742c2083fd9d84db3926afdc535ad84dd79e943bb24b761be25d(
*,
display_hint: typing.Optional[builtins.str] = None,
omit_empty: typing.Optional[builtins.bool] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__11154e9acb99e91fe8a38a92330e2004810b345c011269ed4ae3381d938718d9(
*,
display_hint: typing.Optional[builtins.str] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__25327f9b7ddf68f2c9dae74053743641437aa840308c92297b09ca5ce4b2daad(
*,
parameters: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
template_body: typing.Optional[builtins.str] = None,
template_url: typing.Optional[builtins.str] = None,
timeout: typing.Optional[jsii.Number] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__1f8dc2790577ee818f6a8555fec401bd0e2aad0ca17cbcf1ad940dc9bc4fe6f0(
value: typing.Any,
target: IConstruct,
display_name: typing.Optional[builtins.str] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__ac9bc39f84fa4ed07ec85a081144f2a366bff3352728edce92eb3a3ff10c4f12(
x: typing.Any,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__555f312cbc4130456a07898da4b77d3db0176039426274e8555cce2bfbd8dfc7(
*,
apply_to_update_replace_policy: typing.Optional[builtins.bool] = None,
default_policy: typing.Optional[RemovalPolicy] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__1cf5324bcb826f8eda6917454783379af5c03bb9882d50455f1f28ea76eabbf3(
*,
resolver: ITokenResolver,
scope: IConstruct,
preparing: typing.Optional[builtins.bool] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__5eb39483257934b924a474a55b25ee60c39f38148113cb72ba8962bb0da42ada(
*,
physical_name: typing.Optional[builtins.str] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__f534de3d8e5fcb3d98fa2b9d753eded2ae1398e9c0cfaa50692ce7724b85d774(
*,
expression: typing.Optional[IRosConditionExpression] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__dcd93622adc1517313de11a1d1758998640b5ec2e8e86746a8317929c727ae61(
*,
mapping: typing.Optional[typing.Mapping[builtins.str, typing.Mapping[builtins.str, typing.Any]]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__ee818edecc8dc711db71a3f783f7d205fa34f9482dad186f363524140313425c(
*,
value: typing.Any,
condition: typing.Optional[RosCondition] = None,
description: typing.Optional[builtins.str] = None,
export_name: typing.Optional[builtins.str] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__c39b9c0a543f07fdf20a7f9378ee395653a40289a7101cf922b7de73c8a5047b(
*,
allowed_pattern: typing.Optional[builtins.str] = None,
allowed_values: typing.Optional[typing.Sequence[typing.Any]] = None,
association_property: typing.Optional[builtins.str] = None,
association_property_metadata: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
confirm: typing.Optional[builtins.bool] = None,
constraint_description: typing.Optional[typing.Union[builtins.str, typing.Mapping[builtins.str, builtins.str]]] = None,
default_value: typing.Any = None,
description: typing.Optional[typing.Union[builtins.str, typing.Mapping[builtins.str, builtins.str]]] = None,
label: typing.Optional[builtins.str] = None,
max_length: typing.Optional[jsii.Number] = None,
max_value: typing.Optional[jsii.Number] = None,
min_length: typing.Optional[jsii.Number] = None,
min_value: typing.Optional[jsii.Number] = None,
no_echo: typing.Optional[builtins.bool] = None,
text_area: typing.Optional[builtins.bool] = None,
type: typing.Optional[RosParameterType] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__8ddbb242164b50fd9890ea53698b2754f764c707d0eda9dcea236241f154b189(
*,
type: builtins.str,
properties: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__48ebd8113f5a95e7206754d99c94b514bab899631027b98c5b25c87874858e36(
*,
key: builtins.str,
value: typing.Optional[builtins.str] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__a951b9e38e4266f7795d9cf17d13c5cab9723d247372544c2ea0f1e1034a0ddd(
*,
description: typing.Optional[builtins.str] = None,
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
metadata: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
stack_name: typing.Optional[builtins.str] = None,
synthesizer: typing.Optional[IStackSynthesizer] = None,
tags: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
version: typing.Optional[builtins.str] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__0b4d117a06de3b8d93c347567af09a0e7660f43182f1b89b3d9b139dfc7315a8(
*,
outdir: typing.Optional[builtins.str] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__4840d4380846528233f8217e18a55e03a4a174196e2c0e4f2e2111b8cfd9d593(
*,
skip_validation: typing.Optional[builtins.bool] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__aeb329831e76fa2de1f9eedf7841ce46f3da80065f0977e8f9f2d47cf23f4827(
left: typing.Any,
right: typing.Any,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__b34253714854164c90ac2f1ce4bd38e20e18b53c45053e143999cad2d528be12(
*,
runtime_info: typing.Optional[typing.Union[_ros_cdk_cxapi_45dace6b.RuntimeInfo, typing.Dict[builtins.str, typing.Any]]] = None,
outdir: typing.Optional[builtins.str] = None,
skip_validation: typing.Optional[builtins.bool] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__b31f0916603b9ac0a19041d432d8b63a66c9d635884be9ce7cfe64043d13b996(
tag_type: TagType,
resource_type_name: builtins.str,
tag_structure: typing.Any = None,
*,
tag_property_name: typing.Optional[builtins.str] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__5e3db5dabbad4d55b94d26d442069e119d50daaa4b8d2f279a7dbb32281bf0cd(
construct: typing.Any,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__4e52e20f19c15005b1419702493d03ce70ff0090e04c7b0116e7842aaea82195(
include: typing.Optional[typing.Sequence[builtins.str]] = None,
exclude: typing.Optional[typing.Sequence[builtins.str]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__607bb507ff316ca9882e67bbdda771afd44a804d1822223bddac5091599672e3(
key: builtins.str,
priority: jsii.Number,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__1b5c4a3cfda8aa538d53e13c5614c2be4dcc0dd1693e8a3c09b4896ee2915fa8(
key: builtins.str,
value: builtins.str,
priority: typing.Optional[jsii.Number] = None,
apply_to_launched_instances: typing.Optional[builtins.bool] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__762aea27829aa2022727347af6041130cc95adf01466f33b366e43fc81c7d366(
*,
tag_property_name: typing.Optional[builtins.str] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__10cbda2ba292cace9348c3269b4a0e4ef2c137fd31c2cfe347e37b9a82a42113(
value: typing.Any,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__8f4e057c19741202d697745f96cdac2507420fb69665f906cfbf139e83e5c25f(
value: typing.Any,
*,
display_hint: typing.Optional[builtins.str] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__e810b924d685cb48f32839a0b7f6c794e8e7479f053d6175afb6b297c374c257(
value: typing.Any,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__42e46304e3c03d9f33a2ee730e211b7adc4b55bc70bb89dc7321d0d2f309c2f3(
value: typing.Any,
*,
display_hint: typing.Optional[builtins.str] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__44124ba50108ab8e08c87dd89f6eb94b1a0664a5a3b1da6f8700b15789bf11e3(
obj: typing.Any,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__40a96ccdbe485dab06de95cb233d33fad660624b380a8a8fb2344c6aaa56d74a(
obj: typing.Any,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__c89018313fbf500beba9c940ccfdded3a6dd1cb684bcf03e9daef7e54d3978fe(
obj: typing.Any,
*,
resolver: ITokenResolver,
scope: IConstruct,
preparing: typing.Optional[builtins.bool] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__9e55de9d18756386134ebce512c21523d92c378766278fc50534a8cd1668af16(
l: typing.Sequence[builtins.str],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__e5e35a2fe0dd0bc9b2fdc457c232db0df1e729aec4917cfa407e15a0421c7439(
n: jsii.Number,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__4498b1ae96d2081b3636f64315f9a32e7d913a0ebb0c9043445603ef9c73ecfa(
s: builtins.str,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__4baaf0fdb93d747169ccfac8fe3c052c1e366aaa3cf94c4c3ed6cf21994123fb(
x: jsii.Number,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__299944495831f0351a5c3fbe9fda834ddf89ee24168fc7a0f7401221decb1d5a(
value: typing.Any,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__2afff4a4b2f29e3e273f323f6b9d7e749e21718257d27356f4e9425c85d64467(
lit: typing.Any,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__3e46e28eb8bebe2734ab7401ad99908b2f4d641e7cffad9589a1c9df06b57557(
token: IResolvable,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__c80dc9e0477ad2aef93147913606ac3e6d84dacc0d042dcdc512372c14420f07(
concat: IFragmentConcatenator,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__67ffc6b31d0552ac1f075e597446ec4e3590af7972656e2a81c0453e5d48f60f(
mapper: ITokenMapper,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__8160540b1b0781396fbb49de8909f485bc6847f12b06c284899426a5ba73d702(
key: builtins.str,
value: typing.Any,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__24c461a233468bdd35c3de4534cc3efeef61b40de176800f40e33fe5d9b63935(
*,
message: builtins.str,
source: Construct,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__8464e23dc0647f104591d2538171583569e436394676dc7eacc14605f4bc6c6f(
error_message: typing.Optional[builtins.str] = None,
results: typing.Optional[ValidationResults] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__14b5bac0e79db41ff39720d1056b6d3ad3381b18f0245a6992c93703c07bc82f(
message: builtins.str,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__d22e62cd44b29ae7387d4d18bcbc2e8767111e1b9f70ad6d9bbaaa972ec3b410(
results: typing.Optional[typing.Sequence[ValidationResult]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__ee64811eef3876aca433a599fde8c5d35b893f421e7c1492cdbaf75d4a580c38(
result: ValidationResult,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__097ed477d8f3d33cc0e8be9230f76e3de9bcc8e9f3f4aa640fb62bd5ea9e213c(
message: builtins.str,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__4403f3c33afef1e6ba1ccbadc87ac1ddd05aae6b7a400b3cbd85a043d7d85462(
value: typing.List[ValidationResult],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__2aff3187c70abf274ed13cd4a3f2e4998d0f0992886e51edb0da1d043b8c4479(
construct: IConstruct,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__056834e8ea5e467b3e578dab4687464feb942970071b2e92b431cb79e887b6e4(
stack: Stack,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__c57938c57f0e21ffd21d8acfc12cedae1a940974abf5c9d97f6e3a44fef3f31a(
session: ISynthesisSession,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__9727b4179c0e167b591e6d6381af6777aa5c0bc173a9be06c520752e6276a79b(
concat: IFragmentConcatenator,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__216b9096fbe63ca7f074fc29e40563204d6f77fcf26ca8d257635a47aaf5654c(
xs: typing.Sequence[builtins.str],
context: IResolveContext,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__94afe6ae9a614e95657ec50260cbe8a8f37f3334a6f8e36774cc6d50076adce9(
fragments: TokenizedStringFragments,
context: IResolveContext,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__c53a6ef11bc0db98771275f3ebe02ae5f19946dcc1e5c5d6d3b3d064bc41fc0c(
t: IResolvable,
context: IResolveContext,
post_processor: IPostProcessor,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__686e2b42bbe4af2a65edd2cbf32a76d1c722ba8453b459409936c8b9aa9fbf03(
values: typing.Any,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__45110e0d6534b98ed8e6e9281dc23a01599642f85573bf97ad8d584b97f59491(
*condition: typing.Union[builtins.str, IRosConditionExpression],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__b9524542b26c45613494832a6e6412d4cdfe45869ceeabd7ee930da6b0ef7ef6(
value: typing.Any,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__52065ec56e8eae2266f840354d908795d211fda0f7050a5d39c062982a080ba9(
data: typing.Any,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__40e0d55844e1804e912770b8e7c076cfb38b59071e09baebb42b3e5e0e337fe0(
data: typing.Any,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__26465fde8e7163abd6f7cb2de91952795d430f22b34a8d6cf28a0ef4761de891(
value: typing.Any,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__b3cc295f516f290459b1196f5b3f00e46e3c192dc4ac112e357e96a209e33fad(
lhs: typing.Any,
rhs: typing.Any,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__dd98760b6a01e88e5ed5377b56f290262fd96f6703c0328839b0e0668e6ddafa(
value: typing.Any,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__99a58fd57d7de4274f57bce0fac8696676b644b6bd94046816eaa33980856884(
region: typing.Any,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__0bf228358201491aaacfb32677b98c44e0d2791cbef92d2c13a4a1b612a88544(
logical_name_of_resource: builtins.str,
attribute_name: builtins.str,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__5a2e3c1b3ac88b16338cbf206af8919482beb8d247ee3ff3215f49de03ddf0de(
value: typing.Any,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__16e5baaf8cdfb71cdcdc61ee86e19fbe34de66252cc13ec6e10d05b56b2cae67(
value: typing.Any,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__bd45b41054d6fd402e50eb7829f1b272ebdac9695a6aa57470cb2b3361cd658f(
condition: typing.Union[builtins.str, IRosConditionExpression],
value_if_true: typing.Any,
value_if_false: typing.Any,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__e0122df383b5bc5fa6367cdb94a99ac0174bb8f1f325bd5ed5b2f6ecc4dca2a6(
delimiter: builtins.str,
list_of_values: typing.Sequence[typing.Any],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__61ef76dd29f6e730b8a873263bec53e01d984484dab8e4c18002a13641acee47(
context: IResolveContext,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__8eb62c800fcae67b10a7b5c30ccb3c039f73b92a810339966810785336b14d0e(
value: typing.Any,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__e8c35bdce19ff8d2ea687c9a63e379a6babcc6ff8119fd475f25f1b5ea1c25ee(
value: typing.Any,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__9c01b3caf582f9af877e56cc694bb360a2085322725b78786274d824cdaf2072(
values: typing.Any,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__a615ab5ca96cf38319d0e6b4a376abfa40a4feb616ea507c962ee6cb7b1690bd(
map_list: typing.Any,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__b9b3bd114c9b3dc0c6ac49a5be7ec7f0bcbbb1ff5fa2912854055f81c5b00296(
values: typing.Any,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__aa8f0c940a166a4c70ea31088c6453e4302d5d801015d2550db27f2ec81e930b(
condition: typing.Union[builtins.str, IRosConditionExpression],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__adf2e03c690c3cb28b74e88982a4889d3b0d5b54d92b5a3556624ce9a9f7fd8a(
*condition: typing.Union[builtins.str, IRosConditionExpression],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__61889f70542841a7dcc6f9a86f78d58f369a603f32fea0e24af9a0038e420cf1(
logical_name: builtins.str,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__0250eb79836dc506c39f785b743b8af41f55a581763ad1190d251682df8b0555(
value: typing.Any,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__29fbee6c85e18606ce841248ed899786d11cbeef5717939d92fbf8662a5a02e5(
value: typing.Any,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__7943bda42cbb6b91580503ce70079765bd1027495853a52b7c78d1715d76e8ef(
value: typing.Any,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__2102430162bd15106fa9023902fbaf95aa0321bdc3212c478770febe2a0dc945(
value: typing.Any,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__b00749cf94b050e10d4ab91960af1d49a86a78183b31830079457c840eb9cb2f(
value: typing.Any,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__1d91ade8c7dd39fea016dc553268e72b597d83596b15dfa5cf4baa2671204f76(
value: typing.Any,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__5ecfb8f7a776d0de65e015ad8172e9f8a178dfc04f8dec1b2457d86c1bcce877(
scope: Construct,
id: builtins.str,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__d81f1bc767e0d25084ea165ce16fa1c230bffea60cbe788385d3a0c0464589a7(
x: typing.Any,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__4197923b6ab33eb87eae536a39bd7d210a48cd7dc85d241d4a8085cdf3f7dc33(
session: _constructs_77d1e7e8.ISynthesisSession,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__2f7caf605f353ebe34c5a2ec53efdef2cfa7107d02aeed0f97d720b59659e706(
session: ISynthesisSession,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__033bb68d0358ede779f4100fe0f171f4f4096ee9aaa265cd7450816e13f088d8(
scope: Construct,
id: builtins.str,
*,
physical_name: typing.Optional[builtins.str] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__0aa8adb2d892faa138aee5c2af9a6cbbbfc9d54b43889d0799eebf9400b57059(
condition: RosCondition,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__9a26f834a04528bb7b9d99cd6a3b1c1f5afa6975f3da82cac68b4b711b4c0f75(
count: typing.Union[jsii.Number, IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__72092dbfe054fc98599cfa5aeeb4d43af094fa113e4c033759d9d0e9e97c531c(
resource: Resource,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__d2de7567d682f0d1123dbb1b9b79114ec2ae9f54c7129f94c03a3d2eda6e46f0(
desc: builtins.str,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__c6f59019a6cdb5178ab386365e04a087fe7d1567a3b3f2ad94de5f8bdf660ae7(
policy: RemovalPolicy,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__5e2160cb5dc7359592892c674d564da7c8414d648c824034201bd3dd82ec0bec(
name: builtins.str,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__6a9029d185d924daa02b18c58064fef6c16d7b34e4f28fccbe1b8eab51797cd4(
key: builtins.str,
value: typing.Any,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__f9d9dbf8b7f0d7f6cdf67a80e6264fd20b981f29db775ecb90841534c8fff724(
value: typing.Optional[RosResource],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__47cdb0909e8e294d54ce6c8ae50dfb95c5fdf1709eb8ea16fdce2ef2e8f73e7b(
scope: Construct,
id: builtins.str,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__3d40a5c72ddbab2cda8b7e6ef044a141113184fda4c3aa8716c67666d897bd3e(
x: typing.Any,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__08dd30761a553a2adc5e01c01d68f30e8ddea800911818c648f0a49c635f69fb(
new_logical_id: builtins.str,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__7300de86255b954db919450213cdd6104ff126ec38b173084a8af111ebb6bf42(
scope: Construct,
id: builtins.str,
info: typing.Union[builtins.str, typing.Mapping[builtins.str, typing.Any]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__8b371b50c0476a22f7da554b0ef5e1b89dc247a8bb992c6f86b2ed7c09e0892e(
value: builtins.str,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__aa96b151c96eada05a9d3b279fb66e4cb84bb539d53d0fa549a3a8b5409590e9(
value: builtins.str,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__2e410986d9d6502c50d2359c177f56480efe88b9aaac9a2dc2b6b21f61681483(
value: builtins.str,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__94e885e07ee948b0adff014e19a0ee4e877f020a16bf7c546ccca03bdd02e8d0(
value: builtins.str,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__ddd2ed831ba9eeda3b15433187523442a685f4956efb14117d5dafc98c124d14(
scope: Construct,
id: builtins.str,
*,
value: typing.Any,
condition: typing.Optional[RosCondition] = None,
description: typing.Optional[builtins.str] = None,
export_name: typing.Optional[builtins.str] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__b7aaa28eb232cdee9e75f6952c8ab6cf5980c389158bbcfa89b4f4432767c575(
condition: RosCondition,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__c1eedc66bdf3ec0f47726c50b7cb3a20ea4c777331c44e83e7720074022f7d61(
scope: Construct,
id: builtins.str,
*,
allowed_pattern: typing.Optional[builtins.str] = None,
allowed_values: typing.Optional[typing.Sequence[typing.Any]] = None,
association_property: typing.Optional[builtins.str] = None,
association_property_metadata: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
confirm: typing.Optional[builtins.bool] = None,
constraint_description: typing.Optional[typing.Union[builtins.str, typing.Mapping[builtins.str, builtins.str]]] = None,
default_value: typing.Any = None,
description: typing.Optional[typing.Union[builtins.str, typing.Mapping[builtins.str, builtins.str]]] = None,
label: typing.Optional[builtins.str] = None,
max_length: typing.Optional[jsii.Number] = None,
max_value: typing.Optional[jsii.Number] = None,
min_length: typing.Optional[jsii.Number] = None,
min_value: typing.Optional[jsii.Number] = None,
no_echo: typing.Optional[builtins.bool] = None,
text_area: typing.Optional[builtins.bool] = None,
type: typing.Optional[RosParameterType] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__a28eb848a0f55c965d4c5b981426497b24a126948abc9ce0a408838596a87de2(
_context: IResolveContext,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__bc68be0ccd998c03d226dee9f58b58db58d51777d1dcb148ca8580210f62d8da(
scope: Construct,
id: builtins.str,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__941346c4ba544e38c6d484ee04db6f28c2e03e3998827ec04c07caeb8e3513b9(
scope: Construct,
id: builtins.str,
*,
type: builtins.str,
properties: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__26a7a5bd0c2c812f4b7c3483c22ba2665d748cd34851f26f18d362f3b7641568(
construct: IConstruct,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__3bab3990b90c81f3ea564fe13bb7a16fd3f3b943f93b68220c584761a015331f(
con: RosCondition,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__6dcfa9031021a07adecdb44494c0f0c80c2d66bd014996148e6443d50d8f4755(
count: typing.Union[jsii.Number, IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__5dc20ad26961aac937f4a09fe1babbdd7982bf6c0e340f79c2662c20030cd319(
path: builtins.str,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__4fcdc2057253d1e8056633ce513f71b142942e1b4c71bbd14bffbb951ce349db(
target: RosResource,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__5603f5e790e6800ca247898c0a76a748b08bdccea54b2f8d8ef44dcd446d54b3(
desc: builtins.str,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__e8d8fdbfca26a1b9c08967852905c7f2c18defd647238b134e1b34d1f98622c7(
key: builtins.str,
value: typing.Any,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__de4d904e391329b12281f41d993ef7bec66f72067ac6df107010c7da6ad60fc6(
path: builtins.str,
value: typing.Any,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__e73a34b5fd578a1a0e6d239f8de7f429c7c7cb23dd01e234b26d2537a37db7e1(
property_path: builtins.str,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__3d3152a58d03df66e61a691c9a3e2407cd03751db0aa384483e63e6239031b34(
property_path: builtins.str,
value: typing.Any,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__571aed41b9b5890cca2490033e2ffea5957ed69b0a36cc932074ac2aff4688ec(
target: builtins.str,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__f11f6c0e586fc49c3773a537af49ac2e497dcc49ecdecb8c4d92702a8e66a7e4(
policy: typing.Optional[RemovalPolicy] = None,
*,
apply_to_update_replace_policy: typing.Optional[builtins.bool] = None,
default_policy: typing.Optional[RemovalPolicy] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__01a8a56058b17a312f5ffb8ca87bdfeb2749ff430a4213b4a7dda2c476ab0ef4(
attribute_name: builtins.str,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__980668d774fee5ae667c0a3cf02ce68aedfdf3b8f92d10348ec1a94883c0c78b(
props: typing.Mapping[builtins.str, typing.Any],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__6e75c1ebcfe210720730289132506828c5a1e5c261f68ef912e260fdd4f28fd4(
_properties: typing.Any,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__1dc168842bc69954d0e07ab74e7ad20f5227249df44949f4a202402c806ebe86(
scope: typing.Optional[Construct] = None,
id: typing.Optional[builtins.str] = None,
*,
description: typing.Optional[builtins.str] = None,
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
metadata: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
stack_name: typing.Optional[builtins.str] = None,
synthesizer: typing.Optional[IStackSynthesizer] = None,
tags: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
version: typing.Optional[builtins.str] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__0bc7e129e09b4feddab62e4966768ba39cbaed884489a9137f10d40ac2bf7db0(
x: typing.Any,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__b94641c207370c83802c8c71ec1c1b6f5bfe8e7d3d68b538d8e81241a823e1e6(
construct: IConstruct,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__b4506fefa5dd69433347eb17079b665a7e5aeed444aaa064f41f02e964b224b2(
target: Stack,
reason: typing.Optional[builtins.str] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__0af605d4b0354a6812eb679f03dc7800afa36dba79ee386d95519a3db2ca6977(
ros_element: RosElement,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__7bfdee0d9f37059144839af82465d446909bf1e3490f99384d011f1a8324a431(
element: RosElement,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__af7bd001d5b018cf8e304d958695046f54f29932881a260dc73b7e680abb1f87(
_source_stack: Stack,
reference: Reference,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__bbf09e8a560a6d2a51b85d6d34d59468e862c5d2438cfb9d51a67d4e52fc7683(
old_id: builtins.str,
new_id: builtins.str,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__2df79660b12efbfa718154119699655340f2e0f1473b164ba21d864a85e698e4(
obj: typing.Any,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__af0331c6d2a7f5ce9ffb0945062b3bd65a450e61fb33a74d8d8893038819f96e(
session: ISynthesisSession,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__076a3f3e8ef5caf16f7c89a9161d7d167666b81169349270d1676da89018fb23(
obj: typing.Any,
space: typing.Optional[jsii.Number] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__9d3cc5431aa000ead0553b38893e095b0fff1ca6e8cfac885d80486e937a4dbb(
scope: Construct,
id: builtins.str,
*,
outdir: typing.Optional[builtins.str] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__57cc149bf33dfb1dd59aecbfb358c0d1cccf4e870c0cbf33c3e18336b7e6de8f(
x: typing.Any,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__be7e7d60a27fba054f5fa1e6d28e319ee2e67b01f4cedf5452c2627e2aa17bc8(
construct: IConstruct,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__74d0fa652e39f975ef68ff4093ff1dfd8c4919e78344e1e557ea1960f095bcd0(
obj: typing.Any,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__2e646842a4e32a91459603425998d3a13b4b135ea05d39360f3d382a3486dc84(
scope: Construct,
id: builtins.str,
*,
parameters: typing.Optional[typing.Mapping[builtins.str, typing.Any]] = None,
template_body: typing.Optional[builtins.str] = None,
template_url: typing.Optional[builtins.str] = None,
timeout: typing.Optional[jsii.Number] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__25b017370399ffba3a033fae3ebc112f4fdd2e6f79c636d64384b8f4a381bb0d(
x: typing.Any,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__447d9f5b6c2854b6d918d5ae1853ac034d78e15222dae3f55f6c81b4e9386c88(
attribute_name: builtins.str,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__e8acfe38a22d7972aef78bf4967459c27003e8a578a5baffcc308affdbc9c9bc(
name: builtins.str,
value: typing.Any,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__a4adeb2f3dbe000bfb1c7ec7bed924206f4df34a2bc64ad2e4e1e1504e7a7c13(
scope: Construct,
id: builtins.str,
*,
expression: typing.Optional[IRosConditionExpression] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__e2ef9d8bbd99a6ab400cec2a3268734727521372a8f3dd11a561cbbfceaa382a(
_context: IResolveContext,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__320a90f621af7519a0584bb43b35d213f2c135a2982b42bad6edb3d7ff01f842(
value: typing.Optional[IRosConditionExpression],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__339c8731b33058714cd4c46bb12532db7cb165d85986335505599f486cb0e2e1(
scope: Construct,
id: builtins.str,
*,
mapping: typing.Optional[typing.Mapping[builtins.str, typing.Mapping[builtins.str, typing.Any]]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__2700068fd9ad29f35ddcdc8992b2ffd67e016c0cc7343a6e921126ab1927e842(
key1: builtins.str,
key2: builtins.str,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__bf0fe656246b94ac6fc706854b81700474ad2a9a16e4cb7a23e1b55588f7ec37(
key1: builtins.str,
key2: builtins.str,
value: typing.Any,
) -> None:
"""Type checking stubs"""
pass | /ros-cdk-core-1.0.19.tar.gz/ros-cdk-core-1.0.19/src/ros_cdk_core/__init__.py | 0.667473 | 0.199152 | __init__.py | pypi |
import abc
import builtins
import datetime
import enum
import typing
import jsii
import publication
import typing_extensions
from typeguard import check_type
from .._jsii import *
import ros_cdk_core as _ros_cdk_core_7adfd82f
class ClusterApplicationResources(
_ros_cdk_core_7adfd82f.Resource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-cs.datasource.ClusterApplicationResources",
):
'''A ROS resource type: ``DATASOURCE::CS::ClusterApplicationResources``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["ClusterApplicationResourcesProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
'''Create a new ``DATASOURCE::CS::ClusterApplicationResources``.
Param scope - scope in which this resource is defined
Param id - scoped id of the resource
Param props - resource properties
:param scope: -
:param id: -
:param props: -
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__293113022aca25e91d5765b13b06a36083e1f82d114b7115757e4e2546ae318c)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@builtins.property
@jsii.member(jsii_name="attrResponse")
def attr_response(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute Response: Query result of kubernetes resource(s).'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrResponse"))
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-cs.datasource.ClusterApplicationResourcesProps",
jsii_struct_bases=[],
name_mapping={
"cluster_id": "clusterId",
"kind": "kind",
"first_match": "firstMatch",
"json_path": "jsonPath",
"name": "name",
"namespace": "namespace",
},
)
class ClusterApplicationResourcesProps:
def __init__(
self,
*,
cluster_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
kind: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
first_match: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
json_path: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
namespace: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``DATASOURCE::CS::ClusterApplicationResources``.
:param cluster_id: Property clusterId: The ID of the kubernetes cluster.
:param kind: Property kind: The kind of kubernetes resources to query.
:param first_match: Property firstMatch: Only the first matching result in jsonpath's filtered results is returned. Default False
:param json_path: Property jsonPath: Json path expression to filter the output.
:param name: Property name: The name of the kubernetes resource to query.
:param namespace: Property namespace: The namespace of kubernetes containing the resource. Default value is default
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__dc0fd0fb58ead564a98149a5b60b36741dc423967339e98c4ede2f7f5825fb61)
check_type(argname="argument cluster_id", value=cluster_id, expected_type=type_hints["cluster_id"])
check_type(argname="argument kind", value=kind, expected_type=type_hints["kind"])
check_type(argname="argument first_match", value=first_match, expected_type=type_hints["first_match"])
check_type(argname="argument json_path", value=json_path, expected_type=type_hints["json_path"])
check_type(argname="argument name", value=name, expected_type=type_hints["name"])
check_type(argname="argument namespace", value=namespace, expected_type=type_hints["namespace"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"cluster_id": cluster_id,
"kind": kind,
}
if first_match is not None:
self._values["first_match"] = first_match
if json_path is not None:
self._values["json_path"] = json_path
if name is not None:
self._values["name"] = name
if namespace is not None:
self._values["namespace"] = namespace
@builtins.property
def cluster_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property clusterId: The ID of the kubernetes cluster.'''
result = self._values.get("cluster_id")
assert result is not None, "Required property 'cluster_id' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def kind(self) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property kind: The kind of kubernetes resources to query.'''
result = self._values.get("kind")
assert result is not None, "Required property 'kind' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def first_match(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property firstMatch: Only the first matching result in jsonpath's filtered results is returned.
Default False
'''
result = self._values.get("first_match")
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def json_path(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property jsonPath: Json path expression to filter the output.'''
result = self._values.get("json_path")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def name(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property name: The name of the kubernetes resource to query.'''
result = self._values.get("name")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def namespace(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property namespace: The namespace of kubernetes containing the resource.
Default value is default
'''
result = self._values.get("namespace")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "ClusterApplicationResourcesProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class ClusterNodePools(
_ros_cdk_core_7adfd82f.Resource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-cs.datasource.ClusterNodePools",
):
'''A ROS resource type: ``DATASOURCE::CS::ClusterNodePools``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["ClusterNodePoolsProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
'''Create a new ``DATASOURCE::CS::ClusterNodePools``.
Param scope - scope in which this resource is defined
Param id - scoped id of the resource
Param props - resource properties
:param scope: -
:param id: -
:param props: -
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__329818a4866ed37a9b1668c057843433c9b7f976f321a3d342f05978eb5b9cd4)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@builtins.property
@jsii.member(jsii_name="attrNodePoolIds")
def attr_node_pool_ids(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute NodePoolIds: The list of node_pool IDs.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrNodePoolIds"))
@builtins.property
@jsii.member(jsii_name="attrNodePools")
def attr_node_pools(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute NodePools: The list of node_pools.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrNodePools"))
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-cs.datasource.ClusterNodePoolsProps",
jsii_struct_bases=[],
name_mapping={"cluster_id": "clusterId"},
)
class ClusterNodePoolsProps:
def __init__(
self,
*,
cluster_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
'''Properties for defining a ``DATASOURCE::CS::ClusterNodePools``.
:param cluster_id: Property clusterId: Cluster ID.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__5acff2ff695c10bbf3b4115adc03efbddf23c8c83bed6d2002f511d7d5879f5c)
check_type(argname="argument cluster_id", value=cluster_id, expected_type=type_hints["cluster_id"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"cluster_id": cluster_id,
}
@builtins.property
def cluster_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property clusterId: Cluster ID.'''
result = self._values.get("cluster_id")
assert result is not None, "Required property 'cluster_id' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "ClusterNodePoolsProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class ClusterUserKubeconfig(
_ros_cdk_core_7adfd82f.Resource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-cs.datasource.ClusterUserKubeconfig",
):
'''A ROS resource type: ``DATASOURCE::CS::ClusterUserKubeconfig``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["ClusterUserKubeconfigProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
'''Create a new ``DATASOURCE::CS::ClusterUserKubeconfig``.
Param scope - scope in which this resource is defined
Param id - scoped id of the resource
Param props - resource properties
:param scope: -
:param id: -
:param props: -
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__61ce7798d06a4b415379236edc72bd24e91ec506db477a1f85d90d70939b96a3)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@builtins.property
@jsii.member(jsii_name="attrClusterId")
def attr_cluster_id(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute ClusterId: The ID of the ACK cluster.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrClusterId"))
@builtins.property
@jsii.member(jsii_name="attrConfig")
def attr_config(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute Config: The content of the kubeconfig file.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrConfig"))
@builtins.property
@jsii.member(jsii_name="attrExpiration")
def attr_expiration(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute Expiration: The expiration time of the kubeconfig file.
The value is the UTC time displayed in RFC3339 format.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrExpiration"))
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-cs.datasource.ClusterUserKubeconfigProps",
jsii_struct_bases=[],
name_mapping={
"cluster_id": "clusterId",
"private_ip_address": "privateIpAddress",
"temporary_duration_minutes": "temporaryDurationMinutes",
},
)
class ClusterUserKubeconfigProps:
def __init__(
self,
*,
cluster_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
private_ip_address: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
temporary_duration_minutes: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``DATASOURCE::CS::ClusterUserKubeconfig``.
:param cluster_id: Property clusterId: The ID of the ACK cluster.
:param private_ip_address: Property privateIpAddress: Specifies whether to obtain the credential that is used to connect to the cluster over the internal network. Valid values: true: obtains the credential that is used to connect to the cluster over the internal network. false: obtains the credential that is used to connect to the cluster over the Internet. Default value: false.
:param temporary_duration_minutes: Property temporaryDurationMinutes: The validity period of a temporary kubeconfig file. Unit: minutes. Valid values: 15 to 4320. Note If you do not specify this parameter, the system automatically specifies a validity period, which is indicated by the expiration field in the response.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__245a6f48f726cb8fd6ab4a508a1b778515142998b886c3fbb386e4f5e8eb7275)
check_type(argname="argument cluster_id", value=cluster_id, expected_type=type_hints["cluster_id"])
check_type(argname="argument private_ip_address", value=private_ip_address, expected_type=type_hints["private_ip_address"])
check_type(argname="argument temporary_duration_minutes", value=temporary_duration_minutes, expected_type=type_hints["temporary_duration_minutes"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"cluster_id": cluster_id,
}
if private_ip_address is not None:
self._values["private_ip_address"] = private_ip_address
if temporary_duration_minutes is not None:
self._values["temporary_duration_minutes"] = temporary_duration_minutes
@builtins.property
def cluster_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property clusterId: The ID of the ACK cluster.'''
result = self._values.get("cluster_id")
assert result is not None, "Required property 'cluster_id' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def private_ip_address(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property privateIpAddress: Specifies whether to obtain the credential that is used to connect to the cluster over the internal network.
Valid values:
true: obtains the credential that is used to connect to the cluster over the internal network.
false: obtains the credential that is used to connect to the cluster over the Internet.
Default value: false.
'''
result = self._values.get("private_ip_address")
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def temporary_duration_minutes(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property temporaryDurationMinutes: The validity period of a temporary kubeconfig file.
Unit: minutes. Valid values: 15 to 4320.
Note If you do not specify this parameter, the system automatically specifies a validity period, which is indicated by the expiration field in the response.
'''
result = self._values.get("temporary_duration_minutes")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "ClusterUserKubeconfigProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class KubernetesClusters(
_ros_cdk_core_7adfd82f.Resource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-cs.datasource.KubernetesClusters",
):
'''A ROS resource type: ``DATASOURCE::CS::KubernetesClusters``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Optional[typing.Union["KubernetesClustersProps", typing.Dict[builtins.str, typing.Any]]] = None,
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
'''Create a new ``DATASOURCE::CS::KubernetesClusters``.
Param scope - scope in which this resource is defined
Param id - scoped id of the resource
Param props - resource properties
:param scope: -
:param id: -
:param props: -
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__0e2ecdafcef2411e2b722e22406cbd2fd53e07d613859a9da0be4e55baa7cacd)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@builtins.property
@jsii.member(jsii_name="attrClusterIds")
def attr_cluster_ids(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute ClusterIds: The list of cluster IDs.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrClusterIds"))
@builtins.property
@jsii.member(jsii_name="attrClusters")
def attr_clusters(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute Clusters: The list of clusters.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrClusters"))
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-cs.datasource.KubernetesClustersProps",
jsii_struct_bases=[],
name_mapping={
"cluster_spec": "clusterSpec",
"cluster_type": "clusterType",
"name": "name",
"profile": "profile",
},
)
class KubernetesClustersProps:
def __init__(
self,
*,
cluster_spec: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
cluster_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
profile: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``DATASOURCE::CS::KubernetesClusters``.
:param cluster_spec: Property clusterSpec: The specification of the cluster. If you set the cluster type to ManagedKubernetes, you can use cluster specifications to distinguish clusters. Valid values: ack.pro.small: professional managed Kubernetes cluster ack.standard: standard managed Kubernetes cluster By default, this parameter is empty. This indicates that the parameter is not used to filter clusters.
:param cluster_type: Property clusterType: The type of the cluster. Valid values: Kubernetes: dedicated Kubernetes cluster ManagedKubernetes: managed Kubernetes cluster, serverless Kubernetes (ASK) cluster, or edge Kubernetes cluster Ask: ASK cluster ExternalKubernetes: registered external cluster When you query an ASK cluster, the value specified when the cluster was created is returned.
:param name: Property name: The name of the cluster.The name must be 1 to 63 characters in length, and can contain digits, letters, and hyphens (-). It cannot start with a hyphen (-).
:param profile: Property profile: The identifier of the cluster. If you set the cluster type to ManagedKubernetes, you can use cluster identifiers to distinguish clusters. Valid values: Default: managed Kubernetes cluster Serverless: ASK cluster Edge: edge Kubernetes cluster By default, this parameter is empty. This indicates that the parameter is not used to filter clusters.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__4f944cf8791691309755c0d6ffcffe02ef2e337f2dcac8886e4f761ab555e8fd)
check_type(argname="argument cluster_spec", value=cluster_spec, expected_type=type_hints["cluster_spec"])
check_type(argname="argument cluster_type", value=cluster_type, expected_type=type_hints["cluster_type"])
check_type(argname="argument name", value=name, expected_type=type_hints["name"])
check_type(argname="argument profile", value=profile, expected_type=type_hints["profile"])
self._values: typing.Dict[builtins.str, typing.Any] = {}
if cluster_spec is not None:
self._values["cluster_spec"] = cluster_spec
if cluster_type is not None:
self._values["cluster_type"] = cluster_type
if name is not None:
self._values["name"] = name
if profile is not None:
self._values["profile"] = profile
@builtins.property
def cluster_spec(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property clusterSpec: The specification of the cluster.
If you set the cluster type to ManagedKubernetes, you can use cluster specifications to distinguish clusters. Valid values:
ack.pro.small: professional managed Kubernetes cluster
ack.standard: standard managed Kubernetes cluster
By default, this parameter is empty. This indicates that the parameter is not used to filter clusters.
'''
result = self._values.get("cluster_spec")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def cluster_type(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property clusterType: The type of the cluster.
Valid values:
Kubernetes: dedicated Kubernetes cluster
ManagedKubernetes: managed Kubernetes cluster, serverless Kubernetes (ASK) cluster, or edge Kubernetes cluster
Ask: ASK cluster
ExternalKubernetes: registered external cluster
When you query an ASK cluster, the value specified when the cluster was created is returned.
'''
result = self._values.get("cluster_type")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def name(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property name: The name of the cluster.The name must be 1 to 63 characters in length, and can contain digits, letters, and hyphens (-). It cannot start with a hyphen (-).'''
result = self._values.get("name")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def profile(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property profile: The identifier of the cluster.
If you set the cluster type to ManagedKubernetes, you can use cluster identifiers to distinguish clusters. Valid values:
Default: managed Kubernetes cluster
Serverless: ASK cluster
Edge: edge Kubernetes cluster
By default, this parameter is empty. This indicates that the parameter is not used to filter clusters.
'''
result = self._values.get("profile")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "KubernetesClustersProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class RosClusterApplicationResources(
_ros_cdk_core_7adfd82f.RosResource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-cs.datasource.RosClusterApplicationResources",
):
'''A ROS template type: ``DATASOURCE::CS::ClusterApplicationResources``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["RosClusterApplicationResourcesProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
'''Create a new ``DATASOURCE::CS::ClusterApplicationResources``.
:param scope: - scope in which this resource is defined.
:param id: - scoped id of the resource.
:param props: - resource properties.
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__caa1f144d3a1b381378c7ced2ddc9bb997cf1c1b94151d40e53d522e38513dbd)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@jsii.member(jsii_name="renderProperties")
def _render_properties(
self,
props: typing.Mapping[builtins.str, typing.Any],
) -> typing.Mapping[builtins.str, typing.Any]:
'''
:param props: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__2ebae1ddc6b1595741fa2c5cec130cf5ac5488287f9e8de606e4aced60935e84)
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))
@jsii.python.classproperty
@jsii.member(jsii_name="ROS_RESOURCE_TYPE_NAME")
def ROS_RESOURCE_TYPE_NAME(cls) -> builtins.str:
'''The resource type name for this resource class.'''
return typing.cast(builtins.str, jsii.sget(cls, "ROS_RESOURCE_TYPE_NAME"))
@builtins.property
@jsii.member(jsii_name="attrResponse")
def attr_response(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: Response: Query result of kubernetes resource(s).
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrResponse"))
@builtins.property
@jsii.member(jsii_name="rosProperties")
def _ros_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "rosProperties"))
@builtins.property
@jsii.member(jsii_name="clusterId")
def cluster_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: clusterId: The ID of the kubernetes cluster.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "clusterId"))
@cluster_id.setter
def cluster_id(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__227a407d96698c49f0e1227acf43405b36fed606020879a4a71b8f088eab645b)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "clusterId", value)
@builtins.property
@jsii.member(jsii_name="enableResourcePropertyConstraint")
def enable_resource_property_constraint(self) -> builtins.bool:
return typing.cast(builtins.bool, jsii.get(self, "enableResourcePropertyConstraint"))
@enable_resource_property_constraint.setter
def enable_resource_property_constraint(self, value: builtins.bool) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__8833fd062642d423b64b4ebe4e50027445ca15076e276f8cc5ea3d751887e586)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "enableResourcePropertyConstraint", value)
@builtins.property
@jsii.member(jsii_name="kind")
def kind(self) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: kind: The kind of kubernetes resources to query.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "kind"))
@kind.setter
def kind(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__4536bbbf4fca100108a4151bdb854293ece12374a9a604c6eb4f5b60250a5e8d)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "kind", value)
@builtins.property
@jsii.member(jsii_name="firstMatch")
def first_match(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: firstMatch: Only the first matching result in jsonpath's filtered results is returned. Default False
'''
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "firstMatch"))
@first_match.setter
def first_match(
self,
value: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__2e2bd63508859d9da831cf2c545b4bf72d80d1e73114757228f30242aeda618a)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "firstMatch", value)
@builtins.property
@jsii.member(jsii_name="jsonPath")
def json_path(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: jsonPath: Json path expression to filter the output.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "jsonPath"))
@json_path.setter
def json_path(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__d1982ca37e39880d1d0d91b063c02f3540efd3d0100787ffed1964b4bcdca36a)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "jsonPath", value)
@builtins.property
@jsii.member(jsii_name="name")
def name(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: name: The name of the kubernetes resource to query.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "name"))
@name.setter
def name(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__f0bd1a905f927a918e328aa7f34c3efad64d1ec79897e2642dcb45cae429e234)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "name", value)
@builtins.property
@jsii.member(jsii_name="namespace")
def namespace(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: namespace: The namespace of kubernetes containing the resource. Default value is default
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "namespace"))
@namespace.setter
def namespace(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__0b4e831fcfcc3c266bacee8e61900055b647a9e483743dc36e962297e3bbe9d8)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "namespace", value)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-cs.datasource.RosClusterApplicationResourcesProps",
jsii_struct_bases=[],
name_mapping={
"cluster_id": "clusterId",
"kind": "kind",
"first_match": "firstMatch",
"json_path": "jsonPath",
"name": "name",
"namespace": "namespace",
},
)
class RosClusterApplicationResourcesProps:
def __init__(
self,
*,
cluster_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
kind: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
first_match: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
json_path: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
namespace: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``DATASOURCE::CS::ClusterApplicationResources``.
:param cluster_id:
:param kind:
:param first_match:
:param json_path:
:param name:
:param namespace:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__afac1707af5d387ab35b81997080a04f80034e4329336e1349bc573c0cec3721)
check_type(argname="argument cluster_id", value=cluster_id, expected_type=type_hints["cluster_id"])
check_type(argname="argument kind", value=kind, expected_type=type_hints["kind"])
check_type(argname="argument first_match", value=first_match, expected_type=type_hints["first_match"])
check_type(argname="argument json_path", value=json_path, expected_type=type_hints["json_path"])
check_type(argname="argument name", value=name, expected_type=type_hints["name"])
check_type(argname="argument namespace", value=namespace, expected_type=type_hints["namespace"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"cluster_id": cluster_id,
"kind": kind,
}
if first_match is not None:
self._values["first_match"] = first_match
if json_path is not None:
self._values["json_path"] = json_path
if name is not None:
self._values["name"] = name
if namespace is not None:
self._values["namespace"] = namespace
@builtins.property
def cluster_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: clusterId: The ID of the kubernetes cluster.
'''
result = self._values.get("cluster_id")
assert result is not None, "Required property 'cluster_id' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def kind(self) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: kind: The kind of kubernetes resources to query.
'''
result = self._values.get("kind")
assert result is not None, "Required property 'kind' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def first_match(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: firstMatch: Only the first matching result in jsonpath's filtered results is returned. Default False
'''
result = self._values.get("first_match")
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def json_path(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: jsonPath: Json path expression to filter the output.
'''
result = self._values.get("json_path")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def name(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: name: The name of the kubernetes resource to query.
'''
result = self._values.get("name")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def namespace(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: namespace: The namespace of kubernetes containing the resource. Default value is default
'''
result = self._values.get("namespace")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "RosClusterApplicationResourcesProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class RosClusterNodePools(
_ros_cdk_core_7adfd82f.RosResource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-cs.datasource.RosClusterNodePools",
):
'''A ROS template type: ``DATASOURCE::CS::ClusterNodePools``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["RosClusterNodePoolsProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
'''Create a new ``DATASOURCE::CS::ClusterNodePools``.
:param scope: - scope in which this resource is defined.
:param id: - scoped id of the resource.
:param props: - resource properties.
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__f3c8ce05127483c67c90b8e0ebc37c9daa89505b368a7794868ca73849761732)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@jsii.member(jsii_name="renderProperties")
def _render_properties(
self,
props: typing.Mapping[builtins.str, typing.Any],
) -> typing.Mapping[builtins.str, typing.Any]:
'''
:param props: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__6bf704fa6a411230c14f65c6f06586f1e1284157aaa3f92b5c2d917d3e70d0b4)
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))
@jsii.python.classproperty
@jsii.member(jsii_name="ROS_RESOURCE_TYPE_NAME")
def ROS_RESOURCE_TYPE_NAME(cls) -> builtins.str:
'''The resource type name for this resource class.'''
return typing.cast(builtins.str, jsii.sget(cls, "ROS_RESOURCE_TYPE_NAME"))
@builtins.property
@jsii.member(jsii_name="attrNodePoolIds")
def attr_node_pool_ids(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: NodePoolIds: The list of node_pool IDs.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrNodePoolIds"))
@builtins.property
@jsii.member(jsii_name="attrNodePools")
def attr_node_pools(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: NodePools: The list of node_pools.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrNodePools"))
@builtins.property
@jsii.member(jsii_name="rosProperties")
def _ros_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "rosProperties"))
@builtins.property
@jsii.member(jsii_name="clusterId")
def cluster_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: clusterId: Cluster ID.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "clusterId"))
@cluster_id.setter
def cluster_id(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__5c72d4db1a186bb7cf0b3b2786bae4947086e531c68d8281c0c605a4f8ebbe5b)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "clusterId", value)
@builtins.property
@jsii.member(jsii_name="enableResourcePropertyConstraint")
def enable_resource_property_constraint(self) -> builtins.bool:
return typing.cast(builtins.bool, jsii.get(self, "enableResourcePropertyConstraint"))
@enable_resource_property_constraint.setter
def enable_resource_property_constraint(self, value: builtins.bool) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__6bebf0e1c00a633464a05c151501f23cd0b825105c00ee389dd20d36769c3af8)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "enableResourcePropertyConstraint", value)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-cs.datasource.RosClusterNodePoolsProps",
jsii_struct_bases=[],
name_mapping={"cluster_id": "clusterId"},
)
class RosClusterNodePoolsProps:
def __init__(
self,
*,
cluster_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
'''Properties for defining a ``DATASOURCE::CS::ClusterNodePools``.
:param cluster_id:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__932135b1bc0c9d508fdce11cb56e734b82ace28410fef956b87882e08ccee535)
check_type(argname="argument cluster_id", value=cluster_id, expected_type=type_hints["cluster_id"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"cluster_id": cluster_id,
}
@builtins.property
def cluster_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: clusterId: Cluster ID.
'''
result = self._values.get("cluster_id")
assert result is not None, "Required property 'cluster_id' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "RosClusterNodePoolsProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class RosClusterUserKubeconfig(
_ros_cdk_core_7adfd82f.RosResource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-cs.datasource.RosClusterUserKubeconfig",
):
'''A ROS template type: ``DATASOURCE::CS::ClusterUserKubeconfig``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["RosClusterUserKubeconfigProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
'''Create a new ``DATASOURCE::CS::ClusterUserKubeconfig``.
:param scope: - scope in which this resource is defined.
:param id: - scoped id of the resource.
:param props: - resource properties.
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__a629f353d0dfd35070c6d5ca3a345cc8f76b68542d6ed1f548f43fc2c5aa0e7c)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@jsii.member(jsii_name="renderProperties")
def _render_properties(
self,
props: typing.Mapping[builtins.str, typing.Any],
) -> typing.Mapping[builtins.str, typing.Any]:
'''
:param props: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__1a1eb62ffa25cdefa1b47dab5254dd58de0d06fa0dd715a9d0ea2f73c04b3db0)
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))
@jsii.python.classproperty
@jsii.member(jsii_name="ROS_RESOURCE_TYPE_NAME")
def ROS_RESOURCE_TYPE_NAME(cls) -> builtins.str:
'''The resource type name for this resource class.'''
return typing.cast(builtins.str, jsii.sget(cls, "ROS_RESOURCE_TYPE_NAME"))
@builtins.property
@jsii.member(jsii_name="attrClusterId")
def attr_cluster_id(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: ClusterId: The ID of the ACK cluster.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrClusterId"))
@builtins.property
@jsii.member(jsii_name="attrConfig")
def attr_config(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: Config: The content of the kubeconfig file.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrConfig"))
@builtins.property
@jsii.member(jsii_name="attrExpiration")
def attr_expiration(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: Expiration: The expiration time of the kubeconfig file. The value is the UTC time displayed in RFC3339 format.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrExpiration"))
@builtins.property
@jsii.member(jsii_name="rosProperties")
def _ros_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "rosProperties"))
@builtins.property
@jsii.member(jsii_name="clusterId")
def cluster_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: clusterId: The ID of the ACK cluster.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "clusterId"))
@cluster_id.setter
def cluster_id(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__35b5f8a24fec237786979b5b11be122daae4f7637eae8b510f82ac6071e9dac2)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "clusterId", value)
@builtins.property
@jsii.member(jsii_name="enableResourcePropertyConstraint")
def enable_resource_property_constraint(self) -> builtins.bool:
return typing.cast(builtins.bool, jsii.get(self, "enableResourcePropertyConstraint"))
@enable_resource_property_constraint.setter
def enable_resource_property_constraint(self, value: builtins.bool) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__6e7a6dbb8ec79d174ff4763ee7536b984bc7a3f2a914ecbba1c0e6677c0d77b4)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "enableResourcePropertyConstraint", value)
@builtins.property
@jsii.member(jsii_name="privateIpAddress")
def private_ip_address(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
privateIpAddress: Specifies whether to obtain the credential that is used to connect to the cluster over the internal network. Valid values:
true: obtains the credential that is used to connect to the cluster over the internal network.
false: obtains the credential that is used to connect to the cluster over the Internet.
Default value: false.
'''
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "privateIpAddress"))
@private_ip_address.setter
def private_ip_address(
self,
value: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__c53077713fe79cb0c8bf8a3452c701238b48510193778de52f9fe321975fc033)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "privateIpAddress", value)
@builtins.property
@jsii.member(jsii_name="temporaryDurationMinutes")
def temporary_duration_minutes(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
temporaryDurationMinutes: The validity period of a temporary kubeconfig file. Unit: minutes. Valid values: 15 to 4320.
Note If you do not specify this parameter, the system automatically specifies a validity period, which is indicated by the expiration field in the response.
'''
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "temporaryDurationMinutes"))
@temporary_duration_minutes.setter
def temporary_duration_minutes(
self,
value: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__2352167fb62b05528154fb25c28e81e83e7312f21e44fc2eef41919b54e0270b)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "temporaryDurationMinutes", value)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-cs.datasource.RosClusterUserKubeconfigProps",
jsii_struct_bases=[],
name_mapping={
"cluster_id": "clusterId",
"private_ip_address": "privateIpAddress",
"temporary_duration_minutes": "temporaryDurationMinutes",
},
)
class RosClusterUserKubeconfigProps:
def __init__(
self,
*,
cluster_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
private_ip_address: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
temporary_duration_minutes: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``DATASOURCE::CS::ClusterUserKubeconfig``.
:param cluster_id:
:param private_ip_address:
:param temporary_duration_minutes:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__06bea1361aeb73bec26f29eef2cf56636c8a40b19527c9b777175fe28742873e)
check_type(argname="argument cluster_id", value=cluster_id, expected_type=type_hints["cluster_id"])
check_type(argname="argument private_ip_address", value=private_ip_address, expected_type=type_hints["private_ip_address"])
check_type(argname="argument temporary_duration_minutes", value=temporary_duration_minutes, expected_type=type_hints["temporary_duration_minutes"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"cluster_id": cluster_id,
}
if private_ip_address is not None:
self._values["private_ip_address"] = private_ip_address
if temporary_duration_minutes is not None:
self._values["temporary_duration_minutes"] = temporary_duration_minutes
@builtins.property
def cluster_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: clusterId: The ID of the ACK cluster.
'''
result = self._values.get("cluster_id")
assert result is not None, "Required property 'cluster_id' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def private_ip_address(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
privateIpAddress: Specifies whether to obtain the credential that is used to connect to the cluster over the internal network. Valid values:
true: obtains the credential that is used to connect to the cluster over the internal network.
false: obtains the credential that is used to connect to the cluster over the Internet.
Default value: false.
'''
result = self._values.get("private_ip_address")
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def temporary_duration_minutes(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
temporaryDurationMinutes: The validity period of a temporary kubeconfig file. Unit: minutes. Valid values: 15 to 4320.
Note If you do not specify this parameter, the system automatically specifies a validity period, which is indicated by the expiration field in the response.
'''
result = self._values.get("temporary_duration_minutes")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "RosClusterUserKubeconfigProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class RosKubernetesClusters(
_ros_cdk_core_7adfd82f.RosResource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-cs.datasource.RosKubernetesClusters",
):
'''A ROS template type: ``DATASOURCE::CS::KubernetesClusters``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["RosKubernetesClustersProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
'''Create a new ``DATASOURCE::CS::KubernetesClusters``.
:param scope: - scope in which this resource is defined.
:param id: - scoped id of the resource.
:param props: - resource properties.
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__a6235bd509edf2891ab327ebac6b4ec2f5f08d727ef88b19d29e6f723db24538)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@jsii.member(jsii_name="renderProperties")
def _render_properties(
self,
props: typing.Mapping[builtins.str, typing.Any],
) -> typing.Mapping[builtins.str, typing.Any]:
'''
:param props: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__07650d4d045c9a2995e6d33c86b86a85656228f87ffc7e1fb4a17576173ce6b3)
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))
@jsii.python.classproperty
@jsii.member(jsii_name="ROS_RESOURCE_TYPE_NAME")
def ROS_RESOURCE_TYPE_NAME(cls) -> builtins.str:
'''The resource type name for this resource class.'''
return typing.cast(builtins.str, jsii.sget(cls, "ROS_RESOURCE_TYPE_NAME"))
@builtins.property
@jsii.member(jsii_name="attrClusterIds")
def attr_cluster_ids(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: ClusterIds: The list of cluster IDs.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrClusterIds"))
@builtins.property
@jsii.member(jsii_name="attrClusters")
def attr_clusters(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: Clusters: The list of clusters.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrClusters"))
@builtins.property
@jsii.member(jsii_name="rosProperties")
def _ros_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "rosProperties"))
@builtins.property
@jsii.member(jsii_name="enableResourcePropertyConstraint")
def enable_resource_property_constraint(self) -> builtins.bool:
return typing.cast(builtins.bool, jsii.get(self, "enableResourcePropertyConstraint"))
@enable_resource_property_constraint.setter
def enable_resource_property_constraint(self, value: builtins.bool) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__2e2bf767afcf09f2271690731783500d46f0e26cdf5732a2f3d45e29c832481e)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "enableResourcePropertyConstraint", value)
@builtins.property
@jsii.member(jsii_name="clusterSpec")
def cluster_spec(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
clusterSpec: The specification of the cluster. If you set the cluster type to ManagedKubernetes, you can use cluster specifications to distinguish clusters. Valid values:
ack.pro.small: professional managed Kubernetes cluster
ack.standard: standard managed Kubernetes cluster
By default, this parameter is empty. This indicates that the parameter is not used to filter clusters.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "clusterSpec"))
@cluster_spec.setter
def cluster_spec(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__182cf357c8b0c1021e0f4fc36d0390dd66e957b7f88591c5cb39af2bade40e72)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "clusterSpec", value)
@builtins.property
@jsii.member(jsii_name="clusterType")
def cluster_type(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
clusterType: The type of the cluster. Valid values:
Kubernetes: dedicated Kubernetes cluster
ManagedKubernetes: managed Kubernetes cluster, serverless Kubernetes (ASK) cluster, or edge Kubernetes cluster
Ask: ASK cluster
ExternalKubernetes: registered external cluster
When you query an ASK cluster, the value specified when the cluster was created is returned.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "clusterType"))
@cluster_type.setter
def cluster_type(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__c8efb7da7957913de0750f4b261fca3962a6a9acdd5007b3b923ac24e4582318)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "clusterType", value)
@builtins.property
@jsii.member(jsii_name="name")
def name(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: name: The name of the cluster.The name must be 1 to 63 characters in length, and can contain digits, letters, and hyphens (-). It cannot start with a hyphen (-).
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "name"))
@name.setter
def name(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__b7c526623a357f69c40fa58a1b37abe4cb831e81d05f122d15c9e9f5be9bb92e)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "name", value)
@builtins.property
@jsii.member(jsii_name="profile")
def profile(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
profile: The identifier of the cluster. If you set the cluster type to ManagedKubernetes, you can use cluster identifiers to distinguish clusters. Valid values:
Default: managed Kubernetes cluster
Serverless: ASK cluster
Edge: edge Kubernetes cluster
By default, this parameter is empty. This indicates that the parameter is not used to filter clusters.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "profile"))
@profile.setter
def profile(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__2f645c1069b082f5c2ec061a9c5c76f8d6a4d08736c8b4b5a24d89738ac961cd)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "profile", value)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-cs.datasource.RosKubernetesClustersProps",
jsii_struct_bases=[],
name_mapping={
"cluster_spec": "clusterSpec",
"cluster_type": "clusterType",
"name": "name",
"profile": "profile",
},
)
class RosKubernetesClustersProps:
def __init__(
self,
*,
cluster_spec: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
cluster_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
profile: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``DATASOURCE::CS::KubernetesClusters``.
:param cluster_spec:
:param cluster_type:
:param name:
:param profile:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__357c7542f353d4f19acbda582839ff5bf3a728a41ad9079bb5dd39e3070a3c2a)
check_type(argname="argument cluster_spec", value=cluster_spec, expected_type=type_hints["cluster_spec"])
check_type(argname="argument cluster_type", value=cluster_type, expected_type=type_hints["cluster_type"])
check_type(argname="argument name", value=name, expected_type=type_hints["name"])
check_type(argname="argument profile", value=profile, expected_type=type_hints["profile"])
self._values: typing.Dict[builtins.str, typing.Any] = {}
if cluster_spec is not None:
self._values["cluster_spec"] = cluster_spec
if cluster_type is not None:
self._values["cluster_type"] = cluster_type
if name is not None:
self._values["name"] = name
if profile is not None:
self._values["profile"] = profile
@builtins.property
def cluster_spec(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
clusterSpec: The specification of the cluster. If you set the cluster type to ManagedKubernetes, you can use cluster specifications to distinguish clusters. Valid values:
ack.pro.small: professional managed Kubernetes cluster
ack.standard: standard managed Kubernetes cluster
By default, this parameter is empty. This indicates that the parameter is not used to filter clusters.
'''
result = self._values.get("cluster_spec")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def cluster_type(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
clusterType: The type of the cluster. Valid values:
Kubernetes: dedicated Kubernetes cluster
ManagedKubernetes: managed Kubernetes cluster, serverless Kubernetes (ASK) cluster, or edge Kubernetes cluster
Ask: ASK cluster
ExternalKubernetes: registered external cluster
When you query an ASK cluster, the value specified when the cluster was created is returned.
'''
result = self._values.get("cluster_type")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def name(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: name: The name of the cluster.The name must be 1 to 63 characters in length, and can contain digits, letters, and hyphens (-). It cannot start with a hyphen (-).
'''
result = self._values.get("name")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def profile(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
profile: The identifier of the cluster. If you set the cluster type to ManagedKubernetes, you can use cluster identifiers to distinguish clusters. Valid values:
Default: managed Kubernetes cluster
Serverless: ASK cluster
Edge: edge Kubernetes cluster
By default, this parameter is empty. This indicates that the parameter is not used to filter clusters.
'''
result = self._values.get("profile")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "RosKubernetesClustersProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
__all__ = [
"ClusterApplicationResources",
"ClusterApplicationResourcesProps",
"ClusterNodePools",
"ClusterNodePoolsProps",
"ClusterUserKubeconfig",
"ClusterUserKubeconfigProps",
"KubernetesClusters",
"KubernetesClustersProps",
"RosClusterApplicationResources",
"RosClusterApplicationResourcesProps",
"RosClusterNodePools",
"RosClusterNodePoolsProps",
"RosClusterUserKubeconfig",
"RosClusterUserKubeconfigProps",
"RosKubernetesClusters",
"RosKubernetesClustersProps",
]
publication.publish()
def _typecheckingstub__293113022aca25e91d5765b13b06a36083e1f82d114b7115757e4e2546ae318c(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[ClusterApplicationResourcesProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__dc0fd0fb58ead564a98149a5b60b36741dc423967339e98c4ede2f7f5825fb61(
*,
cluster_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
kind: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
first_match: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
json_path: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
namespace: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__329818a4866ed37a9b1668c057843433c9b7f976f321a3d342f05978eb5b9cd4(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[ClusterNodePoolsProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__5acff2ff695c10bbf3b4115adc03efbddf23c8c83bed6d2002f511d7d5879f5c(
*,
cluster_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__61ce7798d06a4b415379236edc72bd24e91ec506db477a1f85d90d70939b96a3(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[ClusterUserKubeconfigProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__245a6f48f726cb8fd6ab4a508a1b778515142998b886c3fbb386e4f5e8eb7275(
*,
cluster_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
private_ip_address: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
temporary_duration_minutes: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__0e2ecdafcef2411e2b722e22406cbd2fd53e07d613859a9da0be4e55baa7cacd(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Optional[typing.Union[KubernetesClustersProps, typing.Dict[builtins.str, typing.Any]]] = None,
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__4f944cf8791691309755c0d6ffcffe02ef2e337f2dcac8886e4f761ab555e8fd(
*,
cluster_spec: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
cluster_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
profile: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__caa1f144d3a1b381378c7ced2ddc9bb997cf1c1b94151d40e53d522e38513dbd(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[RosClusterApplicationResourcesProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__2ebae1ddc6b1595741fa2c5cec130cf5ac5488287f9e8de606e4aced60935e84(
props: typing.Mapping[builtins.str, typing.Any],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__227a407d96698c49f0e1227acf43405b36fed606020879a4a71b8f088eab645b(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__8833fd062642d423b64b4ebe4e50027445ca15076e276f8cc5ea3d751887e586(
value: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__4536bbbf4fca100108a4151bdb854293ece12374a9a604c6eb4f5b60250a5e8d(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__2e2bd63508859d9da831cf2c545b4bf72d80d1e73114757228f30242aeda618a(
value: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__d1982ca37e39880d1d0d91b063c02f3540efd3d0100787ffed1964b4bcdca36a(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__f0bd1a905f927a918e328aa7f34c3efad64d1ec79897e2642dcb45cae429e234(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__0b4e831fcfcc3c266bacee8e61900055b647a9e483743dc36e962297e3bbe9d8(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__afac1707af5d387ab35b81997080a04f80034e4329336e1349bc573c0cec3721(
*,
cluster_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
kind: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
first_match: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
json_path: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
namespace: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__f3c8ce05127483c67c90b8e0ebc37c9daa89505b368a7794868ca73849761732(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[RosClusterNodePoolsProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__6bf704fa6a411230c14f65c6f06586f1e1284157aaa3f92b5c2d917d3e70d0b4(
props: typing.Mapping[builtins.str, typing.Any],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__5c72d4db1a186bb7cf0b3b2786bae4947086e531c68d8281c0c605a4f8ebbe5b(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__6bebf0e1c00a633464a05c151501f23cd0b825105c00ee389dd20d36769c3af8(
value: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__932135b1bc0c9d508fdce11cb56e734b82ace28410fef956b87882e08ccee535(
*,
cluster_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__a629f353d0dfd35070c6d5ca3a345cc8f76b68542d6ed1f548f43fc2c5aa0e7c(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[RosClusterUserKubeconfigProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__1a1eb62ffa25cdefa1b47dab5254dd58de0d06fa0dd715a9d0ea2f73c04b3db0(
props: typing.Mapping[builtins.str, typing.Any],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__35b5f8a24fec237786979b5b11be122daae4f7637eae8b510f82ac6071e9dac2(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__6e7a6dbb8ec79d174ff4763ee7536b984bc7a3f2a914ecbba1c0e6677c0d77b4(
value: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__c53077713fe79cb0c8bf8a3452c701238b48510193778de52f9fe321975fc033(
value: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__2352167fb62b05528154fb25c28e81e83e7312f21e44fc2eef41919b54e0270b(
value: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__06bea1361aeb73bec26f29eef2cf56636c8a40b19527c9b777175fe28742873e(
*,
cluster_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
private_ip_address: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
temporary_duration_minutes: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__a6235bd509edf2891ab327ebac6b4ec2f5f08d727ef88b19d29e6f723db24538(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[RosKubernetesClustersProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__07650d4d045c9a2995e6d33c86b86a85656228f87ffc7e1fb4a17576173ce6b3(
props: typing.Mapping[builtins.str, typing.Any],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__2e2bf767afcf09f2271690731783500d46f0e26cdf5732a2f3d45e29c832481e(
value: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__182cf357c8b0c1021e0f4fc36d0390dd66e957b7f88591c5cb39af2bade40e72(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__c8efb7da7957913de0750f4b261fca3962a6a9acdd5007b3b923ac24e4582318(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__b7c526623a357f69c40fa58a1b37abe4cb831e81d05f122d15c9e9f5be9bb92e(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__2f645c1069b082f5c2ec061a9c5c76f8d6a4d08736c8b4b5a24d89738ac961cd(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__357c7542f353d4f19acbda582839ff5bf3a728a41ad9079bb5dd39e3070a3c2a(
*,
cluster_spec: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
cluster_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
profile: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass | /ros-cdk-cs-1.0.17.tar.gz/ros-cdk-cs-1.0.17/src/ros_cdk_cs/datasource/__init__.py | 0.604516 | 0.174639 | __init__.py | pypi |
import abc
import builtins
import datetime
import enum
import typing
import jsii
import publication
import typing_extensions
from typeguard import check_type
from ._jsii import *
import ros_cdk_assembly_schema as _ros_cdk_assembly_schema_63fe2cdf
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-cxapi.AliyunRosStackProperties",
jsii_struct_bases=[],
name_mapping={
"template_file": "templateFile",
"parameters": "parameters",
"stack_name": "stackName",
},
)
class AliyunRosStackProperties:
def __init__(
self,
*,
template_file: builtins.str,
parameters: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
stack_name: typing.Optional[builtins.str] = None,
) -> None:
'''Artifact properties for ROS stacks.
:param template_file: A file relative to the assembly root which contains the ROS template for this stack.
:param parameters: Values for ROS stack parameters that should be passed when the stack is deployed.
:param stack_name: The name to use for the ROS stack. Default: - name derived from artifact ID
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__c02ed7b56cc2e43438298ee3508e579a38f323bf81e58eb4f9fe4cb4bce823fe)
check_type(argname="argument template_file", value=template_file, expected_type=type_hints["template_file"])
check_type(argname="argument parameters", value=parameters, expected_type=type_hints["parameters"])
check_type(argname="argument stack_name", value=stack_name, expected_type=type_hints["stack_name"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"template_file": template_file,
}
if parameters is not None:
self._values["parameters"] = parameters
if stack_name is not None:
self._values["stack_name"] = stack_name
@builtins.property
def template_file(self) -> builtins.str:
'''A file relative to the assembly root which contains the ROS template for this stack.'''
result = self._values.get("template_file")
assert result is not None, "Required property 'template_file' is missing"
return typing.cast(builtins.str, result)
@builtins.property
def parameters(self) -> typing.Optional[typing.Mapping[builtins.str, builtins.str]]:
'''Values for ROS stack parameters that should be passed when the stack is deployed.'''
result = self._values.get("parameters")
return typing.cast(typing.Optional[typing.Mapping[builtins.str, builtins.str]], result)
@builtins.property
def stack_name(self) -> typing.Optional[builtins.str]:
'''The name to use for the ROS stack.
:default: - name derived from artifact ID
'''
result = self._values.get("stack_name")
return typing.cast(typing.Optional[builtins.str], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "AliyunRosStackProperties(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-cxapi.AssemblyBuildOptions",
jsii_struct_bases=[],
name_mapping={"runtime_info": "runtimeInfo"},
)
class AssemblyBuildOptions:
def __init__(
self,
*,
runtime_info: typing.Optional[typing.Union["RuntimeInfo", typing.Dict[builtins.str, typing.Any]]] = None,
) -> None:
'''
:param runtime_info: Include the specified runtime information (module versions) in manifest. Default: - if this option is not specified, runtime info will not be included
'''
if isinstance(runtime_info, dict):
runtime_info = RuntimeInfo(**runtime_info)
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__c428fbe5fd205eae0bef5974551be51b07e9a88490dedd6a67cf54448f1ce884)
check_type(argname="argument runtime_info", value=runtime_info, expected_type=type_hints["runtime_info"])
self._values: typing.Dict[builtins.str, typing.Any] = {}
if runtime_info is not None:
self._values["runtime_info"] = runtime_info
@builtins.property
def runtime_info(self) -> typing.Optional["RuntimeInfo"]:
'''Include the specified runtime information (module versions) in manifest.
:default: - if this option is not specified, runtime info will not be included
'''
result = self._values.get("runtime_info")
return typing.cast(typing.Optional["RuntimeInfo"], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "AssemblyBuildOptions(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class CloudArtifact(
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-cxapi.CloudArtifact",
):
'''Represents an artifact within a cloud assembly.'''
def __init__(
self,
assembly: "CloudAssembly",
id: builtins.str,
*,
type: _ros_cdk_assembly_schema_63fe2cdf.ArtifactType,
dependencies: typing.Optional[typing.Sequence[builtins.str]] = None,
metadata: typing.Optional[typing.Mapping[builtins.str, typing.Sequence[typing.Union[_ros_cdk_assembly_schema_63fe2cdf.MetadataEntry, typing.Dict[builtins.str, typing.Any]]]]] = None,
properties: typing.Optional[typing.Union[typing.Union[_ros_cdk_assembly_schema_63fe2cdf.AliyunRosStackProperties, typing.Dict[builtins.str, typing.Any]], typing.Union[_ros_cdk_assembly_schema_63fe2cdf.TreeArtifactProperties, typing.Dict[builtins.str, typing.Any]], typing.Union[_ros_cdk_assembly_schema_63fe2cdf.NestedCloudAssemblyProperties, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
'''
:param assembly: -
:param id: -
:param type: The type of artifact.
:param dependencies: IDs of artifacts that must be deployed before this artifact. Default: - no dependencies.
:param metadata: Associated metadata. Default: - no metadata.
:param properties: The set of properties for this artifact (depends on type). Default: - no properties.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__1fd0b278a419cc7c82a8290aa9ee9ccbbf437c5b5d7134968e9e678dd089a5d0)
check_type(argname="argument assembly", value=assembly, expected_type=type_hints["assembly"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
manifest = _ros_cdk_assembly_schema_63fe2cdf.ArtifactManifest(
type=type,
dependencies=dependencies,
metadata=metadata,
properties=properties,
)
jsii.create(self.__class__, self, [assembly, id, manifest])
@jsii.member(jsii_name="fromManifest")
@builtins.classmethod
def from_manifest(
cls,
assembly: "CloudAssembly",
id: builtins.str,
*,
type: _ros_cdk_assembly_schema_63fe2cdf.ArtifactType,
dependencies: typing.Optional[typing.Sequence[builtins.str]] = None,
metadata: typing.Optional[typing.Mapping[builtins.str, typing.Sequence[typing.Union[_ros_cdk_assembly_schema_63fe2cdf.MetadataEntry, typing.Dict[builtins.str, typing.Any]]]]] = None,
properties: typing.Optional[typing.Union[typing.Union[_ros_cdk_assembly_schema_63fe2cdf.AliyunRosStackProperties, typing.Dict[builtins.str, typing.Any]], typing.Union[_ros_cdk_assembly_schema_63fe2cdf.TreeArtifactProperties, typing.Dict[builtins.str, typing.Any]], typing.Union[_ros_cdk_assembly_schema_63fe2cdf.NestedCloudAssemblyProperties, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> typing.Optional["CloudArtifact"]:
'''Returns a subclass of ``CloudArtifact`` based on the artifact type defined in the artifact manifest.
:param assembly: The cloud assembly from which to load the artifact.
:param id: The artifact ID.
:param type: The type of artifact.
:param dependencies: IDs of artifacts that must be deployed before this artifact. Default: - no dependencies.
:param metadata: Associated metadata. Default: - no metadata.
:param properties: The set of properties for this artifact (depends on type). Default: - no properties.
:return: the ``CloudArtifact`` that matches the artifact type or ``undefined`` if it's an artifact type that is unrecognized by this module.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__be38acca09c6a3d4ac6cc76c6234c9a24041d73b92c27272b0a1b6e699dc1f27)
check_type(argname="argument assembly", value=assembly, expected_type=type_hints["assembly"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
artifact = _ros_cdk_assembly_schema_63fe2cdf.ArtifactManifest(
type=type,
dependencies=dependencies,
metadata=metadata,
properties=properties,
)
return typing.cast(typing.Optional["CloudArtifact"], jsii.sinvoke(cls, "fromManifest", [assembly, id, artifact]))
@jsii.member(jsii_name="findMetadataByType")
def find_metadata_by_type(
self,
type: builtins.str,
) -> typing.List["MetadataEntryResult"]:
'''
:param type: -
:return: all the metadata entries of a specific type in this artifact.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__a8f2a3233d0b940b4d1131326fc03874d2dd78b2190cb926f12932641dedc71b)
check_type(argname="argument type", value=type, expected_type=type_hints["type"])
return typing.cast(typing.List["MetadataEntryResult"], jsii.invoke(self, "findMetadataByType", [type]))
@builtins.property
@jsii.member(jsii_name="assembly")
def assembly(self) -> "CloudAssembly":
return typing.cast("CloudAssembly", jsii.get(self, "assembly"))
@builtins.property
@jsii.member(jsii_name="id")
def id(self) -> builtins.str:
return typing.cast(builtins.str, jsii.get(self, "id"))
@builtins.property
@jsii.member(jsii_name="manifest")
def manifest(self) -> _ros_cdk_assembly_schema_63fe2cdf.ArtifactManifest:
'''The artifact's manifest.'''
return typing.cast(_ros_cdk_assembly_schema_63fe2cdf.ArtifactManifest, jsii.get(self, "manifest"))
@builtins.property
@jsii.member(jsii_name="messages")
def messages(self) -> typing.List["SynthesisMessage"]:
'''The set of messages extracted from the artifact's metadata.'''
return typing.cast(typing.List["SynthesisMessage"], jsii.get(self, "messages"))
@builtins.property
@jsii.member(jsii_name="dependencies")
def dependencies(self) -> typing.Optional[typing.List["CloudArtifact"]]:
'''Returns all the artifacts that this artifact depends on.'''
return typing.cast(typing.Optional[typing.List["CloudArtifact"]], jsii.get(self, "dependencies"))
class CloudAssembly(
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-cxapi.CloudAssembly",
):
'''Represents a deployable cloud application.'''
def __init__(self, directory: builtins.str) -> None:
'''Reads a cloud assembly from the specified directory.
:param directory: The root directory of the assembly.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__6fc32998cdaf053872836758c7fc414b91dd33adb0f551492b661dfb7cb9582a)
check_type(argname="argument directory", value=directory, expected_type=type_hints["directory"])
jsii.create(self.__class__, self, [directory])
@jsii.member(jsii_name="getNestedAssembly")
def get_nested_assembly(self, artifact_id: builtins.str) -> "CloudAssembly":
'''Returns a nested assembly.
:param artifact_id: The artifact ID of the nested assembly.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__4f72946b7befa08df80a014df5beeb1c4c4ead603501b0a383ea2a5f89865495)
check_type(argname="argument artifact_id", value=artifact_id, expected_type=type_hints["artifact_id"])
return typing.cast("CloudAssembly", jsii.invoke(self, "getNestedAssembly", [artifact_id]))
@jsii.member(jsii_name="getNestedAssemblyArtifact")
def get_nested_assembly_artifact(
self,
artifact_id: builtins.str,
) -> "NestedCloudAssemblyArtifact":
'''Returns a nested assembly artifact.
:param artifact_id: The artifact ID of the nested assembly.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__1f381a040192c6bc37553e4c5191411332ecd5f16170049db20de03fab74b507)
check_type(argname="argument artifact_id", value=artifact_id, expected_type=type_hints["artifact_id"])
return typing.cast("NestedCloudAssemblyArtifact", jsii.invoke(self, "getNestedAssemblyArtifact", [artifact_id]))
@jsii.member(jsii_name="getStack")
def get_stack(self, stack_name: builtins.str) -> "RosStackArtifact":
'''Returns a ROS stack artifact by name from this assembly.
Deprecated renamed to 'getStackByName' (or 'getStackArtifact(id)')
:param stack_name: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__ded5294193414eaa1d0f86c39f8c7ee2076958d3caf70331c05459880c74eeed)
check_type(argname="argument stack_name", value=stack_name, expected_type=type_hints["stack_name"])
return typing.cast("RosStackArtifact", jsii.invoke(self, "getStack", [stack_name]))
@jsii.member(jsii_name="getStackArtifact")
def get_stack_artifact(self, artifact_id: builtins.str) -> "RosStackArtifact":
'''Returns a ROS stack artifact from this assembly.
Param artifactId the artifact id of the stack (can be obtained through 'stack.artifactId').
Throws if there is no stack artifact with that id
Returns a 'RosStackArtifact' object.
:param artifact_id: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__0a5601e746b677b59fb0147c2712861e77db605cb365170c99f3dfe176b33327)
check_type(argname="argument artifact_id", value=artifact_id, expected_type=type_hints["artifact_id"])
return typing.cast("RosStackArtifact", jsii.invoke(self, "getStackArtifact", [artifact_id]))
@jsii.member(jsii_name="getStackByName")
def get_stack_by_name(self, stack_name: builtins.str) -> "RosStackArtifact":
'''Returns a ROS stack artifact from this assembly.
Will only search the current assembly.
Param stackName the name of the ROS stack.
Throws if there is no stack artifact by that name
Throws if there is more than one stack with the same stack name. You can
use 'getStackArtifact - stack.artifactId' instead.
Returns a 'RosStackArtifact' object.
:param stack_name: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__eeb03f99fef00e1295a5f99ece1e08e0da66f513918a08f156c5e503c51915cd)
check_type(argname="argument stack_name", value=stack_name, expected_type=type_hints["stack_name"])
return typing.cast("RosStackArtifact", jsii.invoke(self, "getStackByName", [stack_name]))
@jsii.member(jsii_name="tree")
def tree(self) -> typing.Optional["TreeCloudArtifact"]:
'''Returns the tree metadata artifact from this assembly.
Throws if there is no metadata artifact by that name
Returns a 'TreeCloudArtifact' object if there is one defined in the manifest, 'undefined' otherwise.
'''
return typing.cast(typing.Optional["TreeCloudArtifact"], jsii.invoke(self, "tree", []))
@jsii.member(jsii_name="tryGetArtifact")
def try_get_artifact(self, id: builtins.str) -> typing.Optional[CloudArtifact]:
'''Attempts to find an artifact with a specific identity.
Returns A 'CloudArtifact' object or 'undefined' if the artifact does not exist in this assembly.
Param id The artifact ID
:param id: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__9d7f16b827e7384c7db89d5c67b9026edf7de88a522a9504d732d134d19d7977)
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
return typing.cast(typing.Optional[CloudArtifact], jsii.invoke(self, "tryGetArtifact", [id]))
@builtins.property
@jsii.member(jsii_name="artifacts")
def artifacts(self) -> typing.List[CloudArtifact]:
'''All artifacts included in this assembly.'''
return typing.cast(typing.List[CloudArtifact], jsii.get(self, "artifacts"))
@builtins.property
@jsii.member(jsii_name="directory")
def directory(self) -> builtins.str:
'''The root directory of the cloud assembly.'''
return typing.cast(builtins.str, jsii.get(self, "directory"))
@builtins.property
@jsii.member(jsii_name="manifest")
def manifest(self) -> _ros_cdk_assembly_schema_63fe2cdf.AssemblyManifest:
'''The raw assembly manifest.'''
return typing.cast(_ros_cdk_assembly_schema_63fe2cdf.AssemblyManifest, jsii.get(self, "manifest"))
@builtins.property
@jsii.member(jsii_name="runtime")
def runtime(self) -> _ros_cdk_assembly_schema_63fe2cdf.RuntimeInfo:
'''Runtime information such as module versions used to synthesize this assembly.'''
return typing.cast(_ros_cdk_assembly_schema_63fe2cdf.RuntimeInfo, jsii.get(self, "runtime"))
@builtins.property
@jsii.member(jsii_name="stacks")
def stacks(self) -> typing.List["RosStackArtifact"]:
'''
:return: all the ROS stack artifacts that are included in this assembly.
'''
return typing.cast(typing.List["RosStackArtifact"], jsii.get(self, "stacks"))
@builtins.property
@jsii.member(jsii_name="version")
def version(self) -> builtins.str:
'''The schema version of the assembly manifest.'''
return typing.cast(builtins.str, jsii.get(self, "version"))
class CloudAssemblyBuilder(
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-cxapi.CloudAssemblyBuilder",
):
'''Can be used to build a cloud assembly.'''
def __init__(self, outdir: typing.Optional[builtins.str] = None) -> None:
'''Initializes a cloud assembly builder.
:param outdir: The output directory, uses temporary directory if undefined.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__75737a474095421951968fdd1fc84e47e73502fca3a5d0e733a24a707b927fef)
check_type(argname="argument outdir", value=outdir, expected_type=type_hints["outdir"])
jsii.create(self.__class__, self, [outdir])
@jsii.member(jsii_name="addArtifact")
def add_artifact(
self,
id: builtins.str,
*,
type: _ros_cdk_assembly_schema_63fe2cdf.ArtifactType,
dependencies: typing.Optional[typing.Sequence[builtins.str]] = None,
metadata: typing.Optional[typing.Mapping[builtins.str, typing.Sequence[typing.Union[_ros_cdk_assembly_schema_63fe2cdf.MetadataEntry, typing.Dict[builtins.str, typing.Any]]]]] = None,
properties: typing.Optional[typing.Union[typing.Union[_ros_cdk_assembly_schema_63fe2cdf.AliyunRosStackProperties, typing.Dict[builtins.str, typing.Any]], typing.Union[_ros_cdk_assembly_schema_63fe2cdf.TreeArtifactProperties, typing.Dict[builtins.str, typing.Any]], typing.Union[_ros_cdk_assembly_schema_63fe2cdf.NestedCloudAssemblyProperties, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
'''Adds an artifact into the cloud assembly.
:param id: The ID of the artifact.
:param type: The type of artifact.
:param dependencies: IDs of artifacts that must be deployed before this artifact. Default: - no dependencies.
:param metadata: Associated metadata. Default: - no metadata.
:param properties: The set of properties for this artifact (depends on type). Default: - no properties.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__37c58bea2c2cfc78a9e7a865d93058b291dc4d0394532dc0fe2f7dd1ca4de3a3)
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
manifest = _ros_cdk_assembly_schema_63fe2cdf.ArtifactManifest(
type=type,
dependencies=dependencies,
metadata=metadata,
properties=properties,
)
return typing.cast(None, jsii.invoke(self, "addArtifact", [id, manifest]))
@jsii.member(jsii_name="addMissing")
def add_missing(
self,
*,
key: builtins.str,
props: typing.Union[typing.Union[_ros_cdk_assembly_schema_63fe2cdf.AmiContextQuery, typing.Dict[builtins.str, typing.Any]], typing.Union[_ros_cdk_assembly_schema_63fe2cdf.AvailabilityZonesContextQuery, typing.Dict[builtins.str, typing.Any]], typing.Union[_ros_cdk_assembly_schema_63fe2cdf.HostedZoneContextQuery, typing.Dict[builtins.str, typing.Any]], typing.Union[_ros_cdk_assembly_schema_63fe2cdf.SSMParameterContextQuery, typing.Dict[builtins.str, typing.Any]], typing.Union[_ros_cdk_assembly_schema_63fe2cdf.VpcContextQuery, typing.Dict[builtins.str, typing.Any]], typing.Union[_ros_cdk_assembly_schema_63fe2cdf.EndpointServiceAvailabilityZonesContextQuery, typing.Dict[builtins.str, typing.Any]]],
provider: _ros_cdk_assembly_schema_63fe2cdf.ContextProvider,
) -> None:
'''Reports that some context is missing in order for this cloud assembly to be fully synthesized.
:param key: The missing context key.
:param props: A set of provider-specific options.
:param provider: The provider from which we expect this context key to be obtained.
'''
missing = _ros_cdk_assembly_schema_63fe2cdf.MissingContext(
key=key, props=props, provider=provider
)
return typing.cast(None, jsii.invoke(self, "addMissing", [missing]))
@jsii.member(jsii_name="buildAssembly")
def build_assembly(
self,
*,
runtime_info: typing.Optional[typing.Union["RuntimeInfo", typing.Dict[builtins.str, typing.Any]]] = None,
) -> CloudAssembly:
'''Finalizes the cloud assembly into the output directory returns a 'CloudAssembly' object that can be used to inspect the assembly.
:param runtime_info: Include the specified runtime information (module versions) in manifest. Default: - if this option is not specified, runtime info will not be included
'''
options = AssemblyBuildOptions(runtime_info=runtime_info)
return typing.cast(CloudAssembly, jsii.invoke(self, "buildAssembly", [options]))
@jsii.member(jsii_name="createNestedAssembly")
def create_nested_assembly(
self,
artifact_id: builtins.str,
display_name: builtins.str,
) -> "CloudAssemblyBuilder":
'''Creates a nested cloud assembly.
:param artifact_id: -
:param display_name: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__19e5e6e20d5f256f412a8fe0e0d60a4dafe9cb8b5bc81e152ff0f4d9029db1c0)
check_type(argname="argument artifact_id", value=artifact_id, expected_type=type_hints["artifact_id"])
check_type(argname="argument display_name", value=display_name, expected_type=type_hints["display_name"])
return typing.cast("CloudAssemblyBuilder", jsii.invoke(self, "createNestedAssembly", [artifact_id, display_name]))
@builtins.property
@jsii.member(jsii_name="outdir")
def outdir(self) -> builtins.str:
'''The root directory of the resulting cloud assembly.'''
return typing.cast(builtins.str, jsii.get(self, "outdir"))
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-cxapi.MetadataEntry",
jsii_struct_bases=[_ros_cdk_assembly_schema_63fe2cdf.MetadataEntry],
name_mapping={"type": "type", "data": "data", "trace": "trace"},
)
class MetadataEntry(_ros_cdk_assembly_schema_63fe2cdf.MetadataEntry):
def __init__(
self,
*,
type: builtins.str,
data: typing.Optional[typing.Union[builtins.str, typing.Sequence[typing.Union[_ros_cdk_assembly_schema_63fe2cdf.Tag, typing.Dict[builtins.str, typing.Any]]]]] = None,
trace: typing.Optional[typing.Sequence[builtins.str]] = None,
) -> None:
'''(deprecated) Backwards compatibility for when 'MetadataEntry' was defined here.
This is necessary because its used as an input in the stable
:param type: The type of the metadata entry.
:param data: The data. Default: - no data.
:param trace: A stack trace for when the entry was created. Default: - no trace.
:deprecated: moved to package 'ros-assembly-schema'
:see: core.ConstructNode.metadata
:stability: deprecated
:alicloud: /ros-cdk-core library.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__7da05f7944577a8db92b5dbb13556d9742f74b4771deeb411f0f697323831715)
check_type(argname="argument type", value=type, expected_type=type_hints["type"])
check_type(argname="argument data", value=data, expected_type=type_hints["data"])
check_type(argname="argument trace", value=trace, expected_type=type_hints["trace"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"type": type,
}
if data is not None:
self._values["data"] = data
if trace is not None:
self._values["trace"] = trace
@builtins.property
def type(self) -> builtins.str:
'''The type of the metadata entry.'''
result = self._values.get("type")
assert result is not None, "Required property 'type' is missing"
return typing.cast(builtins.str, result)
@builtins.property
def data(
self,
) -> typing.Optional[typing.Union[builtins.str, typing.List[_ros_cdk_assembly_schema_63fe2cdf.Tag]]]:
'''The data.
:default: - no data.
'''
result = self._values.get("data")
return typing.cast(typing.Optional[typing.Union[builtins.str, typing.List[_ros_cdk_assembly_schema_63fe2cdf.Tag]]], result)
@builtins.property
def trace(self) -> typing.Optional[typing.List[builtins.str]]:
'''A stack trace for when the entry was created.
:default: - no trace.
'''
result = self._values.get("trace")
return typing.cast(typing.Optional[typing.List[builtins.str]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "MetadataEntry(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-cxapi.MetadataEntryResult",
jsii_struct_bases=[_ros_cdk_assembly_schema_63fe2cdf.MetadataEntry],
name_mapping={"type": "type", "data": "data", "trace": "trace", "path": "path"},
)
class MetadataEntryResult(_ros_cdk_assembly_schema_63fe2cdf.MetadataEntry):
def __init__(
self,
*,
type: builtins.str,
data: typing.Optional[typing.Union[builtins.str, typing.Sequence[typing.Union[_ros_cdk_assembly_schema_63fe2cdf.Tag, typing.Dict[builtins.str, typing.Any]]]]] = None,
trace: typing.Optional[typing.Sequence[builtins.str]] = None,
path: builtins.str,
) -> None:
'''
:param type: The type of the metadata entry.
:param data: The data. Default: - no data.
:param trace: A stack trace for when the entry was created. Default: - no trace.
:param path: The path in which this entry was defined.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__74f95e884ce76eab45ca5e38eea872e53d87ffb47aa5b58460065832a9164559)
check_type(argname="argument type", value=type, expected_type=type_hints["type"])
check_type(argname="argument data", value=data, expected_type=type_hints["data"])
check_type(argname="argument trace", value=trace, expected_type=type_hints["trace"])
check_type(argname="argument path", value=path, expected_type=type_hints["path"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"type": type,
"path": path,
}
if data is not None:
self._values["data"] = data
if trace is not None:
self._values["trace"] = trace
@builtins.property
def type(self) -> builtins.str:
'''The type of the metadata entry.'''
result = self._values.get("type")
assert result is not None, "Required property 'type' is missing"
return typing.cast(builtins.str, result)
@builtins.property
def data(
self,
) -> typing.Optional[typing.Union[builtins.str, typing.List[_ros_cdk_assembly_schema_63fe2cdf.Tag]]]:
'''The data.
:default: - no data.
'''
result = self._values.get("data")
return typing.cast(typing.Optional[typing.Union[builtins.str, typing.List[_ros_cdk_assembly_schema_63fe2cdf.Tag]]], result)
@builtins.property
def trace(self) -> typing.Optional[typing.List[builtins.str]]:
'''A stack trace for when the entry was created.
:default: - no trace.
'''
result = self._values.get("trace")
return typing.cast(typing.Optional[typing.List[builtins.str]], result)
@builtins.property
def path(self) -> builtins.str:
'''The path in which this entry was defined.'''
result = self._values.get("path")
assert result is not None, "Required property 'path' is missing"
return typing.cast(builtins.str, result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "MetadataEntryResult(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-cxapi.MissingContext",
jsii_struct_bases=[],
name_mapping={"key": "key", "props": "props", "provider": "provider"},
)
class MissingContext:
def __init__(
self,
*,
key: builtins.str,
props: typing.Mapping[builtins.str, typing.Any],
provider: builtins.str,
) -> None:
'''(deprecated) Backwards compatibility for when 'MissingContext' was defined here.
This is necessary because its used as an input in the stable
:param key: (deprecated) The missing context key.
:param props: (deprecated) A set of provider-specific options. (This is the old untyped definition, which is necessary for backwards compatibility. See cxschema for a type definition.)
:param provider: (deprecated) The provider from which we expect this context key to be obtained. (This is the old untyped definition, which is necessary for backwards compatibility. See cxschema for a type definition.)
:deprecated: moved to package 'ros-assembly-schema'
:see: core.Stack.reportMissingContext
:stability: deprecated
:alicloud: /ros-cdk-core library.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__119f56e5e0f5a649eab50e526b8d2d6b09d418768278604c5cbad5a9e608d765)
check_type(argname="argument key", value=key, expected_type=type_hints["key"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument provider", value=provider, expected_type=type_hints["provider"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"key": key,
"props": props,
"provider": provider,
}
@builtins.property
def key(self) -> builtins.str:
'''(deprecated) The missing context key.
:stability: deprecated
'''
result = self._values.get("key")
assert result is not None, "Required property 'key' is missing"
return typing.cast(builtins.str, result)
@builtins.property
def props(self) -> typing.Mapping[builtins.str, typing.Any]:
'''(deprecated) A set of provider-specific options.
(This is the old untyped definition, which is necessary for backwards compatibility.
See cxschema for a type definition.)
:stability: deprecated
'''
result = self._values.get("props")
assert result is not None, "Required property 'props' is missing"
return typing.cast(typing.Mapping[builtins.str, typing.Any], result)
@builtins.property
def provider(self) -> builtins.str:
'''(deprecated) The provider from which we expect this context key to be obtained.
(This is the old untyped definition, which is necessary for backwards compatibility.
See cxschema for a type definition.)
:stability: deprecated
'''
result = self._values.get("provider")
assert result is not None, "Required property 'provider' is missing"
return typing.cast(builtins.str, result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "MissingContext(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class NestedCloudAssemblyArtifact(
CloudArtifact,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-cxapi.NestedCloudAssemblyArtifact",
):
'''Asset manifest is a description of a set of assets which need to be built and published.'''
def __init__(
self,
assembly: CloudAssembly,
name: builtins.str,
*,
type: _ros_cdk_assembly_schema_63fe2cdf.ArtifactType,
dependencies: typing.Optional[typing.Sequence[builtins.str]] = None,
metadata: typing.Optional[typing.Mapping[builtins.str, typing.Sequence[typing.Union[_ros_cdk_assembly_schema_63fe2cdf.MetadataEntry, typing.Dict[builtins.str, typing.Any]]]]] = None,
properties: typing.Optional[typing.Union[typing.Union[_ros_cdk_assembly_schema_63fe2cdf.AliyunRosStackProperties, typing.Dict[builtins.str, typing.Any]], typing.Union[_ros_cdk_assembly_schema_63fe2cdf.TreeArtifactProperties, typing.Dict[builtins.str, typing.Any]], typing.Union[_ros_cdk_assembly_schema_63fe2cdf.NestedCloudAssemblyProperties, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
'''
:param assembly: -
:param name: -
:param type: The type of artifact.
:param dependencies: IDs of artifacts that must be deployed before this artifact. Default: - no dependencies.
:param metadata: Associated metadata. Default: - no metadata.
:param properties: The set of properties for this artifact (depends on type). Default: - no properties.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__980fec3b47bb5d0e76aec285ce93492b22654f56c0ae965b06c0d23e34307565)
check_type(argname="argument assembly", value=assembly, expected_type=type_hints["assembly"])
check_type(argname="argument name", value=name, expected_type=type_hints["name"])
artifact = _ros_cdk_assembly_schema_63fe2cdf.ArtifactManifest(
type=type,
dependencies=dependencies,
metadata=metadata,
properties=properties,
)
jsii.create(self.__class__, self, [assembly, name, artifact])
@builtins.property
@jsii.member(jsii_name="directoryName")
def directory_name(self) -> builtins.str:
'''The relative directory name of the asset manifest.'''
return typing.cast(builtins.str, jsii.get(self, "directoryName"))
@builtins.property
@jsii.member(jsii_name="displayName")
def display_name(self) -> builtins.str:
'''Display name.'''
return typing.cast(builtins.str, jsii.get(self, "displayName"))
@builtins.property
@jsii.member(jsii_name="fullPath")
def full_path(self) -> builtins.str:
'''Full path to the nested assembly directory.'''
return typing.cast(builtins.str, jsii.get(self, "fullPath"))
@builtins.property
@jsii.member(jsii_name="nestedAssembly")
def nested_assembly(self) -> CloudAssembly:
'''The nested Assembly.'''
return typing.cast(CloudAssembly, jsii.get(self, "nestedAssembly"))
class RosStackArtifact(
CloudArtifact,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-cxapi.RosStackArtifact",
):
def __init__(
self,
assembly: CloudAssembly,
artifact_id: builtins.str,
*,
type: _ros_cdk_assembly_schema_63fe2cdf.ArtifactType,
dependencies: typing.Optional[typing.Sequence[builtins.str]] = None,
metadata: typing.Optional[typing.Mapping[builtins.str, typing.Sequence[typing.Union[_ros_cdk_assembly_schema_63fe2cdf.MetadataEntry, typing.Dict[builtins.str, typing.Any]]]]] = None,
properties: typing.Optional[typing.Union[typing.Union[_ros_cdk_assembly_schema_63fe2cdf.AliyunRosStackProperties, typing.Dict[builtins.str, typing.Any]], typing.Union[_ros_cdk_assembly_schema_63fe2cdf.TreeArtifactProperties, typing.Dict[builtins.str, typing.Any]], typing.Union[_ros_cdk_assembly_schema_63fe2cdf.NestedCloudAssemblyProperties, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
'''
:param assembly: -
:param artifact_id: -
:param type: The type of artifact.
:param dependencies: IDs of artifacts that must be deployed before this artifact. Default: - no dependencies.
:param metadata: Associated metadata. Default: - no metadata.
:param properties: The set of properties for this artifact (depends on type). Default: - no properties.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__5b1e2e9874ff423089b54d266f1b6b305028045d5dce84f26a3286f13d694ef6)
check_type(argname="argument assembly", value=assembly, expected_type=type_hints["assembly"])
check_type(argname="argument artifact_id", value=artifact_id, expected_type=type_hints["artifact_id"])
artifact = _ros_cdk_assembly_schema_63fe2cdf.ArtifactManifest(
type=type,
dependencies=dependencies,
metadata=metadata,
properties=properties,
)
jsii.create(self.__class__, self, [assembly, artifact_id, artifact])
@builtins.property
@jsii.member(jsii_name="displayName")
def display_name(self) -> builtins.str:
'''A string that represents this stack.
Should only be used in user interfaces.
If the stackName and artifactId are the same, it will just return that. Otherwise,
it will return something like " ()"
'''
return typing.cast(builtins.str, jsii.get(self, "displayName"))
@builtins.property
@jsii.member(jsii_name="name")
def name(self) -> builtins.str:
'''(deprecated) The physical name of this stack.
:deprecated: renamed to ``stackName``
:stability: deprecated
'''
return typing.cast(builtins.str, jsii.get(self, "name"))
@builtins.property
@jsii.member(jsii_name="originalName")
def original_name(self) -> builtins.str:
'''The original name as defined in the CDK app.'''
return typing.cast(builtins.str, jsii.get(self, "originalName"))
@builtins.property
@jsii.member(jsii_name="parameters")
def parameters(self) -> typing.Mapping[builtins.str, builtins.str]:
'''ROS parameters to pass to the stack.'''
return typing.cast(typing.Mapping[builtins.str, builtins.str], jsii.get(self, "parameters"))
@builtins.property
@jsii.member(jsii_name="stackName")
def stack_name(self) -> builtins.str:
'''The physical name of this stack.'''
return typing.cast(builtins.str, jsii.get(self, "stackName"))
@builtins.property
@jsii.member(jsii_name="tags")
def tags(self) -> typing.Any:
return typing.cast(typing.Any, jsii.get(self, "tags"))
@builtins.property
@jsii.member(jsii_name="template")
def template(self) -> typing.Any:
'''The ROS template for this stack.'''
return typing.cast(typing.Any, jsii.get(self, "template"))
@builtins.property
@jsii.member(jsii_name="templateFile")
def template_file(self) -> builtins.str:
'''The file name of the template.'''
return typing.cast(builtins.str, jsii.get(self, "templateFile"))
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-cxapi.RuntimeInfo",
jsii_struct_bases=[_ros_cdk_assembly_schema_63fe2cdf.RuntimeInfo],
name_mapping={"libraries": "libraries"},
)
class RuntimeInfo(_ros_cdk_assembly_schema_63fe2cdf.RuntimeInfo):
def __init__(
self,
*,
libraries: typing.Mapping[builtins.str, builtins.str],
) -> None:
'''(deprecated) Backwards compatibility for when 'RuntimeInfo' was defined here.
This is necessary because its used as an input in the stable
:param libraries: The list of libraries loaded in the application, associated with their versions.
:deprecated: moved to package 'ros-assembly-schema'
:see: core.ConstructNode.synth
:stability: deprecated
:alicloud: /ros-cdk-core library.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__b7c7ce3d847d7562d19e05aef24620874c5b871196174139f16553b6f3278590)
check_type(argname="argument libraries", value=libraries, expected_type=type_hints["libraries"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"libraries": libraries,
}
@builtins.property
def libraries(self) -> typing.Mapping[builtins.str, builtins.str]:
'''The list of libraries loaded in the application, associated with their versions.'''
result = self._values.get("libraries")
assert result is not None, "Required property 'libraries' is missing"
return typing.cast(typing.Mapping[builtins.str, builtins.str], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "RuntimeInfo(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-cxapi.SynthesisMessage",
jsii_struct_bases=[],
name_mapping={"entry": "entry", "id": "id", "level": "level"},
)
class SynthesisMessage:
def __init__(
self,
*,
entry: typing.Union[_ros_cdk_assembly_schema_63fe2cdf.MetadataEntry, typing.Dict[builtins.str, typing.Any]],
id: builtins.str,
level: "SynthesisMessageLevel",
) -> None:
'''
:param entry: -
:param id: -
:param level: -
'''
if isinstance(entry, dict):
entry = _ros_cdk_assembly_schema_63fe2cdf.MetadataEntry(**entry)
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__9585640b1217a9eeda7edf01f3a252bddc38603523313be361abe48f810ab155)
check_type(argname="argument entry", value=entry, expected_type=type_hints["entry"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument level", value=level, expected_type=type_hints["level"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"entry": entry,
"id": id,
"level": level,
}
@builtins.property
def entry(self) -> _ros_cdk_assembly_schema_63fe2cdf.MetadataEntry:
result = self._values.get("entry")
assert result is not None, "Required property 'entry' is missing"
return typing.cast(_ros_cdk_assembly_schema_63fe2cdf.MetadataEntry, result)
@builtins.property
def id(self) -> builtins.str:
result = self._values.get("id")
assert result is not None, "Required property 'id' is missing"
return typing.cast(builtins.str, result)
@builtins.property
def level(self) -> "SynthesisMessageLevel":
result = self._values.get("level")
assert result is not None, "Required property 'level' is missing"
return typing.cast("SynthesisMessageLevel", result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "SynthesisMessage(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
@jsii.enum(jsii_type="@alicloud/ros-cdk-cxapi.SynthesisMessageLevel")
class SynthesisMessageLevel(enum.Enum):
INFO = "INFO"
WARNING = "WARNING"
ERROR = "ERROR"
class TreeCloudArtifact(
CloudArtifact,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-cxapi.TreeCloudArtifact",
):
def __init__(
self,
assembly: CloudAssembly,
name: builtins.str,
*,
type: _ros_cdk_assembly_schema_63fe2cdf.ArtifactType,
dependencies: typing.Optional[typing.Sequence[builtins.str]] = None,
metadata: typing.Optional[typing.Mapping[builtins.str, typing.Sequence[typing.Union[_ros_cdk_assembly_schema_63fe2cdf.MetadataEntry, typing.Dict[builtins.str, typing.Any]]]]] = None,
properties: typing.Optional[typing.Union[typing.Union[_ros_cdk_assembly_schema_63fe2cdf.AliyunRosStackProperties, typing.Dict[builtins.str, typing.Any]], typing.Union[_ros_cdk_assembly_schema_63fe2cdf.TreeArtifactProperties, typing.Dict[builtins.str, typing.Any]], typing.Union[_ros_cdk_assembly_schema_63fe2cdf.NestedCloudAssemblyProperties, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
'''
:param assembly: -
:param name: -
:param type: The type of artifact.
:param dependencies: IDs of artifacts that must be deployed before this artifact. Default: - no dependencies.
:param metadata: Associated metadata. Default: - no metadata.
:param properties: The set of properties for this artifact (depends on type). Default: - no properties.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__8817b7cbf6cd51228f8ae6b5c4b8e9d2f166df1f66a32bea6dc2b6f738720e1f)
check_type(argname="argument assembly", value=assembly, expected_type=type_hints["assembly"])
check_type(argname="argument name", value=name, expected_type=type_hints["name"])
artifact = _ros_cdk_assembly_schema_63fe2cdf.ArtifactManifest(
type=type,
dependencies=dependencies,
metadata=metadata,
properties=properties,
)
jsii.create(self.__class__, self, [assembly, name, artifact])
@builtins.property
@jsii.member(jsii_name="file")
def file(self) -> builtins.str:
return typing.cast(builtins.str, jsii.get(self, "file"))
__all__ = [
"AliyunRosStackProperties",
"AssemblyBuildOptions",
"CloudArtifact",
"CloudAssembly",
"CloudAssemblyBuilder",
"MetadataEntry",
"MetadataEntryResult",
"MissingContext",
"NestedCloudAssemblyArtifact",
"RosStackArtifact",
"RuntimeInfo",
"SynthesisMessage",
"SynthesisMessageLevel",
"TreeCloudArtifact",
]
publication.publish()
def _typecheckingstub__c02ed7b56cc2e43438298ee3508e579a38f323bf81e58eb4f9fe4cb4bce823fe(
*,
template_file: builtins.str,
parameters: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
stack_name: typing.Optional[builtins.str] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__c428fbe5fd205eae0bef5974551be51b07e9a88490dedd6a67cf54448f1ce884(
*,
runtime_info: typing.Optional[typing.Union[RuntimeInfo, typing.Dict[builtins.str, typing.Any]]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__1fd0b278a419cc7c82a8290aa9ee9ccbbf437c5b5d7134968e9e678dd089a5d0(
assembly: CloudAssembly,
id: builtins.str,
*,
type: _ros_cdk_assembly_schema_63fe2cdf.ArtifactType,
dependencies: typing.Optional[typing.Sequence[builtins.str]] = None,
metadata: typing.Optional[typing.Mapping[builtins.str, typing.Sequence[typing.Union[_ros_cdk_assembly_schema_63fe2cdf.MetadataEntry, typing.Dict[builtins.str, typing.Any]]]]] = None,
properties: typing.Optional[typing.Union[typing.Union[_ros_cdk_assembly_schema_63fe2cdf.AliyunRosStackProperties, typing.Dict[builtins.str, typing.Any]], typing.Union[_ros_cdk_assembly_schema_63fe2cdf.TreeArtifactProperties, typing.Dict[builtins.str, typing.Any]], typing.Union[_ros_cdk_assembly_schema_63fe2cdf.NestedCloudAssemblyProperties, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__be38acca09c6a3d4ac6cc76c6234c9a24041d73b92c27272b0a1b6e699dc1f27(
assembly: CloudAssembly,
id: builtins.str,
*,
type: _ros_cdk_assembly_schema_63fe2cdf.ArtifactType,
dependencies: typing.Optional[typing.Sequence[builtins.str]] = None,
metadata: typing.Optional[typing.Mapping[builtins.str, typing.Sequence[typing.Union[_ros_cdk_assembly_schema_63fe2cdf.MetadataEntry, typing.Dict[builtins.str, typing.Any]]]]] = None,
properties: typing.Optional[typing.Union[typing.Union[_ros_cdk_assembly_schema_63fe2cdf.AliyunRosStackProperties, typing.Dict[builtins.str, typing.Any]], typing.Union[_ros_cdk_assembly_schema_63fe2cdf.TreeArtifactProperties, typing.Dict[builtins.str, typing.Any]], typing.Union[_ros_cdk_assembly_schema_63fe2cdf.NestedCloudAssemblyProperties, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__a8f2a3233d0b940b4d1131326fc03874d2dd78b2190cb926f12932641dedc71b(
type: builtins.str,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__6fc32998cdaf053872836758c7fc414b91dd33adb0f551492b661dfb7cb9582a(
directory: builtins.str,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__4f72946b7befa08df80a014df5beeb1c4c4ead603501b0a383ea2a5f89865495(
artifact_id: builtins.str,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__1f381a040192c6bc37553e4c5191411332ecd5f16170049db20de03fab74b507(
artifact_id: builtins.str,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__ded5294193414eaa1d0f86c39f8c7ee2076958d3caf70331c05459880c74eeed(
stack_name: builtins.str,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__0a5601e746b677b59fb0147c2712861e77db605cb365170c99f3dfe176b33327(
artifact_id: builtins.str,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__eeb03f99fef00e1295a5f99ece1e08e0da66f513918a08f156c5e503c51915cd(
stack_name: builtins.str,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__9d7f16b827e7384c7db89d5c67b9026edf7de88a522a9504d732d134d19d7977(
id: builtins.str,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__75737a474095421951968fdd1fc84e47e73502fca3a5d0e733a24a707b927fef(
outdir: typing.Optional[builtins.str] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__37c58bea2c2cfc78a9e7a865d93058b291dc4d0394532dc0fe2f7dd1ca4de3a3(
id: builtins.str,
*,
type: _ros_cdk_assembly_schema_63fe2cdf.ArtifactType,
dependencies: typing.Optional[typing.Sequence[builtins.str]] = None,
metadata: typing.Optional[typing.Mapping[builtins.str, typing.Sequence[typing.Union[_ros_cdk_assembly_schema_63fe2cdf.MetadataEntry, typing.Dict[builtins.str, typing.Any]]]]] = None,
properties: typing.Optional[typing.Union[typing.Union[_ros_cdk_assembly_schema_63fe2cdf.AliyunRosStackProperties, typing.Dict[builtins.str, typing.Any]], typing.Union[_ros_cdk_assembly_schema_63fe2cdf.TreeArtifactProperties, typing.Dict[builtins.str, typing.Any]], typing.Union[_ros_cdk_assembly_schema_63fe2cdf.NestedCloudAssemblyProperties, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__19e5e6e20d5f256f412a8fe0e0d60a4dafe9cb8b5bc81e152ff0f4d9029db1c0(
artifact_id: builtins.str,
display_name: builtins.str,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__7da05f7944577a8db92b5dbb13556d9742f74b4771deeb411f0f697323831715(
*,
type: builtins.str,
data: typing.Optional[typing.Union[builtins.str, typing.Sequence[typing.Union[_ros_cdk_assembly_schema_63fe2cdf.Tag, typing.Dict[builtins.str, typing.Any]]]]] = None,
trace: typing.Optional[typing.Sequence[builtins.str]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__74f95e884ce76eab45ca5e38eea872e53d87ffb47aa5b58460065832a9164559(
*,
type: builtins.str,
data: typing.Optional[typing.Union[builtins.str, typing.Sequence[typing.Union[_ros_cdk_assembly_schema_63fe2cdf.Tag, typing.Dict[builtins.str, typing.Any]]]]] = None,
trace: typing.Optional[typing.Sequence[builtins.str]] = None,
path: builtins.str,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__119f56e5e0f5a649eab50e526b8d2d6b09d418768278604c5cbad5a9e608d765(
*,
key: builtins.str,
props: typing.Mapping[builtins.str, typing.Any],
provider: builtins.str,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__980fec3b47bb5d0e76aec285ce93492b22654f56c0ae965b06c0d23e34307565(
assembly: CloudAssembly,
name: builtins.str,
*,
type: _ros_cdk_assembly_schema_63fe2cdf.ArtifactType,
dependencies: typing.Optional[typing.Sequence[builtins.str]] = None,
metadata: typing.Optional[typing.Mapping[builtins.str, typing.Sequence[typing.Union[_ros_cdk_assembly_schema_63fe2cdf.MetadataEntry, typing.Dict[builtins.str, typing.Any]]]]] = None,
properties: typing.Optional[typing.Union[typing.Union[_ros_cdk_assembly_schema_63fe2cdf.AliyunRosStackProperties, typing.Dict[builtins.str, typing.Any]], typing.Union[_ros_cdk_assembly_schema_63fe2cdf.TreeArtifactProperties, typing.Dict[builtins.str, typing.Any]], typing.Union[_ros_cdk_assembly_schema_63fe2cdf.NestedCloudAssemblyProperties, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__5b1e2e9874ff423089b54d266f1b6b305028045d5dce84f26a3286f13d694ef6(
assembly: CloudAssembly,
artifact_id: builtins.str,
*,
type: _ros_cdk_assembly_schema_63fe2cdf.ArtifactType,
dependencies: typing.Optional[typing.Sequence[builtins.str]] = None,
metadata: typing.Optional[typing.Mapping[builtins.str, typing.Sequence[typing.Union[_ros_cdk_assembly_schema_63fe2cdf.MetadataEntry, typing.Dict[builtins.str, typing.Any]]]]] = None,
properties: typing.Optional[typing.Union[typing.Union[_ros_cdk_assembly_schema_63fe2cdf.AliyunRosStackProperties, typing.Dict[builtins.str, typing.Any]], typing.Union[_ros_cdk_assembly_schema_63fe2cdf.TreeArtifactProperties, typing.Dict[builtins.str, typing.Any]], typing.Union[_ros_cdk_assembly_schema_63fe2cdf.NestedCloudAssemblyProperties, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__b7c7ce3d847d7562d19e05aef24620874c5b871196174139f16553b6f3278590(
*,
libraries: typing.Mapping[builtins.str, builtins.str],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__9585640b1217a9eeda7edf01f3a252bddc38603523313be361abe48f810ab155(
*,
entry: typing.Union[_ros_cdk_assembly_schema_63fe2cdf.MetadataEntry, typing.Dict[builtins.str, typing.Any]],
id: builtins.str,
level: SynthesisMessageLevel,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__8817b7cbf6cd51228f8ae6b5c4b8e9d2f166df1f66a32bea6dc2b6f738720e1f(
assembly: CloudAssembly,
name: builtins.str,
*,
type: _ros_cdk_assembly_schema_63fe2cdf.ArtifactType,
dependencies: typing.Optional[typing.Sequence[builtins.str]] = None,
metadata: typing.Optional[typing.Mapping[builtins.str, typing.Sequence[typing.Union[_ros_cdk_assembly_schema_63fe2cdf.MetadataEntry, typing.Dict[builtins.str, typing.Any]]]]] = None,
properties: typing.Optional[typing.Union[typing.Union[_ros_cdk_assembly_schema_63fe2cdf.AliyunRosStackProperties, typing.Dict[builtins.str, typing.Any]], typing.Union[_ros_cdk_assembly_schema_63fe2cdf.TreeArtifactProperties, typing.Dict[builtins.str, typing.Any]], typing.Union[_ros_cdk_assembly_schema_63fe2cdf.NestedCloudAssemblyProperties, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
"""Type checking stubs"""
pass | /ros-cdk-cxapi-1.0.19.tar.gz/ros-cdk-cxapi-1.0.19/src/ros_cdk_cxapi/__init__.py | 0.651466 | 0.309343 | __init__.py | pypi |
import abc
import builtins
import datetime
import enum
import typing
import jsii
import publication
import typing_extensions
from typeguard import check_type
from ._jsii import *
import ros_cdk_core as _ros_cdk_core_7adfd82f
class Domain(
_ros_cdk_core_7adfd82f.Resource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-dcdn.Domain",
):
'''A ROS resource type: ``ALIYUN::DCDN::Domain``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["DomainProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
'''Create a new ``ALIYUN::DCDN::Domain``.
Param scope - scope in which this resource is defined
Param id - scoped id of the resource
Param props - resource properties
:param scope: -
:param id: -
:param props: -
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__b81f1dac511ef72e9e9b44e7dfebe3d6c6ba84a99eb3cd19872ca4b109bbcfe6)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@builtins.property
@jsii.member(jsii_name="attrCname")
def attr_cname(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute Cname: The CNAME generated for the CDN domain.You must add a CNAME record with your DNS provider to map the CDN domain name to the CNAME.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrCname"))
@builtins.property
@jsii.member(jsii_name="attrDomainName")
def attr_domain_name(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute DomainName: The CDN domain name.
Wildcard domain names that start with periods (.) are supported. For example, .a.com.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrDomainName"))
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-dcdn.DomainProps",
jsii_struct_bases=[],
name_mapping={
"domain_name": "domainName",
"sources": "sources",
"check_url": "checkUrl",
"resource_group_id": "resourceGroupId",
"scope": "scope",
"tags": "tags",
"top_level_domain": "topLevelDomain",
},
)
class DomainProps:
def __init__(
self,
*,
domain_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
sources: typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union["RosDomain.SourcesProperty", typing.Dict[builtins.str, typing.Any]]]]],
check_url: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
resource_group_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
scope: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
tags: typing.Optional[typing.Sequence[typing.Union["RosDomain.TagsProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
top_level_domain: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::DCDN::Domain``.
:param domain_name: Property domainName: The DCDN domain name. Wildcard domain names that start with periods (.) are supported. For example, .a.com.
:param sources: Property sources: The list of origin URLs.
:param check_url: Property checkUrl: The validation of the origin.
:param resource_group_id: Property resourceGroupId: The ID of the resource group. If this is left blank, the system automatically fills in the ID of the default resource group.
:param scope: Property scope: Valid values: domestic, overseas, and global. Default value: domestic. The setting is supported for users outside mainland China, users in mainland China of level 3 or above.
:param tags: Property tags: Tags to attach to instance. Max support 20 tags to add during create instance. Each tag with two properties Key and Value, and Key is required.
:param top_level_domain: Property topLevelDomain: The top-level domain, which can only be configured by users on the whitelist.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__dd24bc8973a4454e268fba49e00b0d7e91c0ed6085eb516cf638ac66b613b70f)
check_type(argname="argument domain_name", value=domain_name, expected_type=type_hints["domain_name"])
check_type(argname="argument sources", value=sources, expected_type=type_hints["sources"])
check_type(argname="argument check_url", value=check_url, expected_type=type_hints["check_url"])
check_type(argname="argument resource_group_id", value=resource_group_id, expected_type=type_hints["resource_group_id"])
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument tags", value=tags, expected_type=type_hints["tags"])
check_type(argname="argument top_level_domain", value=top_level_domain, expected_type=type_hints["top_level_domain"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"domain_name": domain_name,
"sources": sources,
}
if check_url is not None:
self._values["check_url"] = check_url
if resource_group_id is not None:
self._values["resource_group_id"] = resource_group_id
if scope is not None:
self._values["scope"] = scope
if tags is not None:
self._values["tags"] = tags
if top_level_domain is not None:
self._values["top_level_domain"] = top_level_domain
@builtins.property
def domain_name(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property domainName: The DCDN domain name.
Wildcard domain names that start with periods (.) are supported. For example, .a.com.
'''
result = self._values.get("domain_name")
assert result is not None, "Required property 'domain_name' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def sources(
self,
) -> typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosDomain.SourcesProperty"]]]:
'''Property sources: The list of origin URLs.'''
result = self._values.get("sources")
assert result is not None, "Required property 'sources' is missing"
return typing.cast(typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosDomain.SourcesProperty"]]], result)
@builtins.property
def check_url(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property checkUrl: The validation of the origin.'''
result = self._values.get("check_url")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def resource_group_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property resourceGroupId: The ID of the resource group.
If this is left blank, the system automatically fills in the ID of the default resource group.
'''
result = self._values.get("resource_group_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def scope(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property scope: Valid values: domestic, overseas, and global.
Default value: domestic. The setting is supported for users outside mainland China, users in mainland China of level 3 or above.
'''
result = self._values.get("scope")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def tags(self) -> typing.Optional[typing.List["RosDomain.TagsProperty"]]:
'''Property tags: Tags to attach to instance.
Max support 20 tags to add during create instance. Each tag with two properties Key and Value, and Key is required.
'''
result = self._values.get("tags")
return typing.cast(typing.Optional[typing.List["RosDomain.TagsProperty"]], result)
@builtins.property
def top_level_domain(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property topLevelDomain: The top-level domain, which can only be configured by users on the whitelist.'''
result = self._values.get("top_level_domain")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "DomainProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class RosDomain(
_ros_cdk_core_7adfd82f.RosResource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-dcdn.RosDomain",
):
'''A ROS template type: ``ALIYUN::DCDN::Domain``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["RosDomainProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
'''Create a new ``ALIYUN::DCDN::Domain``.
:param scope: - scope in which this resource is defined.
:param id: - scoped id of the resource.
:param props: - resource properties.
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__e93427b1257378ea099300478892ddd93c7d73b0a051b9fa0fadabfa9e733533)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@jsii.member(jsii_name="renderProperties")
def _render_properties(
self,
props: typing.Mapping[builtins.str, typing.Any],
) -> typing.Mapping[builtins.str, typing.Any]:
'''
:param props: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__0fd65af9b9b22237b53e3fc87e40e66a058a816d29d713f0c80ab0abf159fa7c)
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))
@jsii.python.classproperty
@jsii.member(jsii_name="ROS_RESOURCE_TYPE_NAME")
def ROS_RESOURCE_TYPE_NAME(cls) -> builtins.str:
'''The resource type name for this resource class.'''
return typing.cast(builtins.str, jsii.sget(cls, "ROS_RESOURCE_TYPE_NAME"))
@builtins.property
@jsii.member(jsii_name="attrCname")
def attr_cname(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: Cname: The CNAME generated for the CDN domain.You must add a CNAME record with your DNS provider to map the CDN domain name to the CNAME.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrCname"))
@builtins.property
@jsii.member(jsii_name="attrDomainName")
def attr_domain_name(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: DomainName: The CDN domain name. Wildcard domain names that start with periods (.) are supported. For example, .a.com.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrDomainName"))
@builtins.property
@jsii.member(jsii_name="rosProperties")
def _ros_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "rosProperties"))
@builtins.property
@jsii.member(jsii_name="domainName")
def domain_name(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: domainName: The DCDN domain name. Wildcard domain names that start with periods (.) are supported. For example, .a.com.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "domainName"))
@domain_name.setter
def domain_name(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__a687b0dd8e1aed5d6308cfa591071bf0fa08c987f37fe93329073f9597d374da)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "domainName", value)
@builtins.property
@jsii.member(jsii_name="enableResourcePropertyConstraint")
def enable_resource_property_constraint(self) -> builtins.bool:
return typing.cast(builtins.bool, jsii.get(self, "enableResourcePropertyConstraint"))
@enable_resource_property_constraint.setter
def enable_resource_property_constraint(self, value: builtins.bool) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__ddc6930c4c42489586bf69cb28f0d98f3899bdce1d3975b68db0fc68c3e9f47b)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "enableResourcePropertyConstraint", value)
@builtins.property
@jsii.member(jsii_name="sources")
def sources(
self,
) -> typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosDomain.SourcesProperty"]]]:
'''
:Property: sources: The list of origin URLs.
'''
return typing.cast(typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosDomain.SourcesProperty"]]], jsii.get(self, "sources"))
@sources.setter
def sources(
self,
value: typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosDomain.SourcesProperty"]]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__bb7c9c86054350ef62ae5345269d1d1674a767f8e1633037e2fa77cf61b9c1b6)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "sources", value)
@builtins.property
@jsii.member(jsii_name="checkUrl")
def check_url(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: checkUrl: The validation of the origin.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "checkUrl"))
@check_url.setter
def check_url(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__e2b5c1352ae68a1705e0be5684253ebc66c2fb58698d376e8f6d5db6f7cfab2e)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "checkUrl", value)
@builtins.property
@jsii.member(jsii_name="resourceGroupId")
def resource_group_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: resourceGroupId: The ID of the resource group. If this is left blank, the system automatically fills in the ID of the default resource group.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "resourceGroupId"))
@resource_group_id.setter
def resource_group_id(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__26c46363e4066c306d7e0e09a35854e186625d4e1084b8670a9dabf775c04a3a)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "resourceGroupId", value)
@builtins.property
@jsii.member(jsii_name="scope")
def scope(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: scope: Valid values: domestic, overseas, and global. Default value: domestic. The setting is supported for users outside mainland China, users in mainland China of level 3 or above.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "scope"))
@scope.setter
def scope(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__bf093e567871d959152910f5f4f4084cfa0746f8f311cf191e9055ea97d73120)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "scope", value)
@builtins.property
@jsii.member(jsii_name="tags")
def tags(self) -> typing.Optional[typing.List["RosDomain.TagsProperty"]]:
'''
:Property: tags: Tags to attach to instance. Max support 20 tags to add during create instance. Each tag with two properties Key and Value, and Key is required.
'''
return typing.cast(typing.Optional[typing.List["RosDomain.TagsProperty"]], jsii.get(self, "tags"))
@tags.setter
def tags(
self,
value: typing.Optional[typing.List["RosDomain.TagsProperty"]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__e9343381cdee1d8e563bfc04abad9fc22ed1ffefa2b7d8d97689e7b677212310)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "tags", value)
@builtins.property
@jsii.member(jsii_name="topLevelDomain")
def top_level_domain(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: topLevelDomain: The top-level domain, which can only be configured by users on the whitelist.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "topLevelDomain"))
@top_level_domain.setter
def top_level_domain(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__62b11a57d58dbc12316c016f0686023ad74d7ea131d2452d2897608eb0f25ecb)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "topLevelDomain", value)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-dcdn.RosDomain.SourcesProperty",
jsii_struct_bases=[],
name_mapping={
"content": "content",
"type": "type",
"port": "port",
"priority": "priority",
"weight": "weight",
},
)
class SourcesProperty:
def __init__(
self,
*,
content: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
type: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
port: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
priority: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
weight: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''
:param content:
:param type:
:param port:
:param priority:
:param weight:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__536f52116b815fa7492cdea8c1d02bb531f271ceda4892632b8c08d58eec89ff)
check_type(argname="argument content", value=content, expected_type=type_hints["content"])
check_type(argname="argument type", value=type, expected_type=type_hints["type"])
check_type(argname="argument port", value=port, expected_type=type_hints["port"])
check_type(argname="argument priority", value=priority, expected_type=type_hints["priority"])
check_type(argname="argument weight", value=weight, expected_type=type_hints["weight"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"content": content,
"type": type,
}
if port is not None:
self._values["port"] = port
if priority is not None:
self._values["priority"] = priority
if weight is not None:
self._values["weight"] = weight
@builtins.property
def content(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: content: The address of the origin server. You can specify an IP address or a domain name.
'''
result = self._values.get("content")
assert result is not None, "Required property 'content' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def type(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
type: The type of the origin server. Valid values:
ipaddr: the IP address
domain: the domain name
oss: the endpoint of an Object Storage Service (OSS) bucket
fc_domain: the domain name of Function Compute
'''
result = self._values.get("type")
assert result is not None, "Required property 'type' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def port(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
port: The port. Valid values:
80: the default port
443: the HTTPS port
A custom port
'''
result = self._values.get("port")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def priority(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
priority: The priority of the origin server if multiple origin servers are specified. Default value: 20. Valid values:
20: the primary origin server
30: the secondary origin server
'''
result = self._values.get("priority")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def weight(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: weight: The weight of the origin server if multiple origin servers are specified. Valid values: 0 to 100. Default value: 10.
'''
result = self._values.get("weight")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "SourcesProperty(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-dcdn.RosDomain.TagsProperty",
jsii_struct_bases=[],
name_mapping={"key": "key", "value": "value"},
)
class TagsProperty:
def __init__(
self,
*,
key: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''
:param key:
:param value:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__d6ec5a4216e1c8765def52b9ee851a9e5a504d310deba563b72cdbaf578c6241)
check_type(argname="argument key", value=key, expected_type=type_hints["key"])
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"key": key,
}
if value is not None:
self._values["value"] = value
@builtins.property
def key(self) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: key: undefined
'''
result = self._values.get("key")
assert result is not None, "Required property 'key' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def value(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: value: undefined
'''
result = self._values.get("value")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "TagsProperty(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-dcdn.RosDomainProps",
jsii_struct_bases=[],
name_mapping={
"domain_name": "domainName",
"sources": "sources",
"check_url": "checkUrl",
"resource_group_id": "resourceGroupId",
"scope": "scope",
"tags": "tags",
"top_level_domain": "topLevelDomain",
},
)
class RosDomainProps:
def __init__(
self,
*,
domain_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
sources: typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union[RosDomain.SourcesProperty, typing.Dict[builtins.str, typing.Any]]]]],
check_url: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
resource_group_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
scope: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
tags: typing.Optional[typing.Sequence[typing.Union[RosDomain.TagsProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
top_level_domain: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::DCDN::Domain``.
:param domain_name:
:param sources:
:param check_url:
:param resource_group_id:
:param scope:
:param tags:
:param top_level_domain:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__d1ab345fe98664bb3acf8ce4bd2b0aac080b415bce2099ba404f7332d124a9aa)
check_type(argname="argument domain_name", value=domain_name, expected_type=type_hints["domain_name"])
check_type(argname="argument sources", value=sources, expected_type=type_hints["sources"])
check_type(argname="argument check_url", value=check_url, expected_type=type_hints["check_url"])
check_type(argname="argument resource_group_id", value=resource_group_id, expected_type=type_hints["resource_group_id"])
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument tags", value=tags, expected_type=type_hints["tags"])
check_type(argname="argument top_level_domain", value=top_level_domain, expected_type=type_hints["top_level_domain"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"domain_name": domain_name,
"sources": sources,
}
if check_url is not None:
self._values["check_url"] = check_url
if resource_group_id is not None:
self._values["resource_group_id"] = resource_group_id
if scope is not None:
self._values["scope"] = scope
if tags is not None:
self._values["tags"] = tags
if top_level_domain is not None:
self._values["top_level_domain"] = top_level_domain
@builtins.property
def domain_name(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: domainName: The DCDN domain name. Wildcard domain names that start with periods (.) are supported. For example, .a.com.
'''
result = self._values.get("domain_name")
assert result is not None, "Required property 'domain_name' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def sources(
self,
) -> typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, RosDomain.SourcesProperty]]]:
'''
:Property: sources: The list of origin URLs.
'''
result = self._values.get("sources")
assert result is not None, "Required property 'sources' is missing"
return typing.cast(typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, RosDomain.SourcesProperty]]], result)
@builtins.property
def check_url(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: checkUrl: The validation of the origin.
'''
result = self._values.get("check_url")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def resource_group_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: resourceGroupId: The ID of the resource group. If this is left blank, the system automatically fills in the ID of the default resource group.
'''
result = self._values.get("resource_group_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def scope(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: scope: Valid values: domestic, overseas, and global. Default value: domestic. The setting is supported for users outside mainland China, users in mainland China of level 3 or above.
'''
result = self._values.get("scope")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def tags(self) -> typing.Optional[typing.List[RosDomain.TagsProperty]]:
'''
:Property: tags: Tags to attach to instance. Max support 20 tags to add during create instance. Each tag with two properties Key and Value, and Key is required.
'''
result = self._values.get("tags")
return typing.cast(typing.Optional[typing.List[RosDomain.TagsProperty]], result)
@builtins.property
def top_level_domain(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: topLevelDomain: The top-level domain, which can only be configured by users on the whitelist.
'''
result = self._values.get("top_level_domain")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "RosDomainProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
__all__ = [
"Domain",
"DomainProps",
"RosDomain",
"RosDomainProps",
]
publication.publish()
def _typecheckingstub__b81f1dac511ef72e9e9b44e7dfebe3d6c6ba84a99eb3cd19872ca4b109bbcfe6(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[DomainProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__dd24bc8973a4454e268fba49e00b0d7e91c0ed6085eb516cf638ac66b613b70f(
*,
domain_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
sources: typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union[RosDomain.SourcesProperty, typing.Dict[builtins.str, typing.Any]]]]],
check_url: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
resource_group_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
scope: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
tags: typing.Optional[typing.Sequence[typing.Union[RosDomain.TagsProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
top_level_domain: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__e93427b1257378ea099300478892ddd93c7d73b0a051b9fa0fadabfa9e733533(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[RosDomainProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__0fd65af9b9b22237b53e3fc87e40e66a058a816d29d713f0c80ab0abf159fa7c(
props: typing.Mapping[builtins.str, typing.Any],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__a687b0dd8e1aed5d6308cfa591071bf0fa08c987f37fe93329073f9597d374da(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__ddc6930c4c42489586bf69cb28f0d98f3899bdce1d3975b68db0fc68c3e9f47b(
value: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__bb7c9c86054350ef62ae5345269d1d1674a767f8e1633037e2fa77cf61b9c1b6(
value: typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, RosDomain.SourcesProperty]]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__e2b5c1352ae68a1705e0be5684253ebc66c2fb58698d376e8f6d5db6f7cfab2e(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__26c46363e4066c306d7e0e09a35854e186625d4e1084b8670a9dabf775c04a3a(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__bf093e567871d959152910f5f4f4084cfa0746f8f311cf191e9055ea97d73120(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__e9343381cdee1d8e563bfc04abad9fc22ed1ffefa2b7d8d97689e7b677212310(
value: typing.Optional[typing.List[RosDomain.TagsProperty]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__62b11a57d58dbc12316c016f0686023ad74d7ea131d2452d2897608eb0f25ecb(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__536f52116b815fa7492cdea8c1d02bb531f271ceda4892632b8c08d58eec89ff(
*,
content: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
type: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
port: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
priority: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
weight: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__d6ec5a4216e1c8765def52b9ee851a9e5a504d310deba563b72cdbaf578c6241(
*,
key: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__d1ab345fe98664bb3acf8ce4bd2b0aac080b415bce2099ba404f7332d124a9aa(
*,
domain_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
sources: typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union[RosDomain.SourcesProperty, typing.Dict[builtins.str, typing.Any]]]]],
check_url: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
resource_group_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
scope: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
tags: typing.Optional[typing.Sequence[typing.Union[RosDomain.TagsProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
top_level_domain: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass | /ros-cdk-dcdn-1.0.17.tar.gz/ros-cdk-dcdn-1.0.17/src/ros_cdk_dcdn/__init__.py | 0.625896 | 0.164114 | __init__.py | pypi |
import abc
import builtins
import datetime
import enum
import typing
import jsii
import publication
import typing_extensions
from typeguard import check_type
from ._jsii import *
import ros_cdk_core as _ros_cdk_core_7adfd82f
class AccessGroup(
_ros_cdk_core_7adfd82f.Resource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-dfs.AccessGroup",
):
'''A ROS resource type: ``ALIYUN::DFS::AccessGroup``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Optional[typing.Union["AccessGroupProps", typing.Dict[builtins.str, typing.Any]]] = None,
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
'''Create a new ``ALIYUN::DFS::AccessGroup``.
Param scope - scope in which this resource is defined
Param id - scoped id of the resource
Param props - resource properties
:param scope: -
:param id: -
:param props: -
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__73c052540ab971a2f96cfab5d42147e65139b9aa7d211240c765ce87176f8bc6)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@builtins.property
@jsii.member(jsii_name="attrAccessGroupId")
def attr_access_group_id(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute AccessGroupId: The ID of the access_group.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrAccessGroupId"))
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-dfs.AccessGroupProps",
jsii_struct_bases=[],
name_mapping={
"access_group_name": "accessGroupName",
"description": "description",
"network_type": "networkType",
},
)
class AccessGroupProps:
def __init__(
self,
*,
access_group_name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
description: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
network_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::DFS::AccessGroup``.
:param access_group_name: Property accessGroupName: The Name of Access Group. The naming rules are as follows: The value contains 6 to 100 characters. Globally unique and cannot be an empty string.
:param description: Property description: The description of the access_group. The value contains 0 to 100 characters
:param network_type: Property networkType: The NetworkType of Access Group. Valid values: VPC.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__558752123512b3cd13e68ab0c6b992b9077f889bc8e59e6cb48ef51dd8e188c7)
check_type(argname="argument access_group_name", value=access_group_name, expected_type=type_hints["access_group_name"])
check_type(argname="argument description", value=description, expected_type=type_hints["description"])
check_type(argname="argument network_type", value=network_type, expected_type=type_hints["network_type"])
self._values: typing.Dict[builtins.str, typing.Any] = {}
if access_group_name is not None:
self._values["access_group_name"] = access_group_name
if description is not None:
self._values["description"] = description
if network_type is not None:
self._values["network_type"] = network_type
@builtins.property
def access_group_name(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property accessGroupName: The Name of Access Group.
The naming rules are as follows:
The value contains 6 to 100 characters.
Globally unique and cannot be an empty string.
'''
result = self._values.get("access_group_name")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def description(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property description: The description of the access_group.
The value contains 0 to 100 characters
'''
result = self._values.get("description")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def network_type(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property networkType: The NetworkType of Access Group.
Valid values: VPC.
'''
result = self._values.get("network_type")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "AccessGroupProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class AccessRule(
_ros_cdk_core_7adfd82f.Resource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-dfs.AccessRule",
):
'''A ROS resource type: ``ALIYUN::DFS::AccessRule``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["AccessRuleProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
'''Create a new ``ALIYUN::DFS::AccessRule``.
Param scope - scope in which this resource is defined
Param id - scoped id of the resource
Param props - resource properties
:param scope: -
:param id: -
:param props: -
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__c0e2a69ecea31b1dadc7561a8b4577530fd01ab3d4c1cbd1e24f1aa249711434)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@builtins.property
@jsii.member(jsii_name="attrAccessRuleId")
def attr_access_rule_id(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute AccessRuleId: The ID of the access_rule.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrAccessRuleId"))
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-dfs.AccessRuleProps",
jsii_struct_bases=[],
name_mapping={
"access_group_id": "accessGroupId",
"network_segment": "networkSegment",
"rw_access_type": "rwAccessType",
"description": "description",
"priority": "priority",
},
)
class AccessRuleProps:
def __init__(
self,
*,
access_group_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
network_segment: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
rw_access_type: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
description: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
priority: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::DFS::AccessRule``.
:param access_group_id: Property accessGroupId: The resource ID of Access Group.
:param network_segment: Property networkSegment: The NetworkSegment of the Access Rule.
:param rw_access_type: Property rwAccessType: The read/write permission of the authorized object on the file system. Values: RDWR (default) : read and write. RDONLY: read-only
:param description: Property description: The Description of the Access Rule.
:param priority: Property priority: The Priority of the Access Rule. Valid values: 1 to 100. NOTE: When multiple rules are matched by the same authorized object, the high-priority rule takes effect. 1 is the highest priority.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__47459e079bcb520873145865a6c6510e3e5effe1e0c046cb0fe27d2702bb1acd)
check_type(argname="argument access_group_id", value=access_group_id, expected_type=type_hints["access_group_id"])
check_type(argname="argument network_segment", value=network_segment, expected_type=type_hints["network_segment"])
check_type(argname="argument rw_access_type", value=rw_access_type, expected_type=type_hints["rw_access_type"])
check_type(argname="argument description", value=description, expected_type=type_hints["description"])
check_type(argname="argument priority", value=priority, expected_type=type_hints["priority"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"access_group_id": access_group_id,
"network_segment": network_segment,
"rw_access_type": rw_access_type,
}
if description is not None:
self._values["description"] = description
if priority is not None:
self._values["priority"] = priority
@builtins.property
def access_group_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property accessGroupId: The resource ID of Access Group.'''
result = self._values.get("access_group_id")
assert result is not None, "Required property 'access_group_id' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def network_segment(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property networkSegment: The NetworkSegment of the Access Rule.'''
result = self._values.get("network_segment")
assert result is not None, "Required property 'network_segment' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def rw_access_type(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property rwAccessType: The read/write permission of the authorized object on the file system.
Values:
RDWR (default) : read and write.
RDONLY: read-only
'''
result = self._values.get("rw_access_type")
assert result is not None, "Required property 'rw_access_type' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def description(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property description: The Description of the Access Rule.'''
result = self._values.get("description")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def priority(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property priority: The Priority of the Access Rule.
Valid values: 1 to 100.
NOTE: When multiple rules are matched by the same authorized object,
the high-priority rule takes effect. 1 is the highest priority.
'''
result = self._values.get("priority")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "AccessRuleProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class FileSystem(
_ros_cdk_core_7adfd82f.Resource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-dfs.FileSystem",
):
'''A ROS resource type: ``ALIYUN::DFS::FileSystem``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["FileSystemProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
'''Create a new ``ALIYUN::DFS::FileSystem``.
Param scope - scope in which this resource is defined
Param id - scoped id of the resource
Param props - resource properties
:param scope: -
:param id: -
:param props: -
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__f82f0229e516030cf3e97bb063e35ba3705b8e32189df2f38d313a64b29eb4db)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@builtins.property
@jsii.member(jsii_name="attrFileSystemId")
def attr_file_system_id(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute FileSystemId: The ID of the file system.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrFileSystemId"))
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-dfs.FileSystemProps",
jsii_struct_bases=[],
name_mapping={
"protocol_type": "protocolType",
"space_capacity": "spaceCapacity",
"storage_type": "storageType",
"zone_id": "zoneId",
"data_redundancy_type": "dataRedundancyType",
"description": "description",
"file_system_name": "fileSystemName",
"partition_number": "partitionNumber",
"provisioned_throughput_in_mi_bps": "provisionedThroughputInMiBps",
"storage_set_name": "storageSetName",
"throughput_mode": "throughputMode",
},
)
class FileSystemProps:
def __init__(
self,
*,
protocol_type: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
space_capacity: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
storage_type: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
zone_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
data_redundancy_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
description: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
file_system_name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
partition_number: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
provisioned_throughput_in_mi_bps: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
storage_set_name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
throughput_mode: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::DFS::FileSystem``.
:param protocol_type: Property protocolType: Protocol type, only support HDFS（HadoopFileSystem）.
:param space_capacity: Property spaceCapacity: Capacity of the file system. When the actual data volume reaches the file system capacity, data cannot be written. Unit: GB
:param storage_type: Property storageType: Type of storage media. Values: STANDARD (default) : standard type. PERFORMANCE: performance type.
:param zone_id: Property zoneId: zone id.
:param data_redundancy_type: Property dataRedundancyType: Redundancy mode of the file system. Values: LRS (default) : local redundancy. ZRS: in-city redundancy.
:param description: Property description: The description of the file system.
:param file_system_name: Property fileSystemName: Name of the file system. The naming rules are as follows: The value contains 6 to 100 characters. Globally unique and cannot be an empty string. The value can contain letters and digits and underscores (_).
:param partition_number: Property partitionNumber: The reserved parameters.
:param provisioned_throughput_in_mi_bps: Property provisionedThroughputInMiBps: Preset handling capacity. Unit: MB/sdata range: 1-5120
:param storage_set_name: Property storageSetName: The reserved parameters.
:param throughput_mode: Property throughputMode: Throughput mode Values: Standard（default）: standard throughputProvisioned: preset throughput.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__d76b5ec882e230aa03b7504be03cd232f8b7d06b67b8815dc293d0b7a3de1a2b)
check_type(argname="argument protocol_type", value=protocol_type, expected_type=type_hints["protocol_type"])
check_type(argname="argument space_capacity", value=space_capacity, expected_type=type_hints["space_capacity"])
check_type(argname="argument storage_type", value=storage_type, expected_type=type_hints["storage_type"])
check_type(argname="argument zone_id", value=zone_id, expected_type=type_hints["zone_id"])
check_type(argname="argument data_redundancy_type", value=data_redundancy_type, expected_type=type_hints["data_redundancy_type"])
check_type(argname="argument description", value=description, expected_type=type_hints["description"])
check_type(argname="argument file_system_name", value=file_system_name, expected_type=type_hints["file_system_name"])
check_type(argname="argument partition_number", value=partition_number, expected_type=type_hints["partition_number"])
check_type(argname="argument provisioned_throughput_in_mi_bps", value=provisioned_throughput_in_mi_bps, expected_type=type_hints["provisioned_throughput_in_mi_bps"])
check_type(argname="argument storage_set_name", value=storage_set_name, expected_type=type_hints["storage_set_name"])
check_type(argname="argument throughput_mode", value=throughput_mode, expected_type=type_hints["throughput_mode"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"protocol_type": protocol_type,
"space_capacity": space_capacity,
"storage_type": storage_type,
"zone_id": zone_id,
}
if data_redundancy_type is not None:
self._values["data_redundancy_type"] = data_redundancy_type
if description is not None:
self._values["description"] = description
if file_system_name is not None:
self._values["file_system_name"] = file_system_name
if partition_number is not None:
self._values["partition_number"] = partition_number
if provisioned_throughput_in_mi_bps is not None:
self._values["provisioned_throughput_in_mi_bps"] = provisioned_throughput_in_mi_bps
if storage_set_name is not None:
self._values["storage_set_name"] = storage_set_name
if throughput_mode is not None:
self._values["throughput_mode"] = throughput_mode
@builtins.property
def protocol_type(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property protocolType: Protocol type, only support HDFS（HadoopFileSystem）.'''
result = self._values.get("protocol_type")
assert result is not None, "Required property 'protocol_type' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def space_capacity(
self,
) -> typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property spaceCapacity: Capacity of the file system.
When the actual data volume reaches the file system capacity, data cannot be written.
Unit: GB
'''
result = self._values.get("space_capacity")
assert result is not None, "Required property 'space_capacity' is missing"
return typing.cast(typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def storage_type(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property storageType: Type of storage media.
Values:
STANDARD (default) : standard type.
PERFORMANCE: performance type.
'''
result = self._values.get("storage_type")
assert result is not None, "Required property 'storage_type' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def zone_id(self) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property zoneId: zone id.'''
result = self._values.get("zone_id")
assert result is not None, "Required property 'zone_id' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def data_redundancy_type(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property dataRedundancyType: Redundancy mode of the file system.
Values:
LRS (default) : local redundancy.
ZRS: in-city redundancy.
'''
result = self._values.get("data_redundancy_type")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def description(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property description: The description of the file system.'''
result = self._values.get("description")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def file_system_name(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property fileSystemName: Name of the file system.
The naming rules are as follows:
The value contains 6 to 100 characters.
Globally unique and cannot be an empty string.
The value can contain letters and digits and underscores (_).
'''
result = self._values.get("file_system_name")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def partition_number(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property partitionNumber: The reserved parameters.'''
result = self._values.get("partition_number")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def provisioned_throughput_in_mi_bps(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property provisionedThroughputInMiBps: Preset handling capacity.
Unit: MB/sdata range: 1-5120
'''
result = self._values.get("provisioned_throughput_in_mi_bps")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def storage_set_name(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property storageSetName: The reserved parameters.'''
result = self._values.get("storage_set_name")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def throughput_mode(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property throughputMode: Throughput mode Values: Standard（default）: standard throughputProvisioned: preset throughput.'''
result = self._values.get("throughput_mode")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "FileSystemProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class MountPoint(
_ros_cdk_core_7adfd82f.Resource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-dfs.MountPoint",
):
'''A ROS resource type: ``ALIYUN::DFS::MountPoint``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["MountPointProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
'''Create a new ``ALIYUN::DFS::MountPoint``.
Param scope - scope in which this resource is defined
Param id - scoped id of the resource
Param props - resource properties
:param scope: -
:param id: -
:param props: -
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__3f5714e8401bc7635af2b6a57290696dd00389acc1e3a87004849ff0b22103b8)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@builtins.property
@jsii.member(jsii_name="attrMountPointId")
def attr_mount_point_id(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute MountPointId: The ID of the mount point.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrMountPointId"))
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-dfs.MountPointProps",
jsii_struct_bases=[],
name_mapping={
"access_group_id": "accessGroupId",
"file_system_id": "fileSystemId",
"network_type": "networkType",
"vpc_id": "vpcId",
"v_switch_id": "vSwitchId",
"description": "description",
"status": "status",
},
)
class MountPointProps:
def __init__(
self,
*,
access_group_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
file_system_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
network_type: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
vpc_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
v_switch_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
description: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
status: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::DFS::MountPoint``.
:param access_group_id: Property accessGroupId: The ID of the Access Group.
:param file_system_id: Property fileSystemId: The ID of the File System.
:param network_type: Property networkType: The network type of the Mount Point. Valid values: VPC.
:param vpc_id: Property vpcId: The vpc id.
:param v_switch_id: Property vSwitchId: The vswitch id.
:param description: Property description: The description of the Mount Point.
:param status: Property status: The status of the Mount Point. Valid values: Active, Inactive
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__2eb9db9a539fb90f40a9e195fff14eef53a8c0adfaf7f05093ad084d5876a2d5)
check_type(argname="argument access_group_id", value=access_group_id, expected_type=type_hints["access_group_id"])
check_type(argname="argument file_system_id", value=file_system_id, expected_type=type_hints["file_system_id"])
check_type(argname="argument network_type", value=network_type, expected_type=type_hints["network_type"])
check_type(argname="argument vpc_id", value=vpc_id, expected_type=type_hints["vpc_id"])
check_type(argname="argument v_switch_id", value=v_switch_id, expected_type=type_hints["v_switch_id"])
check_type(argname="argument description", value=description, expected_type=type_hints["description"])
check_type(argname="argument status", value=status, expected_type=type_hints["status"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"access_group_id": access_group_id,
"file_system_id": file_system_id,
"network_type": network_type,
"vpc_id": vpc_id,
"v_switch_id": v_switch_id,
}
if description is not None:
self._values["description"] = description
if status is not None:
self._values["status"] = status
@builtins.property
def access_group_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property accessGroupId: The ID of the Access Group.'''
result = self._values.get("access_group_id")
assert result is not None, "Required property 'access_group_id' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def file_system_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property fileSystemId: The ID of the File System.'''
result = self._values.get("file_system_id")
assert result is not None, "Required property 'file_system_id' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def network_type(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property networkType: The network type of the Mount Point.
Valid values: VPC.
'''
result = self._values.get("network_type")
assert result is not None, "Required property 'network_type' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def vpc_id(self) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property vpcId: The vpc id.'''
result = self._values.get("vpc_id")
assert result is not None, "Required property 'vpc_id' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def v_switch_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property vSwitchId: The vswitch id.'''
result = self._values.get("v_switch_id")
assert result is not None, "Required property 'v_switch_id' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def description(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property description: The description of the Mount Point.'''
result = self._values.get("description")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def status(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property status: The status of the Mount Point.
Valid values: Active, Inactive
'''
result = self._values.get("status")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "MountPointProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class RosAccessGroup(
_ros_cdk_core_7adfd82f.RosResource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-dfs.RosAccessGroup",
):
'''A ROS template type: ``ALIYUN::DFS::AccessGroup``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["RosAccessGroupProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
'''Create a new ``ALIYUN::DFS::AccessGroup``.
:param scope: - scope in which this resource is defined.
:param id: - scoped id of the resource.
:param props: - resource properties.
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__27abbbc58e832f3799a7bec627ccf4b98afdf57a2a4c5bc188e3355f47acefc3)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@jsii.member(jsii_name="renderProperties")
def _render_properties(
self,
props: typing.Mapping[builtins.str, typing.Any],
) -> typing.Mapping[builtins.str, typing.Any]:
'''
:param props: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__fc51f5fb3fb6a8d7df6fbcc91df1840265538028201bee75626d50e21ba49e8b)
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))
@jsii.python.classproperty
@jsii.member(jsii_name="ROS_RESOURCE_TYPE_NAME")
def ROS_RESOURCE_TYPE_NAME(cls) -> builtins.str:
'''The resource type name for this resource class.'''
return typing.cast(builtins.str, jsii.sget(cls, "ROS_RESOURCE_TYPE_NAME"))
@builtins.property
@jsii.member(jsii_name="attrAccessGroupId")
def attr_access_group_id(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: AccessGroupId: The ID of the access_group.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrAccessGroupId"))
@builtins.property
@jsii.member(jsii_name="rosProperties")
def _ros_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "rosProperties"))
@builtins.property
@jsii.member(jsii_name="enableResourcePropertyConstraint")
def enable_resource_property_constraint(self) -> builtins.bool:
return typing.cast(builtins.bool, jsii.get(self, "enableResourcePropertyConstraint"))
@enable_resource_property_constraint.setter
def enable_resource_property_constraint(self, value: builtins.bool) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__6fcaac061bd3f6472d6e4b6249dab3a49665867cf1a6b2530fe4f535a0c2ecb4)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "enableResourcePropertyConstraint", value)
@builtins.property
@jsii.member(jsii_name="accessGroupName")
def access_group_name(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
accessGroupName: The Name of Access Group. The naming rules are as follows:
The value contains 6 to 100 characters.
Globally unique and cannot be an empty string.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "accessGroupName"))
@access_group_name.setter
def access_group_name(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__0c319cc24d3bc3f6868f50d63fdc99708bfd190eb1a436869e5e739b38ed7f59)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "accessGroupName", value)
@builtins.property
@jsii.member(jsii_name="description")
def description(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
description: The description of the access_group.
The value contains 0 to 100 characters
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "description"))
@description.setter
def description(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__f98db17968a1e4a0bd6d8fe244c542d27fe5d585dd02f5e27f6e223b56d4f99a)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "description", value)
@builtins.property
@jsii.member(jsii_name="networkType")
def network_type(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: networkType: The NetworkType of Access Group. Valid values: VPC.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "networkType"))
@network_type.setter
def network_type(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__c324bc0c1ac484e6788ea37b3610a29a048ce96ffc08ee73e1d70935de55e1ef)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "networkType", value)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-dfs.RosAccessGroupProps",
jsii_struct_bases=[],
name_mapping={
"access_group_name": "accessGroupName",
"description": "description",
"network_type": "networkType",
},
)
class RosAccessGroupProps:
def __init__(
self,
*,
access_group_name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
description: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
network_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::DFS::AccessGroup``.
:param access_group_name:
:param description:
:param network_type:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__0a9414a672892cb99b7f4e4e708f03a5557dace9c5b0c5cf5eb7f963c24f2daa)
check_type(argname="argument access_group_name", value=access_group_name, expected_type=type_hints["access_group_name"])
check_type(argname="argument description", value=description, expected_type=type_hints["description"])
check_type(argname="argument network_type", value=network_type, expected_type=type_hints["network_type"])
self._values: typing.Dict[builtins.str, typing.Any] = {}
if access_group_name is not None:
self._values["access_group_name"] = access_group_name
if description is not None:
self._values["description"] = description
if network_type is not None:
self._values["network_type"] = network_type
@builtins.property
def access_group_name(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
accessGroupName: The Name of Access Group. The naming rules are as follows:
The value contains 6 to 100 characters.
Globally unique and cannot be an empty string.
'''
result = self._values.get("access_group_name")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def description(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
description: The description of the access_group.
The value contains 0 to 100 characters
'''
result = self._values.get("description")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def network_type(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: networkType: The NetworkType of Access Group. Valid values: VPC.
'''
result = self._values.get("network_type")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "RosAccessGroupProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class RosAccessRule(
_ros_cdk_core_7adfd82f.RosResource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-dfs.RosAccessRule",
):
'''A ROS template type: ``ALIYUN::DFS::AccessRule``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["RosAccessRuleProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
'''Create a new ``ALIYUN::DFS::AccessRule``.
:param scope: - scope in which this resource is defined.
:param id: - scoped id of the resource.
:param props: - resource properties.
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__160727bd59c09415c83442966d19ced414e6361dc6b2d06d347c305d69603fe7)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@jsii.member(jsii_name="renderProperties")
def _render_properties(
self,
props: typing.Mapping[builtins.str, typing.Any],
) -> typing.Mapping[builtins.str, typing.Any]:
'''
:param props: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__ed12f318153c57ec1a8de7372d3fa0065032a35f7e4e183b7db82f42acc1ef51)
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))
@jsii.python.classproperty
@jsii.member(jsii_name="ROS_RESOURCE_TYPE_NAME")
def ROS_RESOURCE_TYPE_NAME(cls) -> builtins.str:
'''The resource type name for this resource class.'''
return typing.cast(builtins.str, jsii.sget(cls, "ROS_RESOURCE_TYPE_NAME"))
@builtins.property
@jsii.member(jsii_name="attrAccessRuleId")
def attr_access_rule_id(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: AccessRuleId: The ID of the access_rule.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrAccessRuleId"))
@builtins.property
@jsii.member(jsii_name="rosProperties")
def _ros_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "rosProperties"))
@builtins.property
@jsii.member(jsii_name="accessGroupId")
def access_group_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: accessGroupId: The resource ID of Access Group.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "accessGroupId"))
@access_group_id.setter
def access_group_id(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__aa1762fbcab76a94e23f8e7e5b273eccc7f294da4d06b0ce3c07592a0d4aec72)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "accessGroupId", value)
@builtins.property
@jsii.member(jsii_name="enableResourcePropertyConstraint")
def enable_resource_property_constraint(self) -> builtins.bool:
return typing.cast(builtins.bool, jsii.get(self, "enableResourcePropertyConstraint"))
@enable_resource_property_constraint.setter
def enable_resource_property_constraint(self, value: builtins.bool) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__7b271b6bd18a49ec6c611eee34e3b0e8e8897da20d333e6988923d6246e2b89a)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "enableResourcePropertyConstraint", value)
@builtins.property
@jsii.member(jsii_name="networkSegment")
def network_segment(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: networkSegment: The NetworkSegment of the Access Rule.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "networkSegment"))
@network_segment.setter
def network_segment(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__3aadcce2e425574c3f6c753334523e251aabf7e196b219030f7fd5f19023b521)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "networkSegment", value)
@builtins.property
@jsii.member(jsii_name="rwAccessType")
def rw_access_type(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
rwAccessType: The read/write permission of the authorized object on the file system.
Values:
RDWR (default) : read and write.
RDONLY: read-only
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "rwAccessType"))
@rw_access_type.setter
def rw_access_type(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__6e7aca772d7bdf4082312a8dfc8b79daee78eba45ee631c07c6f131ac0939736)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "rwAccessType", value)
@builtins.property
@jsii.member(jsii_name="description")
def description(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: description: The Description of the Access Rule.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "description"))
@description.setter
def description(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__f13f4dd3e64474da3c66e8417eeb84b613ea56a7fb831f4e22209a61c310b47b)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "description", value)
@builtins.property
@jsii.member(jsii_name="priority")
def priority(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
priority: The Priority of the Access Rule. Valid values: 1 to 100.
NOTE: When multiple rules are matched by the same authorized object,
the high-priority rule takes effect. 1 is the highest priority.
'''
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "priority"))
@priority.setter
def priority(
self,
value: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__f601054f8f2735f37d7453ea5773f98d118b5aed2b58fbebd2cce8823d35cd84)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "priority", value)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-dfs.RosAccessRuleProps",
jsii_struct_bases=[],
name_mapping={
"access_group_id": "accessGroupId",
"network_segment": "networkSegment",
"rw_access_type": "rwAccessType",
"description": "description",
"priority": "priority",
},
)
class RosAccessRuleProps:
def __init__(
self,
*,
access_group_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
network_segment: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
rw_access_type: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
description: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
priority: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::DFS::AccessRule``.
:param access_group_id:
:param network_segment:
:param rw_access_type:
:param description:
:param priority:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__a8c4ccb50a231b36ac1a735df2eb54ef3454036c12ea561df92845100c813e6f)
check_type(argname="argument access_group_id", value=access_group_id, expected_type=type_hints["access_group_id"])
check_type(argname="argument network_segment", value=network_segment, expected_type=type_hints["network_segment"])
check_type(argname="argument rw_access_type", value=rw_access_type, expected_type=type_hints["rw_access_type"])
check_type(argname="argument description", value=description, expected_type=type_hints["description"])
check_type(argname="argument priority", value=priority, expected_type=type_hints["priority"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"access_group_id": access_group_id,
"network_segment": network_segment,
"rw_access_type": rw_access_type,
}
if description is not None:
self._values["description"] = description
if priority is not None:
self._values["priority"] = priority
@builtins.property
def access_group_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: accessGroupId: The resource ID of Access Group.
'''
result = self._values.get("access_group_id")
assert result is not None, "Required property 'access_group_id' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def network_segment(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: networkSegment: The NetworkSegment of the Access Rule.
'''
result = self._values.get("network_segment")
assert result is not None, "Required property 'network_segment' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def rw_access_type(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
rwAccessType: The read/write permission of the authorized object on the file system.
Values:
RDWR (default) : read and write.
RDONLY: read-only
'''
result = self._values.get("rw_access_type")
assert result is not None, "Required property 'rw_access_type' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def description(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: description: The Description of the Access Rule.
'''
result = self._values.get("description")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def priority(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
priority: The Priority of the Access Rule. Valid values: 1 to 100.
NOTE: When multiple rules are matched by the same authorized object,
the high-priority rule takes effect. 1 is the highest priority.
'''
result = self._values.get("priority")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "RosAccessRuleProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class RosFileSystem(
_ros_cdk_core_7adfd82f.RosResource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-dfs.RosFileSystem",
):
'''A ROS template type: ``ALIYUN::DFS::FileSystem``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["RosFileSystemProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
'''Create a new ``ALIYUN::DFS::FileSystem``.
:param scope: - scope in which this resource is defined.
:param id: - scoped id of the resource.
:param props: - resource properties.
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__46fa9e89b53dc309f91a1837df04efbb293a3ac859dd47561f2f17875998750c)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@jsii.member(jsii_name="renderProperties")
def _render_properties(
self,
props: typing.Mapping[builtins.str, typing.Any],
) -> typing.Mapping[builtins.str, typing.Any]:
'''
:param props: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__54327c61aed9f6068974df8b60c4ce57b857b983a9f2350d0d678e965f8d968d)
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))
@jsii.python.classproperty
@jsii.member(jsii_name="ROS_RESOURCE_TYPE_NAME")
def ROS_RESOURCE_TYPE_NAME(cls) -> builtins.str:
'''The resource type name for this resource class.'''
return typing.cast(builtins.str, jsii.sget(cls, "ROS_RESOURCE_TYPE_NAME"))
@builtins.property
@jsii.member(jsii_name="attrFileSystemId")
def attr_file_system_id(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: FileSystemId: The ID of the file system.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrFileSystemId"))
@builtins.property
@jsii.member(jsii_name="rosProperties")
def _ros_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "rosProperties"))
@builtins.property
@jsii.member(jsii_name="enableResourcePropertyConstraint")
def enable_resource_property_constraint(self) -> builtins.bool:
return typing.cast(builtins.bool, jsii.get(self, "enableResourcePropertyConstraint"))
@enable_resource_property_constraint.setter
def enable_resource_property_constraint(self, value: builtins.bool) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__96a421f6fd6e2ed5fa7cf3d33d1b0ef018c12facb4a337fcf9332a195af1f372)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "enableResourcePropertyConstraint", value)
@builtins.property
@jsii.member(jsii_name="protocolType")
def protocol_type(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: protocolType: Protocol type, only support HDFS（HadoopFileSystem）
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "protocolType"))
@protocol_type.setter
def protocol_type(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__eb0182f72e1731033c9f41b89fdc172be0d396d1d4fae7a3aff80ef090e0dea9)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "protocolType", value)
@builtins.property
@jsii.member(jsii_name="spaceCapacity")
def space_capacity(
self,
) -> typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
spaceCapacity: Capacity of the file system.
When the actual data volume reaches the file system capacity, data cannot be written.
Unit: GB
'''
return typing.cast(typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "spaceCapacity"))
@space_capacity.setter
def space_capacity(
self,
value: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__659062943baea179ce7ba2b1906195b712bbed9d1cf9405ef2295fbdfddb6360)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "spaceCapacity", value)
@builtins.property
@jsii.member(jsii_name="storageType")
def storage_type(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
storageType: Type of storage media.
Values:
STANDARD (default) : standard type.
PERFORMANCE: performance type.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "storageType"))
@storage_type.setter
def storage_type(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__f260fae1636553c4f0abea693f7ef94b30d869a261266f0b1eefdf277759d2cc)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "storageType", value)
@builtins.property
@jsii.member(jsii_name="zoneId")
def zone_id(self) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: zoneId: zone id
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "zoneId"))
@zone_id.setter
def zone_id(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__085f930a87908cf5c71b2068b79d6b47fe88cefa4ebd70bb02ccc2cb09cfb6c1)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "zoneId", value)
@builtins.property
@jsii.member(jsii_name="dataRedundancyType")
def data_redundancy_type(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
dataRedundancyType: Redundancy mode of the file system.
Values:
LRS (default) : local redundancy.
ZRS: in-city redundancy.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "dataRedundancyType"))
@data_redundancy_type.setter
def data_redundancy_type(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__f1cb47b9456683535235324b73d162f1d5f098415de6cfce295bf700cec49f22)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "dataRedundancyType", value)
@builtins.property
@jsii.member(jsii_name="description")
def description(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: description: The description of the file system.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "description"))
@description.setter
def description(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__524d4f8ccbc28355a1aa2995d78a35a3300850b73be31dfd05d4a32f37634149)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "description", value)
@builtins.property
@jsii.member(jsii_name="fileSystemName")
def file_system_name(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
fileSystemName: Name of the file system. The naming rules are as follows:
The value contains 6 to 100 characters.
Globally unique and cannot be an empty string.
The value can contain letters and digits and underscores (_).
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "fileSystemName"))
@file_system_name.setter
def file_system_name(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__0dd88983ca6dc04f58ee4ac89b505c17696e607be515d894eb8433602b4097c6)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "fileSystemName", value)
@builtins.property
@jsii.member(jsii_name="partitionNumber")
def partition_number(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: partitionNumber: The reserved parameters
'''
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "partitionNumber"))
@partition_number.setter
def partition_number(
self,
value: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__4b429f48fa9072ea853ae47ca86a83ce4b6aa9d8a410ffcedc706ccfc897eadd)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "partitionNumber", value)
@builtins.property
@jsii.member(jsii_name="provisionedThroughputInMiBps")
def provisioned_throughput_in_mi_bps(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
provisionedThroughputInMiBps: Preset handling capacity.
Unit: MB/sdata range: 1-5120
'''
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "provisionedThroughputInMiBps"))
@provisioned_throughput_in_mi_bps.setter
def provisioned_throughput_in_mi_bps(
self,
value: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__bc438e3586dcc672ad967091e6f5f61a1dfe5bb056be57ae76411fb087ca6ec4)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "provisionedThroughputInMiBps", value)
@builtins.property
@jsii.member(jsii_name="storageSetName")
def storage_set_name(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: storageSetName: The reserved parameters.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "storageSetName"))
@storage_set_name.setter
def storage_set_name(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__0a54fb4d30a45751d57323086917980be2cb61ebd64bcae6bbdc64607adee3bb)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "storageSetName", value)
@builtins.property
@jsii.member(jsii_name="throughputMode")
def throughput_mode(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
throughputMode: Throughput mode
Values:
Standard（default）: standard throughputProvisioned: preset throughput
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "throughputMode"))
@throughput_mode.setter
def throughput_mode(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__e1f59d907e6e277537d752abf36a03cf2a10a4dbd428fae8d4474c483d6a83a8)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "throughputMode", value)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-dfs.RosFileSystemProps",
jsii_struct_bases=[],
name_mapping={
"protocol_type": "protocolType",
"space_capacity": "spaceCapacity",
"storage_type": "storageType",
"zone_id": "zoneId",
"data_redundancy_type": "dataRedundancyType",
"description": "description",
"file_system_name": "fileSystemName",
"partition_number": "partitionNumber",
"provisioned_throughput_in_mi_bps": "provisionedThroughputInMiBps",
"storage_set_name": "storageSetName",
"throughput_mode": "throughputMode",
},
)
class RosFileSystemProps:
def __init__(
self,
*,
protocol_type: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
space_capacity: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
storage_type: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
zone_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
data_redundancy_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
description: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
file_system_name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
partition_number: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
provisioned_throughput_in_mi_bps: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
storage_set_name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
throughput_mode: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::DFS::FileSystem``.
:param protocol_type:
:param space_capacity:
:param storage_type:
:param zone_id:
:param data_redundancy_type:
:param description:
:param file_system_name:
:param partition_number:
:param provisioned_throughput_in_mi_bps:
:param storage_set_name:
:param throughput_mode:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__6fbd2d15773b762baff0c0bedc60f9850811649a973fcbe698fa473fc676d14e)
check_type(argname="argument protocol_type", value=protocol_type, expected_type=type_hints["protocol_type"])
check_type(argname="argument space_capacity", value=space_capacity, expected_type=type_hints["space_capacity"])
check_type(argname="argument storage_type", value=storage_type, expected_type=type_hints["storage_type"])
check_type(argname="argument zone_id", value=zone_id, expected_type=type_hints["zone_id"])
check_type(argname="argument data_redundancy_type", value=data_redundancy_type, expected_type=type_hints["data_redundancy_type"])
check_type(argname="argument description", value=description, expected_type=type_hints["description"])
check_type(argname="argument file_system_name", value=file_system_name, expected_type=type_hints["file_system_name"])
check_type(argname="argument partition_number", value=partition_number, expected_type=type_hints["partition_number"])
check_type(argname="argument provisioned_throughput_in_mi_bps", value=provisioned_throughput_in_mi_bps, expected_type=type_hints["provisioned_throughput_in_mi_bps"])
check_type(argname="argument storage_set_name", value=storage_set_name, expected_type=type_hints["storage_set_name"])
check_type(argname="argument throughput_mode", value=throughput_mode, expected_type=type_hints["throughput_mode"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"protocol_type": protocol_type,
"space_capacity": space_capacity,
"storage_type": storage_type,
"zone_id": zone_id,
}
if data_redundancy_type is not None:
self._values["data_redundancy_type"] = data_redundancy_type
if description is not None:
self._values["description"] = description
if file_system_name is not None:
self._values["file_system_name"] = file_system_name
if partition_number is not None:
self._values["partition_number"] = partition_number
if provisioned_throughput_in_mi_bps is not None:
self._values["provisioned_throughput_in_mi_bps"] = provisioned_throughput_in_mi_bps
if storage_set_name is not None:
self._values["storage_set_name"] = storage_set_name
if throughput_mode is not None:
self._values["throughput_mode"] = throughput_mode
@builtins.property
def protocol_type(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: protocolType: Protocol type, only support HDFS（HadoopFileSystem）
'''
result = self._values.get("protocol_type")
assert result is not None, "Required property 'protocol_type' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def space_capacity(
self,
) -> typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
spaceCapacity: Capacity of the file system.
When the actual data volume reaches the file system capacity, data cannot be written.
Unit: GB
'''
result = self._values.get("space_capacity")
assert result is not None, "Required property 'space_capacity' is missing"
return typing.cast(typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def storage_type(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
storageType: Type of storage media.
Values:
STANDARD (default) : standard type.
PERFORMANCE: performance type.
'''
result = self._values.get("storage_type")
assert result is not None, "Required property 'storage_type' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def zone_id(self) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: zoneId: zone id
'''
result = self._values.get("zone_id")
assert result is not None, "Required property 'zone_id' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def data_redundancy_type(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
dataRedundancyType: Redundancy mode of the file system.
Values:
LRS (default) : local redundancy.
ZRS: in-city redundancy.
'''
result = self._values.get("data_redundancy_type")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def description(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: description: The description of the file system.
'''
result = self._values.get("description")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def file_system_name(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
fileSystemName: Name of the file system. The naming rules are as follows:
The value contains 6 to 100 characters.
Globally unique and cannot be an empty string.
The value can contain letters and digits and underscores (_).
'''
result = self._values.get("file_system_name")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def partition_number(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: partitionNumber: The reserved parameters
'''
result = self._values.get("partition_number")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def provisioned_throughput_in_mi_bps(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
provisionedThroughputInMiBps: Preset handling capacity.
Unit: MB/sdata range: 1-5120
'''
result = self._values.get("provisioned_throughput_in_mi_bps")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def storage_set_name(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: storageSetName: The reserved parameters.
'''
result = self._values.get("storage_set_name")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def throughput_mode(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
throughputMode: Throughput mode
Values:
Standard（default）: standard throughputProvisioned: preset throughput
'''
result = self._values.get("throughput_mode")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "RosFileSystemProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class RosMountPoint(
_ros_cdk_core_7adfd82f.RosResource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-dfs.RosMountPoint",
):
'''A ROS template type: ``ALIYUN::DFS::MountPoint``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["RosMountPointProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
'''Create a new ``ALIYUN::DFS::MountPoint``.
:param scope: - scope in which this resource is defined.
:param id: - scoped id of the resource.
:param props: - resource properties.
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__b3eb07d230db865859a6a96488827ced9a0c4b10bf2f27bf2c9eb3c065cbbfff)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@jsii.member(jsii_name="renderProperties")
def _render_properties(
self,
props: typing.Mapping[builtins.str, typing.Any],
) -> typing.Mapping[builtins.str, typing.Any]:
'''
:param props: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__123a11d632307eac1b57a5ada40b44812f52bbce317568422fd9b7bd42a8f00d)
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))
@jsii.python.classproperty
@jsii.member(jsii_name="ROS_RESOURCE_TYPE_NAME")
def ROS_RESOURCE_TYPE_NAME(cls) -> builtins.str:
'''The resource type name for this resource class.'''
return typing.cast(builtins.str, jsii.sget(cls, "ROS_RESOURCE_TYPE_NAME"))
@builtins.property
@jsii.member(jsii_name="attrMountPointId")
def attr_mount_point_id(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: MountPointId: The ID of the mount point.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrMountPointId"))
@builtins.property
@jsii.member(jsii_name="rosProperties")
def _ros_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "rosProperties"))
@builtins.property
@jsii.member(jsii_name="accessGroupId")
def access_group_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: accessGroupId: The ID of the Access Group.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "accessGroupId"))
@access_group_id.setter
def access_group_id(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__3c012c06baa6d6ea6451af8b964d65a724864edb14ffb5c789de4db2524ceced)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "accessGroupId", value)
@builtins.property
@jsii.member(jsii_name="enableResourcePropertyConstraint")
def enable_resource_property_constraint(self) -> builtins.bool:
return typing.cast(builtins.bool, jsii.get(self, "enableResourcePropertyConstraint"))
@enable_resource_property_constraint.setter
def enable_resource_property_constraint(self, value: builtins.bool) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__7477de7d7fddee61ea3e0c571867b8060e866da8ed89fa60e9f934bface13d57)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "enableResourcePropertyConstraint", value)
@builtins.property
@jsii.member(jsii_name="fileSystemId")
def file_system_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: fileSystemId: The ID of the File System.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "fileSystemId"))
@file_system_id.setter
def file_system_id(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__5cde256c454934ce6d59865acce9c550bd31e3c0dc9fd1245c2808352cfc4717)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "fileSystemId", value)
@builtins.property
@jsii.member(jsii_name="networkType")
def network_type(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: networkType: The network type of the Mount Point. Valid values: VPC.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "networkType"))
@network_type.setter
def network_type(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__0b1963f90083d69107d9be65ec900d2bd615442b59af26482632f9638ed3bb9a)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "networkType", value)
@builtins.property
@jsii.member(jsii_name="vpcId")
def vpc_id(self) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: vpcId: The vpc id.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "vpcId"))
@vpc_id.setter
def vpc_id(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__67c091a5f1c424210a112345cdee71508c16130cf48a4bfb18eb5eacbddf921b)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "vpcId", value)
@builtins.property
@jsii.member(jsii_name="vSwitchId")
def v_switch_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: vSwitchId: The vswitch id.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "vSwitchId"))
@v_switch_id.setter
def v_switch_id(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__747b99a2fcbd38851486c41a40ae3de5db36fe1696d2e1ebd3adc7de0d343afb)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "vSwitchId", value)
@builtins.property
@jsii.member(jsii_name="description")
def description(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: description: The description of the Mount Point.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "description"))
@description.setter
def description(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__e3d4446cd8573ee6aef2b227e69758e0c822de91e7f989526baea921ef151f6b)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "description", value)
@builtins.property
@jsii.member(jsii_name="status")
def status(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
status: The status of the Mount Point.
Valid values: Active, Inactive
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "status"))
@status.setter
def status(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__2cb468b54e7b3eae3dfdf825547a482f07c1fc45d5ef2f6c01f201bad860c7f6)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "status", value)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-dfs.RosMountPointProps",
jsii_struct_bases=[],
name_mapping={
"access_group_id": "accessGroupId",
"file_system_id": "fileSystemId",
"network_type": "networkType",
"vpc_id": "vpcId",
"v_switch_id": "vSwitchId",
"description": "description",
"status": "status",
},
)
class RosMountPointProps:
def __init__(
self,
*,
access_group_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
file_system_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
network_type: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
vpc_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
v_switch_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
description: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
status: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::DFS::MountPoint``.
:param access_group_id:
:param file_system_id:
:param network_type:
:param vpc_id:
:param v_switch_id:
:param description:
:param status:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__946c0a4e14423ad01302ddb4da3049f9f2eb0d9d84b988bc20d83cb195ea966b)
check_type(argname="argument access_group_id", value=access_group_id, expected_type=type_hints["access_group_id"])
check_type(argname="argument file_system_id", value=file_system_id, expected_type=type_hints["file_system_id"])
check_type(argname="argument network_type", value=network_type, expected_type=type_hints["network_type"])
check_type(argname="argument vpc_id", value=vpc_id, expected_type=type_hints["vpc_id"])
check_type(argname="argument v_switch_id", value=v_switch_id, expected_type=type_hints["v_switch_id"])
check_type(argname="argument description", value=description, expected_type=type_hints["description"])
check_type(argname="argument status", value=status, expected_type=type_hints["status"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"access_group_id": access_group_id,
"file_system_id": file_system_id,
"network_type": network_type,
"vpc_id": vpc_id,
"v_switch_id": v_switch_id,
}
if description is not None:
self._values["description"] = description
if status is not None:
self._values["status"] = status
@builtins.property
def access_group_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: accessGroupId: The ID of the Access Group.
'''
result = self._values.get("access_group_id")
assert result is not None, "Required property 'access_group_id' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def file_system_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: fileSystemId: The ID of the File System.
'''
result = self._values.get("file_system_id")
assert result is not None, "Required property 'file_system_id' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def network_type(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: networkType: The network type of the Mount Point. Valid values: VPC.
'''
result = self._values.get("network_type")
assert result is not None, "Required property 'network_type' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def vpc_id(self) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: vpcId: The vpc id.
'''
result = self._values.get("vpc_id")
assert result is not None, "Required property 'vpc_id' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def v_switch_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: vSwitchId: The vswitch id.
'''
result = self._values.get("v_switch_id")
assert result is not None, "Required property 'v_switch_id' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def description(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: description: The description of the Mount Point.
'''
result = self._values.get("description")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def status(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
status: The status of the Mount Point.
Valid values: Active, Inactive
'''
result = self._values.get("status")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "RosMountPointProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
__all__ = [
"AccessGroup",
"AccessGroupProps",
"AccessRule",
"AccessRuleProps",
"FileSystem",
"FileSystemProps",
"MountPoint",
"MountPointProps",
"RosAccessGroup",
"RosAccessGroupProps",
"RosAccessRule",
"RosAccessRuleProps",
"RosFileSystem",
"RosFileSystemProps",
"RosMountPoint",
"RosMountPointProps",
]
publication.publish()
def _typecheckingstub__73c052540ab971a2f96cfab5d42147e65139b9aa7d211240c765ce87176f8bc6(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Optional[typing.Union[AccessGroupProps, typing.Dict[builtins.str, typing.Any]]] = None,
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__558752123512b3cd13e68ab0c6b992b9077f889bc8e59e6cb48ef51dd8e188c7(
*,
access_group_name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
description: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
network_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__c0e2a69ecea31b1dadc7561a8b4577530fd01ab3d4c1cbd1e24f1aa249711434(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[AccessRuleProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__47459e079bcb520873145865a6c6510e3e5effe1e0c046cb0fe27d2702bb1acd(
*,
access_group_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
network_segment: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
rw_access_type: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
description: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
priority: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__f82f0229e516030cf3e97bb063e35ba3705b8e32189df2f38d313a64b29eb4db(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[FileSystemProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__d76b5ec882e230aa03b7504be03cd232f8b7d06b67b8815dc293d0b7a3de1a2b(
*,
protocol_type: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
space_capacity: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
storage_type: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
zone_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
data_redundancy_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
description: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
file_system_name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
partition_number: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
provisioned_throughput_in_mi_bps: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
storage_set_name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
throughput_mode: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__3f5714e8401bc7635af2b6a57290696dd00389acc1e3a87004849ff0b22103b8(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[MountPointProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__2eb9db9a539fb90f40a9e195fff14eef53a8c0adfaf7f05093ad084d5876a2d5(
*,
access_group_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
file_system_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
network_type: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
vpc_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
v_switch_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
description: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
status: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__27abbbc58e832f3799a7bec627ccf4b98afdf57a2a4c5bc188e3355f47acefc3(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[RosAccessGroupProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__fc51f5fb3fb6a8d7df6fbcc91df1840265538028201bee75626d50e21ba49e8b(
props: typing.Mapping[builtins.str, typing.Any],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__6fcaac061bd3f6472d6e4b6249dab3a49665867cf1a6b2530fe4f535a0c2ecb4(
value: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__0c319cc24d3bc3f6868f50d63fdc99708bfd190eb1a436869e5e739b38ed7f59(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__f98db17968a1e4a0bd6d8fe244c542d27fe5d585dd02f5e27f6e223b56d4f99a(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__c324bc0c1ac484e6788ea37b3610a29a048ce96ffc08ee73e1d70935de55e1ef(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__0a9414a672892cb99b7f4e4e708f03a5557dace9c5b0c5cf5eb7f963c24f2daa(
*,
access_group_name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
description: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
network_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__160727bd59c09415c83442966d19ced414e6361dc6b2d06d347c305d69603fe7(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[RosAccessRuleProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__ed12f318153c57ec1a8de7372d3fa0065032a35f7e4e183b7db82f42acc1ef51(
props: typing.Mapping[builtins.str, typing.Any],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__aa1762fbcab76a94e23f8e7e5b273eccc7f294da4d06b0ce3c07592a0d4aec72(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__7b271b6bd18a49ec6c611eee34e3b0e8e8897da20d333e6988923d6246e2b89a(
value: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__3aadcce2e425574c3f6c753334523e251aabf7e196b219030f7fd5f19023b521(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__6e7aca772d7bdf4082312a8dfc8b79daee78eba45ee631c07c6f131ac0939736(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__f13f4dd3e64474da3c66e8417eeb84b613ea56a7fb831f4e22209a61c310b47b(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__f601054f8f2735f37d7453ea5773f98d118b5aed2b58fbebd2cce8823d35cd84(
value: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__a8c4ccb50a231b36ac1a735df2eb54ef3454036c12ea561df92845100c813e6f(
*,
access_group_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
network_segment: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
rw_access_type: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
description: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
priority: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__46fa9e89b53dc309f91a1837df04efbb293a3ac859dd47561f2f17875998750c(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[RosFileSystemProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__54327c61aed9f6068974df8b60c4ce57b857b983a9f2350d0d678e965f8d968d(
props: typing.Mapping[builtins.str, typing.Any],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__96a421f6fd6e2ed5fa7cf3d33d1b0ef018c12facb4a337fcf9332a195af1f372(
value: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__eb0182f72e1731033c9f41b89fdc172be0d396d1d4fae7a3aff80ef090e0dea9(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__659062943baea179ce7ba2b1906195b712bbed9d1cf9405ef2295fbdfddb6360(
value: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__f260fae1636553c4f0abea693f7ef94b30d869a261266f0b1eefdf277759d2cc(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__085f930a87908cf5c71b2068b79d6b47fe88cefa4ebd70bb02ccc2cb09cfb6c1(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__f1cb47b9456683535235324b73d162f1d5f098415de6cfce295bf700cec49f22(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__524d4f8ccbc28355a1aa2995d78a35a3300850b73be31dfd05d4a32f37634149(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__0dd88983ca6dc04f58ee4ac89b505c17696e607be515d894eb8433602b4097c6(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__4b429f48fa9072ea853ae47ca86a83ce4b6aa9d8a410ffcedc706ccfc897eadd(
value: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__bc438e3586dcc672ad967091e6f5f61a1dfe5bb056be57ae76411fb087ca6ec4(
value: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__0a54fb4d30a45751d57323086917980be2cb61ebd64bcae6bbdc64607adee3bb(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__e1f59d907e6e277537d752abf36a03cf2a10a4dbd428fae8d4474c483d6a83a8(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__6fbd2d15773b762baff0c0bedc60f9850811649a973fcbe698fa473fc676d14e(
*,
protocol_type: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
space_capacity: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
storage_type: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
zone_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
data_redundancy_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
description: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
file_system_name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
partition_number: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
provisioned_throughput_in_mi_bps: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
storage_set_name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
throughput_mode: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__b3eb07d230db865859a6a96488827ced9a0c4b10bf2f27bf2c9eb3c065cbbfff(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[RosMountPointProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__123a11d632307eac1b57a5ada40b44812f52bbce317568422fd9b7bd42a8f00d(
props: typing.Mapping[builtins.str, typing.Any],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__3c012c06baa6d6ea6451af8b964d65a724864edb14ffb5c789de4db2524ceced(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__7477de7d7fddee61ea3e0c571867b8060e866da8ed89fa60e9f934bface13d57(
value: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__5cde256c454934ce6d59865acce9c550bd31e3c0dc9fd1245c2808352cfc4717(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__0b1963f90083d69107d9be65ec900d2bd615442b59af26482632f9638ed3bb9a(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__67c091a5f1c424210a112345cdee71508c16130cf48a4bfb18eb5eacbddf921b(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__747b99a2fcbd38851486c41a40ae3de5db36fe1696d2e1ebd3adc7de0d343afb(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__e3d4446cd8573ee6aef2b227e69758e0c822de91e7f989526baea921ef151f6b(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__2cb468b54e7b3eae3dfdf825547a482f07c1fc45d5ef2f6c01f201bad860c7f6(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__946c0a4e14423ad01302ddb4da3049f9f2eb0d9d84b988bc20d83cb195ea966b(
*,
access_group_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
file_system_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
network_type: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
vpc_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
v_switch_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
description: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
status: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass | /ros-cdk-dfs-1.0.17.tar.gz/ros-cdk-dfs-1.0.17/src/ros_cdk_dfs/__init__.py | 0.623606 | 0.173358 | __init__.py | pypi |
import abc
import builtins
import datetime
import enum
import typing
import jsii
import publication
import typing_extensions
from typeguard import check_type
from ._jsii import *
import ros_cdk_core as _ros_cdk_core_7adfd82f
class Catalog(
_ros_cdk_core_7adfd82f.Resource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-dlf.Catalog",
):
'''A ROS resource type: ``ALIYUN::DLF::Catalog``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["CatalogProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
'''Create a new ``ALIYUN::DLF::Catalog``.
Param scope - scope in which this resource is defined
Param id - scoped id of the resource
Param props - resource properties
:param scope: -
:param id: -
:param props: -
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__cfbed42840f1e1a31da20d8e67dcf7c4a7baaab8209072f35524458c35bc5c90)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@builtins.property
@jsii.member(jsii_name="attrCatalogId")
def attr_catalog_id(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute CatalogId: Catalog ID.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrCatalogId"))
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-dlf.CatalogProps",
jsii_struct_bases=[],
name_mapping={
"catalog_id": "catalogId",
"description": "description",
"location_uri": "locationUri",
"owner": "owner",
},
)
class CatalogProps:
def __init__(
self,
*,
catalog_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
description: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
location_uri: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
owner: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::DLF::Catalog``.
:param catalog_id: Property catalogId: Catalog ID.
:param description: Property description: Description.
:param location_uri: Property locationUri: Location uri, for example: oss://dlf-test-oss-location/.
:param owner: Property owner: Person in charge, principal format. Empty auto-fill with current creator identity
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__efac50007a4e85446d9b5319b5e1d4a70d3d146bf307a9be6a0e46bbef1d84de)
check_type(argname="argument catalog_id", value=catalog_id, expected_type=type_hints["catalog_id"])
check_type(argname="argument description", value=description, expected_type=type_hints["description"])
check_type(argname="argument location_uri", value=location_uri, expected_type=type_hints["location_uri"])
check_type(argname="argument owner", value=owner, expected_type=type_hints["owner"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"catalog_id": catalog_id,
}
if description is not None:
self._values["description"] = description
if location_uri is not None:
self._values["location_uri"] = location_uri
if owner is not None:
self._values["owner"] = owner
@builtins.property
def catalog_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property catalogId: Catalog ID.'''
result = self._values.get("catalog_id")
assert result is not None, "Required property 'catalog_id' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def description(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property description: Description.'''
result = self._values.get("description")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def location_uri(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property locationUri: Location uri, for example: oss://dlf-test-oss-location/.'''
result = self._values.get("location_uri")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def owner(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property owner: Person in charge, principal format.
Empty auto-fill with current creator identity
'''
result = self._values.get("owner")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "CatalogProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class RosCatalog(
_ros_cdk_core_7adfd82f.RosResource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-dlf.RosCatalog",
):
'''A ROS template type: ``ALIYUN::DLF::Catalog``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["RosCatalogProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
'''Create a new ``ALIYUN::DLF::Catalog``.
:param scope: - scope in which this resource is defined.
:param id: - scoped id of the resource.
:param props: - resource properties.
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__980bd0677402661dec94729e5957e88ca32aa7ed00c09868caa7daa699f3c4cb)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@jsii.member(jsii_name="renderProperties")
def _render_properties(
self,
props: typing.Mapping[builtins.str, typing.Any],
) -> typing.Mapping[builtins.str, typing.Any]:
'''
:param props: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__0ef0ccb05b5f830651cbcc5c8446de7c836d03c18e84065664b19d342b962cd2)
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))
@jsii.python.classproperty
@jsii.member(jsii_name="ROS_RESOURCE_TYPE_NAME")
def ROS_RESOURCE_TYPE_NAME(cls) -> builtins.str:
'''The resource type name for this resource class.'''
return typing.cast(builtins.str, jsii.sget(cls, "ROS_RESOURCE_TYPE_NAME"))
@builtins.property
@jsii.member(jsii_name="attrCatalogId")
def attr_catalog_id(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: CatalogId: Catalog ID
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrCatalogId"))
@builtins.property
@jsii.member(jsii_name="rosProperties")
def _ros_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "rosProperties"))
@builtins.property
@jsii.member(jsii_name="catalogId")
def catalog_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: catalogId: Catalog ID
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "catalogId"))
@catalog_id.setter
def catalog_id(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__5a7403aefe0c0aa2599715e11e5302be34ed8edcc631b1c0da3643c6a4e885d8)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "catalogId", value)
@builtins.property
@jsii.member(jsii_name="enableResourcePropertyConstraint")
def enable_resource_property_constraint(self) -> builtins.bool:
return typing.cast(builtins.bool, jsii.get(self, "enableResourcePropertyConstraint"))
@enable_resource_property_constraint.setter
def enable_resource_property_constraint(self, value: builtins.bool) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__5e82b9fb67c6a85bc3df9f7718377b546a56834f4413d92fe50ec90b5e215fdc)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "enableResourcePropertyConstraint", value)
@builtins.property
@jsii.member(jsii_name="description")
def description(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: description: Description
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "description"))
@description.setter
def description(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__115fa4257532651b2825c10b169396522d3556a1b8ddc3b94521bfc0c4c969a8)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "description", value)
@builtins.property
@jsii.member(jsii_name="locationUri")
def location_uri(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: locationUri: Location uri, for example: oss://dlf-test-oss-location/
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "locationUri"))
@location_uri.setter
def location_uri(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__600be73065701eb855f648e55202a9b725c8cc84946f97c28274aaa3220427d7)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "locationUri", value)
@builtins.property
@jsii.member(jsii_name="owner")
def owner(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: owner: Person in charge, principal format. Empty auto-fill with current creator identity
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "owner"))
@owner.setter
def owner(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__2a8c08a48ace6a366269ffc6bf05498d11a4eff7efa778ab63181d4ca1b6f055)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "owner", value)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-dlf.RosCatalogProps",
jsii_struct_bases=[],
name_mapping={
"catalog_id": "catalogId",
"description": "description",
"location_uri": "locationUri",
"owner": "owner",
},
)
class RosCatalogProps:
def __init__(
self,
*,
catalog_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
description: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
location_uri: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
owner: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::DLF::Catalog``.
:param catalog_id:
:param description:
:param location_uri:
:param owner:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__ffa1de5642e19e4050d5195a192aabedcecccafd44dd06079712879469aa04f5)
check_type(argname="argument catalog_id", value=catalog_id, expected_type=type_hints["catalog_id"])
check_type(argname="argument description", value=description, expected_type=type_hints["description"])
check_type(argname="argument location_uri", value=location_uri, expected_type=type_hints["location_uri"])
check_type(argname="argument owner", value=owner, expected_type=type_hints["owner"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"catalog_id": catalog_id,
}
if description is not None:
self._values["description"] = description
if location_uri is not None:
self._values["location_uri"] = location_uri
if owner is not None:
self._values["owner"] = owner
@builtins.property
def catalog_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: catalogId: Catalog ID
'''
result = self._values.get("catalog_id")
assert result is not None, "Required property 'catalog_id' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def description(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: description: Description
'''
result = self._values.get("description")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def location_uri(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: locationUri: Location uri, for example: oss://dlf-test-oss-location/
'''
result = self._values.get("location_uri")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def owner(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: owner: Person in charge, principal format. Empty auto-fill with current creator identity
'''
result = self._values.get("owner")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "RosCatalogProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
__all__ = [
"Catalog",
"CatalogProps",
"RosCatalog",
"RosCatalogProps",
]
publication.publish()
def _typecheckingstub__cfbed42840f1e1a31da20d8e67dcf7c4a7baaab8209072f35524458c35bc5c90(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[CatalogProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__efac50007a4e85446d9b5319b5e1d4a70d3d146bf307a9be6a0e46bbef1d84de(
*,
catalog_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
description: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
location_uri: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
owner: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__980bd0677402661dec94729e5957e88ca32aa7ed00c09868caa7daa699f3c4cb(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[RosCatalogProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__0ef0ccb05b5f830651cbcc5c8446de7c836d03c18e84065664b19d342b962cd2(
props: typing.Mapping[builtins.str, typing.Any],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__5a7403aefe0c0aa2599715e11e5302be34ed8edcc631b1c0da3643c6a4e885d8(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__5e82b9fb67c6a85bc3df9f7718377b546a56834f4413d92fe50ec90b5e215fdc(
value: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__115fa4257532651b2825c10b169396522d3556a1b8ddc3b94521bfc0c4c969a8(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__600be73065701eb855f648e55202a9b725c8cc84946f97c28274aaa3220427d7(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__2a8c08a48ace6a366269ffc6bf05498d11a4eff7efa778ab63181d4ca1b6f055(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__ffa1de5642e19e4050d5195a192aabedcecccafd44dd06079712879469aa04f5(
*,
catalog_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
description: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
location_uri: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
owner: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass | /ros-cdk-dlf-1.0.17.tar.gz/ros-cdk-dlf-1.0.17/src/ros_cdk_dlf/__init__.py | 0.653016 | 0.175945 | __init__.py | pypi |
import abc
import builtins
import datetime
import enum
import typing
import jsii
import publication
import typing_extensions
from typeguard import check_type
from .._jsii import *
import ros_cdk_core as _ros_cdk_core_7adfd82f
class MigrationInstances(
_ros_cdk_core_7adfd82f.Resource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-dts.datasource.MigrationInstances",
):
'''A ROS resource type: ``DATASOURCE::DTS::MigrationInstances``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Optional[typing.Union["MigrationInstancesProps", typing.Dict[builtins.str, typing.Any]]] = None,
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
'''Create a new ``DATASOURCE::DTS::MigrationInstances``.
Param scope - scope in which this resource is defined
Param id - scoped id of the resource
Param props - resource properties
:param scope: -
:param id: -
:param props: -
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__1ff163b30fb20ae142aafef7fcc16e9cd01c16f00043ad9778324c492b25d187)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@builtins.property
@jsii.member(jsii_name="attrDtsInstanceIds")
def attr_dts_instance_ids(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute DtsInstanceIds: The list of dts instance IDs.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrDtsInstanceIds"))
@builtins.property
@jsii.member(jsii_name="attrMigrationInstances")
def attr_migration_instances(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute MigrationInstances: The list of migration instances.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrMigrationInstances"))
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-dts.datasource.MigrationInstancesProps",
jsii_struct_bases=[],
name_mapping={"dts_instance_id": "dtsInstanceId"},
)
class MigrationInstancesProps:
def __init__(
self,
*,
dts_instance_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``DATASOURCE::DTS::MigrationInstances``.
:param dts_instance_id: Property dtsInstanceId: Synchronization instance ID.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__b0520c37e397d480c0c15305961b46a603e5903d6d4fa51e048e183db318094a)
check_type(argname="argument dts_instance_id", value=dts_instance_id, expected_type=type_hints["dts_instance_id"])
self._values: typing.Dict[builtins.str, typing.Any] = {}
if dts_instance_id is not None:
self._values["dts_instance_id"] = dts_instance_id
@builtins.property
def dts_instance_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property dtsInstanceId: Synchronization instance ID.'''
result = self._values.get("dts_instance_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "MigrationInstancesProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class RosMigrationInstances(
_ros_cdk_core_7adfd82f.RosResource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-dts.datasource.RosMigrationInstances",
):
'''A ROS template type: ``DATASOURCE::DTS::MigrationInstances``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["RosMigrationInstancesProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
'''Create a new ``DATASOURCE::DTS::MigrationInstances``.
:param scope: - scope in which this resource is defined.
:param id: - scoped id of the resource.
:param props: - resource properties.
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__ca2573484f23c23e9cb260d260170fdec3ff7f60aa263fcbb900e53201d411b3)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@jsii.member(jsii_name="renderProperties")
def _render_properties(
self,
props: typing.Mapping[builtins.str, typing.Any],
) -> typing.Mapping[builtins.str, typing.Any]:
'''
:param props: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__cca5cdafb1cae21abb48c79a3adf8c8420ce3ea2361d13925bb4596c41d8596b)
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))
@jsii.python.classproperty
@jsii.member(jsii_name="ROS_RESOURCE_TYPE_NAME")
def ROS_RESOURCE_TYPE_NAME(cls) -> builtins.str:
'''The resource type name for this resource class.'''
return typing.cast(builtins.str, jsii.sget(cls, "ROS_RESOURCE_TYPE_NAME"))
@builtins.property
@jsii.member(jsii_name="attrDtsInstanceIds")
def attr_dts_instance_ids(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: DtsInstanceIds: The list of dts instance IDs.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrDtsInstanceIds"))
@builtins.property
@jsii.member(jsii_name="attrMigrationInstances")
def attr_migration_instances(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: MigrationInstances: The list of migration instances.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrMigrationInstances"))
@builtins.property
@jsii.member(jsii_name="rosProperties")
def _ros_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "rosProperties"))
@builtins.property
@jsii.member(jsii_name="enableResourcePropertyConstraint")
def enable_resource_property_constraint(self) -> builtins.bool:
return typing.cast(builtins.bool, jsii.get(self, "enableResourcePropertyConstraint"))
@enable_resource_property_constraint.setter
def enable_resource_property_constraint(self, value: builtins.bool) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__011780317dd291cf713f44712c41d245c21c5aea1a17b045b80ca0cf1da2c00f)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "enableResourcePropertyConstraint", value)
@builtins.property
@jsii.member(jsii_name="dtsInstanceId")
def dts_instance_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: dtsInstanceId: Synchronization instance ID.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "dtsInstanceId"))
@dts_instance_id.setter
def dts_instance_id(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__863fd75b05e7769a81468ce4031a30bfb138f3c45cdbc42de726f53c8e5c58ce)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "dtsInstanceId", value)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-dts.datasource.RosMigrationInstancesProps",
jsii_struct_bases=[],
name_mapping={"dts_instance_id": "dtsInstanceId"},
)
class RosMigrationInstancesProps:
def __init__(
self,
*,
dts_instance_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``DATASOURCE::DTS::MigrationInstances``.
:param dts_instance_id:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__9bc2455b2aac6f4f8c1cf824569a51e9b3b50e12a5d09bdf81f59eb5a2977244)
check_type(argname="argument dts_instance_id", value=dts_instance_id, expected_type=type_hints["dts_instance_id"])
self._values: typing.Dict[builtins.str, typing.Any] = {}
if dts_instance_id is not None:
self._values["dts_instance_id"] = dts_instance_id
@builtins.property
def dts_instance_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: dtsInstanceId: Synchronization instance ID.
'''
result = self._values.get("dts_instance_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "RosMigrationInstancesProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
__all__ = [
"MigrationInstances",
"MigrationInstancesProps",
"RosMigrationInstances",
"RosMigrationInstancesProps",
]
publication.publish()
def _typecheckingstub__1ff163b30fb20ae142aafef7fcc16e9cd01c16f00043ad9778324c492b25d187(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Optional[typing.Union[MigrationInstancesProps, typing.Dict[builtins.str, typing.Any]]] = None,
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__b0520c37e397d480c0c15305961b46a603e5903d6d4fa51e048e183db318094a(
*,
dts_instance_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__ca2573484f23c23e9cb260d260170fdec3ff7f60aa263fcbb900e53201d411b3(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[RosMigrationInstancesProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__cca5cdafb1cae21abb48c79a3adf8c8420ce3ea2361d13925bb4596c41d8596b(
props: typing.Mapping[builtins.str, typing.Any],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__011780317dd291cf713f44712c41d245c21c5aea1a17b045b80ca0cf1da2c00f(
value: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__863fd75b05e7769a81468ce4031a30bfb138f3c45cdbc42de726f53c8e5c58ce(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__9bc2455b2aac6f4f8c1cf824569a51e9b3b50e12a5d09bdf81f59eb5a2977244(
*,
dts_instance_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass | /ros-cdk-dts-1.0.17.tar.gz/ros-cdk-dts-1.0.17/src/ros_cdk_dts/datasource/__init__.py | 0.616243 | 0.199405 | __init__.py | pypi |
import abc
import builtins
import datetime
import enum
import typing
import jsii
import publication
import typing_extensions
from typeguard import check_type
from .._jsii import *
import ros_cdk_core as _ros_cdk_core_7adfd82f
class Instances(
_ros_cdk_core_7adfd82f.Resource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-eais.datasource.Instances",
):
'''A ROS resource type: ``DATASOURCE::EAIS::Instances``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Optional[typing.Union["InstancesProps", typing.Dict[builtins.str, typing.Any]]] = None,
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
'''Create a new ``DATASOURCE::EAIS::Instances``.
Param scope - scope in which this resource is defined
Param id - scoped id of the resource
Param props - resource properties
:param scope: -
:param id: -
:param props: -
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__afe63179dd3b311b4463c648fa5e60189264020b8d0d62b9a96718a46e951bc7)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@builtins.property
@jsii.member(jsii_name="attrInstanceIds")
def attr_instance_ids(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute InstanceIds: The list of instance IDs.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrInstanceIds"))
@builtins.property
@jsii.member(jsii_name="attrInstances")
def attr_instances(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute Instances: The list of instances.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrInstances"))
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-eais.datasource.InstancesProps",
jsii_struct_bases=[],
name_mapping={
"instance_id": "instanceId",
"instance_name": "instanceName",
"instance_type": "instanceType",
"resource_group_id": "resourceGroupId",
},
)
class InstancesProps:
def __init__(
self,
*,
instance_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
instance_name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
instance_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
resource_group_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``DATASOURCE::EAIS::Instances``.
:param instance_id: Property instanceId: Elastic accelerated instance ID.
:param instance_name: Property instanceName: Name of the instance.
:param instance_type: Property instanceType: EAIS instance type.
:param resource_group_id: Property resourceGroupId: The ID of the resource group.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__0e6f835eda0f1f5f7346ff0417f92525bb5c8dfcfde82f94bebcbb124f1dde2b)
check_type(argname="argument instance_id", value=instance_id, expected_type=type_hints["instance_id"])
check_type(argname="argument instance_name", value=instance_name, expected_type=type_hints["instance_name"])
check_type(argname="argument instance_type", value=instance_type, expected_type=type_hints["instance_type"])
check_type(argname="argument resource_group_id", value=resource_group_id, expected_type=type_hints["resource_group_id"])
self._values: typing.Dict[builtins.str, typing.Any] = {}
if instance_id is not None:
self._values["instance_id"] = instance_id
if instance_name is not None:
self._values["instance_name"] = instance_name
if instance_type is not None:
self._values["instance_type"] = instance_type
if resource_group_id is not None:
self._values["resource_group_id"] = resource_group_id
@builtins.property
def instance_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property instanceId: Elastic accelerated instance ID.'''
result = self._values.get("instance_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def instance_name(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property instanceName: Name of the instance.'''
result = self._values.get("instance_name")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def instance_type(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property instanceType: EAIS instance type.'''
result = self._values.get("instance_type")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def resource_group_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property resourceGroupId: The ID of the resource group.'''
result = self._values.get("resource_group_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "InstancesProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class RosInstances(
_ros_cdk_core_7adfd82f.RosResource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-eais.datasource.RosInstances",
):
'''A ROS template type: ``DATASOURCE::EAIS::Instances``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["RosInstancesProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
'''Create a new ``DATASOURCE::EAIS::Instances``.
:param scope: - scope in which this resource is defined.
:param id: - scoped id of the resource.
:param props: - resource properties.
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__fbbcab6515f3410f70d560d55d83f926129561de4b6e4183934e84c53f079fed)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@jsii.member(jsii_name="renderProperties")
def _render_properties(
self,
props: typing.Mapping[builtins.str, typing.Any],
) -> typing.Mapping[builtins.str, typing.Any]:
'''
:param props: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__e798b9cacb3a3f2bf495fcedb665b69ba85edbb467e1ad8e8357b68081f6133b)
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))
@jsii.python.classproperty
@jsii.member(jsii_name="ROS_RESOURCE_TYPE_NAME")
def ROS_RESOURCE_TYPE_NAME(cls) -> builtins.str:
'''The resource type name for this resource class.'''
return typing.cast(builtins.str, jsii.sget(cls, "ROS_RESOURCE_TYPE_NAME"))
@builtins.property
@jsii.member(jsii_name="attrInstanceIds")
def attr_instance_ids(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: InstanceIds: The list of instance IDs.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrInstanceIds"))
@builtins.property
@jsii.member(jsii_name="attrInstances")
def attr_instances(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: Instances: The list of instances.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrInstances"))
@builtins.property
@jsii.member(jsii_name="rosProperties")
def _ros_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "rosProperties"))
@builtins.property
@jsii.member(jsii_name="enableResourcePropertyConstraint")
def enable_resource_property_constraint(self) -> builtins.bool:
return typing.cast(builtins.bool, jsii.get(self, "enableResourcePropertyConstraint"))
@enable_resource_property_constraint.setter
def enable_resource_property_constraint(self, value: builtins.bool) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__4440e1e8cc47f2c916b0157aa806c473eaa4e4f08f0ef57e6d76c8fc82d83ce5)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "enableResourcePropertyConstraint", value)
@builtins.property
@jsii.member(jsii_name="instanceId")
def instance_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: instanceId: Elastic accelerated instance ID.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "instanceId"))
@instance_id.setter
def instance_id(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__f00c3aac4109a8c670d5fac8669e6a5d837f55e63b6c2e74bcce425e247dc0a8)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "instanceId", value)
@builtins.property
@jsii.member(jsii_name="instanceName")
def instance_name(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: instanceName: Name of the instance.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "instanceName"))
@instance_name.setter
def instance_name(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__d127067d9e5e418fa5d842e00ae5a5dea7bf2ca16de030dd237d9943b4afea38)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "instanceName", value)
@builtins.property
@jsii.member(jsii_name="instanceType")
def instance_type(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: instanceType: EAIS instance type.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "instanceType"))
@instance_type.setter
def instance_type(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__47443745efcb65de0d68e412809c0a40e30cd178f83ad13e2912ba1d847f3c3f)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "instanceType", value)
@builtins.property
@jsii.member(jsii_name="resourceGroupId")
def resource_group_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: resourceGroupId: The ID of the resource group.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "resourceGroupId"))
@resource_group_id.setter
def resource_group_id(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__b01ccd0c1dd6220c2a47f214cbcf1cfb6077bf00dfbcc71a287feedd638277b7)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "resourceGroupId", value)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-eais.datasource.RosInstancesProps",
jsii_struct_bases=[],
name_mapping={
"instance_id": "instanceId",
"instance_name": "instanceName",
"instance_type": "instanceType",
"resource_group_id": "resourceGroupId",
},
)
class RosInstancesProps:
def __init__(
self,
*,
instance_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
instance_name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
instance_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
resource_group_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``DATASOURCE::EAIS::Instances``.
:param instance_id:
:param instance_name:
:param instance_type:
:param resource_group_id:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__169f5cfdabb466b1894a269e2423615bafcffe9847ff80ad9fff3dcb148eb3e6)
check_type(argname="argument instance_id", value=instance_id, expected_type=type_hints["instance_id"])
check_type(argname="argument instance_name", value=instance_name, expected_type=type_hints["instance_name"])
check_type(argname="argument instance_type", value=instance_type, expected_type=type_hints["instance_type"])
check_type(argname="argument resource_group_id", value=resource_group_id, expected_type=type_hints["resource_group_id"])
self._values: typing.Dict[builtins.str, typing.Any] = {}
if instance_id is not None:
self._values["instance_id"] = instance_id
if instance_name is not None:
self._values["instance_name"] = instance_name
if instance_type is not None:
self._values["instance_type"] = instance_type
if resource_group_id is not None:
self._values["resource_group_id"] = resource_group_id
@builtins.property
def instance_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: instanceId: Elastic accelerated instance ID.
'''
result = self._values.get("instance_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def instance_name(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: instanceName: Name of the instance.
'''
result = self._values.get("instance_name")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def instance_type(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: instanceType: EAIS instance type.
'''
result = self._values.get("instance_type")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def resource_group_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: resourceGroupId: The ID of the resource group.
'''
result = self._values.get("resource_group_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "RosInstancesProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
__all__ = [
"Instances",
"InstancesProps",
"RosInstances",
"RosInstancesProps",
]
publication.publish()
def _typecheckingstub__afe63179dd3b311b4463c648fa5e60189264020b8d0d62b9a96718a46e951bc7(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Optional[typing.Union[InstancesProps, typing.Dict[builtins.str, typing.Any]]] = None,
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__0e6f835eda0f1f5f7346ff0417f92525bb5c8dfcfde82f94bebcbb124f1dde2b(
*,
instance_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
instance_name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
instance_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
resource_group_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__fbbcab6515f3410f70d560d55d83f926129561de4b6e4183934e84c53f079fed(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[RosInstancesProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__e798b9cacb3a3f2bf495fcedb665b69ba85edbb467e1ad8e8357b68081f6133b(
props: typing.Mapping[builtins.str, typing.Any],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__4440e1e8cc47f2c916b0157aa806c473eaa4e4f08f0ef57e6d76c8fc82d83ce5(
value: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__f00c3aac4109a8c670d5fac8669e6a5d837f55e63b6c2e74bcce425e247dc0a8(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__d127067d9e5e418fa5d842e00ae5a5dea7bf2ca16de030dd237d9943b4afea38(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__47443745efcb65de0d68e412809c0a40e30cd178f83ad13e2912ba1d847f3c3f(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__b01ccd0c1dd6220c2a47f214cbcf1cfb6077bf00dfbcc71a287feedd638277b7(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__169f5cfdabb466b1894a269e2423615bafcffe9847ff80ad9fff3dcb148eb3e6(
*,
instance_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
instance_name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
instance_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
resource_group_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass | /ros-cdk-eais-1.0.17.tar.gz/ros-cdk-eais-1.0.17/src/ros_cdk_eais/datasource/__init__.py | 0.605449 | 0.162613 | __init__.py | pypi |
import abc
import builtins
import datetime
import enum
import typing
import jsii
import publication
import typing_extensions
from typeguard import check_type
from .._jsii import *
import ros_cdk_core as _ros_cdk_core_7adfd82f
class Nodes(
_ros_cdk_core_7adfd82f.Resource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-ehpc.datasource.Nodes",
):
'''A ROS resource type: ``DATASOURCE::EHPC::Nodes``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["NodesProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
'''Create a new ``DATASOURCE::EHPC::Nodes``.
Param scope - scope in which this resource is defined
Param id - scoped id of the resource
Param props - resource properties
:param scope: -
:param id: -
:param props: -
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__48ff6955429c29a7646e904ff4d7e22dacf8755cb68415864f77880721cc4ac2)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@builtins.property
@jsii.member(jsii_name="attrNodeIds")
def attr_node_ids(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute NodeIds: The list of node IDs.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrNodeIds"))
@builtins.property
@jsii.member(jsii_name="attrNodes")
def attr_nodes(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute Nodes: The list of nodes.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrNodes"))
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-ehpc.datasource.NodesProps",
jsii_struct_bases=[],
name_mapping={
"cluster_id": "clusterId",
"host_name": "hostName",
"host_name_prefix": "hostNamePrefix",
"host_name_suffix": "hostNameSuffix",
"private_ip_address": "privateIpAddress",
"role": "role",
},
)
class NodesProps:
def __init__(
self,
*,
cluster_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
host_name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
host_name_prefix: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
host_name_suffix: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
private_ip_address: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
role: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``DATASOURCE::EHPC::Nodes``.
:param cluster_id: Property clusterId: The ID of the cluster.
:param host_name: Property hostName: The name of the node. You can perform a fuzzy search. MySQL regular expressions are supported.
:param host_name_prefix: Property hostNamePrefix: The prefix of the hostname. You can query nodes that have a specified prefix.
:param host_name_suffix: Property hostNameSuffix: The suffix of the hostname. You can query nodes that have a specified suffix.
:param private_ip_address: Property privateIpAddress: The private IP address of the node.
:param role: Property role: The type of the node. Valid values: Manager: management node Login: logon node Compute: compute node
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__5b07a16c0c4f53143497be43a17457c6d621465af03a69449d4a67ee8e2ce159)
check_type(argname="argument cluster_id", value=cluster_id, expected_type=type_hints["cluster_id"])
check_type(argname="argument host_name", value=host_name, expected_type=type_hints["host_name"])
check_type(argname="argument host_name_prefix", value=host_name_prefix, expected_type=type_hints["host_name_prefix"])
check_type(argname="argument host_name_suffix", value=host_name_suffix, expected_type=type_hints["host_name_suffix"])
check_type(argname="argument private_ip_address", value=private_ip_address, expected_type=type_hints["private_ip_address"])
check_type(argname="argument role", value=role, expected_type=type_hints["role"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"cluster_id": cluster_id,
}
if host_name is not None:
self._values["host_name"] = host_name
if host_name_prefix is not None:
self._values["host_name_prefix"] = host_name_prefix
if host_name_suffix is not None:
self._values["host_name_suffix"] = host_name_suffix
if private_ip_address is not None:
self._values["private_ip_address"] = private_ip_address
if role is not None:
self._values["role"] = role
@builtins.property
def cluster_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property clusterId: The ID of the cluster.'''
result = self._values.get("cluster_id")
assert result is not None, "Required property 'cluster_id' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def host_name(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property hostName: The name of the node.
You can perform a fuzzy search. MySQL regular expressions are supported.
'''
result = self._values.get("host_name")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def host_name_prefix(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property hostNamePrefix: The prefix of the hostname.
You can query nodes that have a specified prefix.
'''
result = self._values.get("host_name_prefix")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def host_name_suffix(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property hostNameSuffix: The suffix of the hostname.
You can query nodes that have a specified suffix.
'''
result = self._values.get("host_name_suffix")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def private_ip_address(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property privateIpAddress: The private IP address of the node.'''
result = self._values.get("private_ip_address")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def role(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property role: The type of the node.
Valid values:
Manager: management node
Login: logon node
Compute: compute node
'''
result = self._values.get("role")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "NodesProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class RosNodes(
_ros_cdk_core_7adfd82f.RosResource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-ehpc.datasource.RosNodes",
):
'''A ROS template type: ``DATASOURCE::EHPC::Nodes``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["RosNodesProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
'''Create a new ``DATASOURCE::EHPC::Nodes``.
:param scope: - scope in which this resource is defined.
:param id: - scoped id of the resource.
:param props: - resource properties.
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__beff25c0d464f8f341e08b881bce4ec7e10d51083b50e2be12d7a75ad7697742)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@jsii.member(jsii_name="renderProperties")
def _render_properties(
self,
props: typing.Mapping[builtins.str, typing.Any],
) -> typing.Mapping[builtins.str, typing.Any]:
'''
:param props: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__1bd6b66078a508626179c48a264c98f8fc9966ba245adb991476f927ffbb3104)
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))
@jsii.python.classproperty
@jsii.member(jsii_name="ROS_RESOURCE_TYPE_NAME")
def ROS_RESOURCE_TYPE_NAME(cls) -> builtins.str:
'''The resource type name for this resource class.'''
return typing.cast(builtins.str, jsii.sget(cls, "ROS_RESOURCE_TYPE_NAME"))
@builtins.property
@jsii.member(jsii_name="attrNodeIds")
def attr_node_ids(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: NodeIds: The list of node IDs.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrNodeIds"))
@builtins.property
@jsii.member(jsii_name="attrNodes")
def attr_nodes(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: Nodes: The list of nodes.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrNodes"))
@builtins.property
@jsii.member(jsii_name="rosProperties")
def _ros_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "rosProperties"))
@builtins.property
@jsii.member(jsii_name="clusterId")
def cluster_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: clusterId: The ID of the cluster.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "clusterId"))
@cluster_id.setter
def cluster_id(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__5e5ebfcfc2f86312b7a40563d193b88d1d4425c41c5455e9a65880563e343ad7)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "clusterId", value)
@builtins.property
@jsii.member(jsii_name="enableResourcePropertyConstraint")
def enable_resource_property_constraint(self) -> builtins.bool:
return typing.cast(builtins.bool, jsii.get(self, "enableResourcePropertyConstraint"))
@enable_resource_property_constraint.setter
def enable_resource_property_constraint(self, value: builtins.bool) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__9efbd0e0ce20acf3f4d69b484299b58a0822d796b8f10ab72ff4b89e148d878d)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "enableResourcePropertyConstraint", value)
@builtins.property
@jsii.member(jsii_name="hostName")
def host_name(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: hostName: The name of the node. You can perform a fuzzy search. MySQL regular expressions are supported.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "hostName"))
@host_name.setter
def host_name(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__9ce7bfe1f1a9b1e7a4b91f42b4a1374888a1b1987db3302cd52f89fdcf49ff83)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "hostName", value)
@builtins.property
@jsii.member(jsii_name="hostNamePrefix")
def host_name_prefix(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: hostNamePrefix: The prefix of the hostname. You can query nodes that have a specified prefix.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "hostNamePrefix"))
@host_name_prefix.setter
def host_name_prefix(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__1b3d167c54c62373a87d52f36cf66721b01fd96c47cdda37b1067710831c0dce)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "hostNamePrefix", value)
@builtins.property
@jsii.member(jsii_name="hostNameSuffix")
def host_name_suffix(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: hostNameSuffix: The suffix of the hostname. You can query nodes that have a specified suffix.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "hostNameSuffix"))
@host_name_suffix.setter
def host_name_suffix(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__1de63b3ce20046a2feadef6ecf3bcdf8ab298c5d7950b679decaacb94e0d917a)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "hostNameSuffix", value)
@builtins.property
@jsii.member(jsii_name="privateIpAddress")
def private_ip_address(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: privateIpAddress: The private IP address of the node.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "privateIpAddress"))
@private_ip_address.setter
def private_ip_address(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__23456294f610afc32e9747d842b07b941ba5445a031df0c5f54a5efa0deb8eeb)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "privateIpAddress", value)
@builtins.property
@jsii.member(jsii_name="role")
def role(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
role: The type of the node. Valid values:
Manager: management node
Login: logon node
Compute: compute node
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "role"))
@role.setter
def role(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__7e134550c11164e0d890174bbe3b83928eb24c27ff716d238f4dd5756819b0fa)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "role", value)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-ehpc.datasource.RosNodesProps",
jsii_struct_bases=[],
name_mapping={
"cluster_id": "clusterId",
"host_name": "hostName",
"host_name_prefix": "hostNamePrefix",
"host_name_suffix": "hostNameSuffix",
"private_ip_address": "privateIpAddress",
"role": "role",
},
)
class RosNodesProps:
def __init__(
self,
*,
cluster_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
host_name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
host_name_prefix: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
host_name_suffix: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
private_ip_address: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
role: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``DATASOURCE::EHPC::Nodes``.
:param cluster_id:
:param host_name:
:param host_name_prefix:
:param host_name_suffix:
:param private_ip_address:
:param role:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__e1d4e0de16021e7f78c47b39b425e44c88f221c0fa2fe254fd3dc1a04393e3f8)
check_type(argname="argument cluster_id", value=cluster_id, expected_type=type_hints["cluster_id"])
check_type(argname="argument host_name", value=host_name, expected_type=type_hints["host_name"])
check_type(argname="argument host_name_prefix", value=host_name_prefix, expected_type=type_hints["host_name_prefix"])
check_type(argname="argument host_name_suffix", value=host_name_suffix, expected_type=type_hints["host_name_suffix"])
check_type(argname="argument private_ip_address", value=private_ip_address, expected_type=type_hints["private_ip_address"])
check_type(argname="argument role", value=role, expected_type=type_hints["role"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"cluster_id": cluster_id,
}
if host_name is not None:
self._values["host_name"] = host_name
if host_name_prefix is not None:
self._values["host_name_prefix"] = host_name_prefix
if host_name_suffix is not None:
self._values["host_name_suffix"] = host_name_suffix
if private_ip_address is not None:
self._values["private_ip_address"] = private_ip_address
if role is not None:
self._values["role"] = role
@builtins.property
def cluster_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: clusterId: The ID of the cluster.
'''
result = self._values.get("cluster_id")
assert result is not None, "Required property 'cluster_id' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def host_name(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: hostName: The name of the node. You can perform a fuzzy search. MySQL regular expressions are supported.
'''
result = self._values.get("host_name")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def host_name_prefix(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: hostNamePrefix: The prefix of the hostname. You can query nodes that have a specified prefix.
'''
result = self._values.get("host_name_prefix")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def host_name_suffix(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: hostNameSuffix: The suffix of the hostname. You can query nodes that have a specified suffix.
'''
result = self._values.get("host_name_suffix")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def private_ip_address(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: privateIpAddress: The private IP address of the node.
'''
result = self._values.get("private_ip_address")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def role(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
role: The type of the node. Valid values:
Manager: management node
Login: logon node
Compute: compute node
'''
result = self._values.get("role")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "RosNodesProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
__all__ = [
"Nodes",
"NodesProps",
"RosNodes",
"RosNodesProps",
]
publication.publish()
def _typecheckingstub__48ff6955429c29a7646e904ff4d7e22dacf8755cb68415864f77880721cc4ac2(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[NodesProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__5b07a16c0c4f53143497be43a17457c6d621465af03a69449d4a67ee8e2ce159(
*,
cluster_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
host_name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
host_name_prefix: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
host_name_suffix: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
private_ip_address: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
role: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__beff25c0d464f8f341e08b881bce4ec7e10d51083b50e2be12d7a75ad7697742(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[RosNodesProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__1bd6b66078a508626179c48a264c98f8fc9966ba245adb991476f927ffbb3104(
props: typing.Mapping[builtins.str, typing.Any],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__5e5ebfcfc2f86312b7a40563d193b88d1d4425c41c5455e9a65880563e343ad7(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__9efbd0e0ce20acf3f4d69b484299b58a0822d796b8f10ab72ff4b89e148d878d(
value: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__9ce7bfe1f1a9b1e7a4b91f42b4a1374888a1b1987db3302cd52f89fdcf49ff83(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__1b3d167c54c62373a87d52f36cf66721b01fd96c47cdda37b1067710831c0dce(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__1de63b3ce20046a2feadef6ecf3bcdf8ab298c5d7950b679decaacb94e0d917a(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__23456294f610afc32e9747d842b07b941ba5445a031df0c5f54a5efa0deb8eeb(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__7e134550c11164e0d890174bbe3b83928eb24c27ff716d238f4dd5756819b0fa(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__e1d4e0de16021e7f78c47b39b425e44c88f221c0fa2fe254fd3dc1a04393e3f8(
*,
cluster_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
host_name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
host_name_prefix: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
host_name_suffix: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
private_ip_address: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
role: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass | /ros-cdk-ehpc-1.0.17.tar.gz/ros-cdk-ehpc-1.0.17/src/ros_cdk_ehpc/datasource/__init__.py | 0.63624 | 0.161221 | __init__.py | pypi |
import abc
import builtins
import datetime
import enum
import typing
import jsii
import publication
import typing_extensions
from typeguard import check_type
from .._jsii import *
import ros_cdk_core as _ros_cdk_core_7adfd82f
class FlowProjects(
_ros_cdk_core_7adfd82f.Resource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-emr.datasource.FlowProjects",
):
'''A ROS resource type: ``DATASOURCE::EMR::FlowProjects``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Optional[typing.Union["FlowProjectsProps", typing.Dict[builtins.str, typing.Any]]] = None,
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
'''Create a new ``DATASOURCE::EMR::FlowProjects``.
Param scope - scope in which this resource is defined
Param id - scoped id of the resource
Param props - resource properties
:param scope: -
:param id: -
:param props: -
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__e957aaf21cfc3ae937e91828e41291df7fe8a45403c89b7223b82fdded86d660)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@builtins.property
@jsii.member(jsii_name="attrFlowProjectIds")
def attr_flow_project_ids(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute FlowProjectIds: The list of flow project IDs.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrFlowProjectIds"))
@builtins.property
@jsii.member(jsii_name="attrFlowProjects")
def attr_flow_projects(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute FlowProjects: The list of flow projects.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrFlowProjects"))
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-emr.datasource.FlowProjectsProps",
jsii_struct_bases=[],
name_mapping={
"flow_project_id": "flowProjectId",
"flow_project_name": "flowProjectName",
},
)
class FlowProjectsProps:
def __init__(
self,
*,
flow_project_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
flow_project_name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``DATASOURCE::EMR::FlowProjects``.
:param flow_project_id: Property flowProjectId: The first ID of the resource.
:param flow_project_name: Property flowProjectName: Project name.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__38f8478b118ca07818f3e79738cfe0f53806774070cfa361e5a775ed2df52159)
check_type(argname="argument flow_project_id", value=flow_project_id, expected_type=type_hints["flow_project_id"])
check_type(argname="argument flow_project_name", value=flow_project_name, expected_type=type_hints["flow_project_name"])
self._values: typing.Dict[builtins.str, typing.Any] = {}
if flow_project_id is not None:
self._values["flow_project_id"] = flow_project_id
if flow_project_name is not None:
self._values["flow_project_name"] = flow_project_name
@builtins.property
def flow_project_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property flowProjectId: The first ID of the resource.'''
result = self._values.get("flow_project_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def flow_project_name(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property flowProjectName: Project name.'''
result = self._values.get("flow_project_name")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "FlowProjectsProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class RosFlowProjects(
_ros_cdk_core_7adfd82f.RosResource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-emr.datasource.RosFlowProjects",
):
'''A ROS template type: ``DATASOURCE::EMR::FlowProjects``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["RosFlowProjectsProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
'''Create a new ``DATASOURCE::EMR::FlowProjects``.
:param scope: - scope in which this resource is defined.
:param id: - scoped id of the resource.
:param props: - resource properties.
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__855b05da8c5758abee4e6d077e07921c1b8c9a5fd97d2d181fe428c031bdcc25)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@jsii.member(jsii_name="renderProperties")
def _render_properties(
self,
props: typing.Mapping[builtins.str, typing.Any],
) -> typing.Mapping[builtins.str, typing.Any]:
'''
:param props: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__6d244fd8dc3e8ab3b14fa473ec1cde10f46662fb33aa774245d4b684af585e1a)
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))
@jsii.python.classproperty
@jsii.member(jsii_name="ROS_RESOURCE_TYPE_NAME")
def ROS_RESOURCE_TYPE_NAME(cls) -> builtins.str:
'''The resource type name for this resource class.'''
return typing.cast(builtins.str, jsii.sget(cls, "ROS_RESOURCE_TYPE_NAME"))
@builtins.property
@jsii.member(jsii_name="attrFlowProjectIds")
def attr_flow_project_ids(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: FlowProjectIds: The list of flow project IDs.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrFlowProjectIds"))
@builtins.property
@jsii.member(jsii_name="attrFlowProjects")
def attr_flow_projects(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: FlowProjects: The list of flow projects.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrFlowProjects"))
@builtins.property
@jsii.member(jsii_name="rosProperties")
def _ros_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "rosProperties"))
@builtins.property
@jsii.member(jsii_name="enableResourcePropertyConstraint")
def enable_resource_property_constraint(self) -> builtins.bool:
return typing.cast(builtins.bool, jsii.get(self, "enableResourcePropertyConstraint"))
@enable_resource_property_constraint.setter
def enable_resource_property_constraint(self, value: builtins.bool) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__2628f8d78d342bbb8beb6b63d3088f145f93c1eff680fd5c0b3cbb61e03a4467)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "enableResourcePropertyConstraint", value)
@builtins.property
@jsii.member(jsii_name="flowProjectId")
def flow_project_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: flowProjectId: The first ID of the resource
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "flowProjectId"))
@flow_project_id.setter
def flow_project_id(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__492877c596ddc4ab1602a02c9639c28eed1c27b54f4ec460040dbe2167bef355)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "flowProjectId", value)
@builtins.property
@jsii.member(jsii_name="flowProjectName")
def flow_project_name(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: flowProjectName: Project name.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "flowProjectName"))
@flow_project_name.setter
def flow_project_name(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__f4546da45d7bc712b9d68fc97ca09d1f84b5023a38f32b1f7af5eae1f5681948)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "flowProjectName", value)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-emr.datasource.RosFlowProjectsProps",
jsii_struct_bases=[],
name_mapping={
"flow_project_id": "flowProjectId",
"flow_project_name": "flowProjectName",
},
)
class RosFlowProjectsProps:
def __init__(
self,
*,
flow_project_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
flow_project_name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``DATASOURCE::EMR::FlowProjects``.
:param flow_project_id:
:param flow_project_name:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__1c97dada1b4afdb1bca965c399e818470287f774e0e1348b5cab6cb7384aa68a)
check_type(argname="argument flow_project_id", value=flow_project_id, expected_type=type_hints["flow_project_id"])
check_type(argname="argument flow_project_name", value=flow_project_name, expected_type=type_hints["flow_project_name"])
self._values: typing.Dict[builtins.str, typing.Any] = {}
if flow_project_id is not None:
self._values["flow_project_id"] = flow_project_id
if flow_project_name is not None:
self._values["flow_project_name"] = flow_project_name
@builtins.property
def flow_project_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: flowProjectId: The first ID of the resource
'''
result = self._values.get("flow_project_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def flow_project_name(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: flowProjectName: Project name.
'''
result = self._values.get("flow_project_name")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "RosFlowProjectsProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
__all__ = [
"FlowProjects",
"FlowProjectsProps",
"RosFlowProjects",
"RosFlowProjectsProps",
]
publication.publish()
def _typecheckingstub__e957aaf21cfc3ae937e91828e41291df7fe8a45403c89b7223b82fdded86d660(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Optional[typing.Union[FlowProjectsProps, typing.Dict[builtins.str, typing.Any]]] = None,
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__38f8478b118ca07818f3e79738cfe0f53806774070cfa361e5a775ed2df52159(
*,
flow_project_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
flow_project_name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__855b05da8c5758abee4e6d077e07921c1b8c9a5fd97d2d181fe428c031bdcc25(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[RosFlowProjectsProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__6d244fd8dc3e8ab3b14fa473ec1cde10f46662fb33aa774245d4b684af585e1a(
props: typing.Mapping[builtins.str, typing.Any],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__2628f8d78d342bbb8beb6b63d3088f145f93c1eff680fd5c0b3cbb61e03a4467(
value: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__492877c596ddc4ab1602a02c9639c28eed1c27b54f4ec460040dbe2167bef355(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__f4546da45d7bc712b9d68fc97ca09d1f84b5023a38f32b1f7af5eae1f5681948(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__1c97dada1b4afdb1bca965c399e818470287f774e0e1348b5cab6cb7384aa68a(
*,
flow_project_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
flow_project_name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass | /ros-cdk-emr-1.0.17.tar.gz/ros-cdk-emr-1.0.17/src/ros_cdk_emr/datasource/__init__.py | 0.647352 | 0.159414 | __init__.py | pypi |
import abc
import builtins
import datetime
import enum
import typing
import jsii
import publication
import typing_extensions
from typeguard import check_type
from ._jsii import *
import ros_cdk_core as _ros_cdk_core_7adfd82f
class Flow(
_ros_cdk_core_7adfd82f.Resource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-fnf.Flow",
):
'''A ROS resource type: ``ALIYUN::FNF::Flow``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["FlowProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
'''Create a new ``ALIYUN::FNF::Flow``.
Param scope - scope in which this resource is defined
Param id - scoped id of the resource
Param props - resource properties
:param scope: -
:param id: -
:param props: -
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__86084bf95a6bd225ff4c53be4417fc04414c8db356fc614d8a8415ba62c92cdb)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@builtins.property
@jsii.member(jsii_name="attrCreatedTime")
def attr_created_time(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute CreatedTime: Flow creation time.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrCreatedTime"))
@builtins.property
@jsii.member(jsii_name="attrId")
def attr_id(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute Id: The unique ID of the flow.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrId"))
@builtins.property
@jsii.member(jsii_name="attrLastModifiedTime")
def attr_last_modified_time(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute LastModifiedTime: The most recently modified time of the flow.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrLastModifiedTime"))
@builtins.property
@jsii.member(jsii_name="attrName")
def attr_name(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute Name: The name of the flow created.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrName"))
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-fnf.FlowProps",
jsii_struct_bases=[],
name_mapping={
"definition": "definition",
"name": "name",
"description": "description",
"request_id": "requestId",
"role_arn": "roleArn",
},
)
class FlowProps:
def __init__(
self,
*,
definition: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
description: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
request_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
role_arn: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::FNF::Flow``.
:param definition: Property definition: The definition of the created flow following the FDL syntax standard.
:param name: Property name: The name of the flow created. This name is unique under the account.
:param description: Property description: Create a description of the flow.
:param request_id: Property requestId: The specified Request ID for this request. If not specified, our system will help you generate a random one.
:param role_arn: Property roleArn: Optional parameter, the resource descriptor information required for the execution of the flow, used to perform the assume role during FnF execution.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__fe444bb9be696887dd4a006907a0e2691812230ec596e39445fb2101fc4bd013)
check_type(argname="argument definition", value=definition, expected_type=type_hints["definition"])
check_type(argname="argument name", value=name, expected_type=type_hints["name"])
check_type(argname="argument description", value=description, expected_type=type_hints["description"])
check_type(argname="argument request_id", value=request_id, expected_type=type_hints["request_id"])
check_type(argname="argument role_arn", value=role_arn, expected_type=type_hints["role_arn"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"definition": definition,
"name": name,
}
if description is not None:
self._values["description"] = description
if request_id is not None:
self._values["request_id"] = request_id
if role_arn is not None:
self._values["role_arn"] = role_arn
@builtins.property
def definition(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property definition: The definition of the created flow following the FDL syntax standard.'''
result = self._values.get("definition")
assert result is not None, "Required property 'definition' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def name(self) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property name: The name of the flow created.
This name is unique under the account.
'''
result = self._values.get("name")
assert result is not None, "Required property 'name' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def description(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property description: Create a description of the flow.'''
result = self._values.get("description")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def request_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property requestId: The specified Request ID for this request.
If not specified, our system will help you generate a random one.
'''
result = self._values.get("request_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def role_arn(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property roleArn: Optional parameter, the resource descriptor information required for the execution of the flow, used to perform the assume role during FnF execution.'''
result = self._values.get("role_arn")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "FlowProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class RosFlow(
_ros_cdk_core_7adfd82f.RosResource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-fnf.RosFlow",
):
'''A ROS template type: ``ALIYUN::FNF::Flow``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["RosFlowProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
'''Create a new ``ALIYUN::FNF::Flow``.
:param scope: - scope in which this resource is defined.
:param id: - scoped id of the resource.
:param props: - resource properties.
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__7bdad0c85e9e5a56be83cc072cb1ff34c36ee1a309261f4f67fad901bdaef8e8)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@jsii.member(jsii_name="renderProperties")
def _render_properties(
self,
props: typing.Mapping[builtins.str, typing.Any],
) -> typing.Mapping[builtins.str, typing.Any]:
'''
:param props: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__d04ecc771ad16bb4b75839f32207005122c9210b00ac3c7ae746e76852343b45)
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))
@jsii.python.classproperty
@jsii.member(jsii_name="ROS_RESOURCE_TYPE_NAME")
def ROS_RESOURCE_TYPE_NAME(cls) -> builtins.str:
'''The resource type name for this resource class.'''
return typing.cast(builtins.str, jsii.sget(cls, "ROS_RESOURCE_TYPE_NAME"))
@builtins.property
@jsii.member(jsii_name="attrCreatedTime")
def attr_created_time(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: CreatedTime: Flow creation time.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrCreatedTime"))
@builtins.property
@jsii.member(jsii_name="attrId")
def attr_id(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: Id: The unique ID of the flow.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrId"))
@builtins.property
@jsii.member(jsii_name="attrLastModifiedTime")
def attr_last_modified_time(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: LastModifiedTime: The most recently modified time of the flow.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrLastModifiedTime"))
@builtins.property
@jsii.member(jsii_name="attrName")
def attr_name(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: Name: The name of the flow created.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrName"))
@builtins.property
@jsii.member(jsii_name="rosProperties")
def _ros_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "rosProperties"))
@builtins.property
@jsii.member(jsii_name="definition")
def definition(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: definition: The definition of the created flow following the FDL syntax standard.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "definition"))
@definition.setter
def definition(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__e7cc43e3f54922dc7b7d092cf1296c751f766e9bdead8acc5e190155420a02cf)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "definition", value)
@builtins.property
@jsii.member(jsii_name="enableResourcePropertyConstraint")
def enable_resource_property_constraint(self) -> builtins.bool:
return typing.cast(builtins.bool, jsii.get(self, "enableResourcePropertyConstraint"))
@enable_resource_property_constraint.setter
def enable_resource_property_constraint(self, value: builtins.bool) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__21a784feeceb7166cd353bcbe004c5072dee5047dd58ef371ecc19d6dbd1d120)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "enableResourcePropertyConstraint", value)
@builtins.property
@jsii.member(jsii_name="name")
def name(self) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: name: The name of the flow created. This name is unique under the account.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "name"))
@name.setter
def name(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__16357ad2f6454d8a3b553c4d025339e7fbca5ab395f027d4615830f4344204f3)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "name", value)
@builtins.property
@jsii.member(jsii_name="description")
def description(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: description: Create a description of the flow.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "description"))
@description.setter
def description(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__941f312c20ae597d16ab9379ffd62281b7e0584efe43651dd103c180c6951977)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "description", value)
@builtins.property
@jsii.member(jsii_name="requestId")
def request_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: requestId: The specified Request ID for this request. If not specified, our system will help you generate a random one.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "requestId"))
@request_id.setter
def request_id(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__84ec21ba7f1788a69360cd5da97313cfe43c44ed1d99b4b6315e8824663987c5)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "requestId", value)
@builtins.property
@jsii.member(jsii_name="roleArn")
def role_arn(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: roleArn: Optional parameter, the resource descriptor information required for the execution of the flow, used to perform the assume role during FnF execution.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "roleArn"))
@role_arn.setter
def role_arn(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__dcb0bd137e87e65da34a4eb20cf453a442c1b430ec542a29ec42a77d34ac7b23)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "roleArn", value)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-fnf.RosFlowProps",
jsii_struct_bases=[],
name_mapping={
"definition": "definition",
"name": "name",
"description": "description",
"request_id": "requestId",
"role_arn": "roleArn",
},
)
class RosFlowProps:
def __init__(
self,
*,
definition: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
description: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
request_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
role_arn: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::FNF::Flow``.
:param definition:
:param name:
:param description:
:param request_id:
:param role_arn:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__32c71455a490f6e2101a7f8382831e6af09dcc411a72be3ad1da5b9f43542601)
check_type(argname="argument definition", value=definition, expected_type=type_hints["definition"])
check_type(argname="argument name", value=name, expected_type=type_hints["name"])
check_type(argname="argument description", value=description, expected_type=type_hints["description"])
check_type(argname="argument request_id", value=request_id, expected_type=type_hints["request_id"])
check_type(argname="argument role_arn", value=role_arn, expected_type=type_hints["role_arn"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"definition": definition,
"name": name,
}
if description is not None:
self._values["description"] = description
if request_id is not None:
self._values["request_id"] = request_id
if role_arn is not None:
self._values["role_arn"] = role_arn
@builtins.property
def definition(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: definition: The definition of the created flow following the FDL syntax standard.
'''
result = self._values.get("definition")
assert result is not None, "Required property 'definition' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def name(self) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: name: The name of the flow created. This name is unique under the account.
'''
result = self._values.get("name")
assert result is not None, "Required property 'name' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def description(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: description: Create a description of the flow.
'''
result = self._values.get("description")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def request_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: requestId: The specified Request ID for this request. If not specified, our system will help you generate a random one.
'''
result = self._values.get("request_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def role_arn(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: roleArn: Optional parameter, the resource descriptor information required for the execution of the flow, used to perform the assume role during FnF execution.
'''
result = self._values.get("role_arn")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "RosFlowProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class RosSchedule(
_ros_cdk_core_7adfd82f.RosResource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-fnf.RosSchedule",
):
'''A ROS template type: ``ALIYUN::FNF::Schedule``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["RosScheduleProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
'''Create a new ``ALIYUN::FNF::Schedule``.
:param scope: - scope in which this resource is defined.
:param id: - scoped id of the resource.
:param props: - resource properties.
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__3036e27ce88cd13bbb05d387a554f3fc338c5a98c70b41fa647feb16a58ebdf3)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@jsii.member(jsii_name="renderProperties")
def _render_properties(
self,
props: typing.Mapping[builtins.str, typing.Any],
) -> typing.Mapping[builtins.str, typing.Any]:
'''
:param props: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__7ef4d5f87eb5b81fd7b3e6301313be7e06096d26ebb739702af7662eaecb03a4)
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))
@jsii.python.classproperty
@jsii.member(jsii_name="ROS_RESOURCE_TYPE_NAME")
def ROS_RESOURCE_TYPE_NAME(cls) -> builtins.str:
'''The resource type name for this resource class.'''
return typing.cast(builtins.str, jsii.sget(cls, "ROS_RESOURCE_TYPE_NAME"))
@builtins.property
@jsii.member(jsii_name="attrFlowName")
def attr_flow_name(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: FlowName: Flow name.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrFlowName"))
@builtins.property
@jsii.member(jsii_name="attrScheduleId")
def attr_schedule_id(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: ScheduleId: Schedule Id
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrScheduleId"))
@builtins.property
@jsii.member(jsii_name="attrScheduleName")
def attr_schedule_name(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: ScheduleName: Schedule name.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrScheduleName"))
@builtins.property
@jsii.member(jsii_name="rosProperties")
def _ros_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "rosProperties"))
@builtins.property
@jsii.member(jsii_name="cronExpression")
def cron_expression(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: cronExpression: Cron expression.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "cronExpression"))
@cron_expression.setter
def cron_expression(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__4c7f20f904d0c7b2bd4c480b309400992c15c962ec26c1fb45d8d2b4fc994e5e)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "cronExpression", value)
@builtins.property
@jsii.member(jsii_name="enableResourcePropertyConstraint")
def enable_resource_property_constraint(self) -> builtins.bool:
return typing.cast(builtins.bool, jsii.get(self, "enableResourcePropertyConstraint"))
@enable_resource_property_constraint.setter
def enable_resource_property_constraint(self, value: builtins.bool) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__b7252e6bc42c39c31fd2bf3276afa2477407da147c43bb099381effdc9c95c8d)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "enableResourcePropertyConstraint", value)
@builtins.property
@jsii.member(jsii_name="flowName")
def flow_name(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: flowName: Flow name.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "flowName"))
@flow_name.setter
def flow_name(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__7cd0b14bb086f127a3b66862dd726ae67318272572dce7fad001d06f735f84c4)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "flowName", value)
@builtins.property
@jsii.member(jsii_name="scheduleName")
def schedule_name(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: scheduleName: Schedule name.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "scheduleName"))
@schedule_name.setter
def schedule_name(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__db20179b817b590ea4fcb48340098618828273ce0be6d6b25539546370c608a4)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "scheduleName", value)
@builtins.property
@jsii.member(jsii_name="description")
def description(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: description: Description of the schedule.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "description"))
@description.setter
def description(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__2e91dda3025777972a34cc4739975d3c36f49fb0a0aaaf7683b31975731de17e)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "description", value)
@builtins.property
@jsii.member(jsii_name="enable")
def enable(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: enable: Whether enable schedule.
'''
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "enable"))
@enable.setter
def enable(
self,
value: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__946dee9e6c383592e57666a7b0670389ccfeb613e2a17e8d16ad831cc3a0699e)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "enable", value)
@builtins.property
@jsii.member(jsii_name="payload")
def payload(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: payload: Payload.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "payload"))
@payload.setter
def payload(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__0b419202dce3b18a3b7177027814420e1ee1414ba10f10934bd93640cac903e7)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "payload", value)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-fnf.RosScheduleProps",
jsii_struct_bases=[],
name_mapping={
"cron_expression": "cronExpression",
"flow_name": "flowName",
"schedule_name": "scheduleName",
"description": "description",
"enable": "enable",
"payload": "payload",
},
)
class RosScheduleProps:
def __init__(
self,
*,
cron_expression: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
flow_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
schedule_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
description: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
enable: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
payload: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::FNF::Schedule``.
:param cron_expression:
:param flow_name:
:param schedule_name:
:param description:
:param enable:
:param payload:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__ba46ffc1e0fc04173f279fe95c6f8b59f7b6b3856dc2acef98588753ea0958e0)
check_type(argname="argument cron_expression", value=cron_expression, expected_type=type_hints["cron_expression"])
check_type(argname="argument flow_name", value=flow_name, expected_type=type_hints["flow_name"])
check_type(argname="argument schedule_name", value=schedule_name, expected_type=type_hints["schedule_name"])
check_type(argname="argument description", value=description, expected_type=type_hints["description"])
check_type(argname="argument enable", value=enable, expected_type=type_hints["enable"])
check_type(argname="argument payload", value=payload, expected_type=type_hints["payload"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"cron_expression": cron_expression,
"flow_name": flow_name,
"schedule_name": schedule_name,
}
if description is not None:
self._values["description"] = description
if enable is not None:
self._values["enable"] = enable
if payload is not None:
self._values["payload"] = payload
@builtins.property
def cron_expression(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: cronExpression: Cron expression.
'''
result = self._values.get("cron_expression")
assert result is not None, "Required property 'cron_expression' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def flow_name(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: flowName: Flow name.
'''
result = self._values.get("flow_name")
assert result is not None, "Required property 'flow_name' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def schedule_name(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: scheduleName: Schedule name.
'''
result = self._values.get("schedule_name")
assert result is not None, "Required property 'schedule_name' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def description(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: description: Description of the schedule.
'''
result = self._values.get("description")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def enable(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: enable: Whether enable schedule.
'''
result = self._values.get("enable")
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def payload(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: payload: Payload.
'''
result = self._values.get("payload")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "RosScheduleProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class Schedule(
_ros_cdk_core_7adfd82f.Resource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-fnf.Schedule",
):
'''A ROS resource type: ``ALIYUN::FNF::Schedule``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["ScheduleProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
'''Create a new ``ALIYUN::FNF::Schedule``.
Param scope - scope in which this resource is defined
Param id - scoped id of the resource
Param props - resource properties
:param scope: -
:param id: -
:param props: -
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__a5d3a1ebca8d16cd88aa48c8eeba2fa3045b859816c6acaf185a303a878f81a5)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@builtins.property
@jsii.member(jsii_name="attrFlowName")
def attr_flow_name(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute FlowName: Flow name.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrFlowName"))
@builtins.property
@jsii.member(jsii_name="attrScheduleId")
def attr_schedule_id(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute ScheduleId: Schedule Id.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrScheduleId"))
@builtins.property
@jsii.member(jsii_name="attrScheduleName")
def attr_schedule_name(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute ScheduleName: Schedule name.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrScheduleName"))
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-fnf.ScheduleProps",
jsii_struct_bases=[],
name_mapping={
"cron_expression": "cronExpression",
"flow_name": "flowName",
"schedule_name": "scheduleName",
"description": "description",
"enable": "enable",
"payload": "payload",
},
)
class ScheduleProps:
def __init__(
self,
*,
cron_expression: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
flow_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
schedule_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
description: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
enable: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
payload: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::FNF::Schedule``.
:param cron_expression: Property cronExpression: Cron expression.
:param flow_name: Property flowName: Flow name.
:param schedule_name: Property scheduleName: Schedule name.
:param description: Property description: Description of the schedule.
:param enable: Property enable: Whether enable schedule.
:param payload: Property payload: Payload.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__e180f429f8f7c1cfab8bad1a65b846080d434971118296f87436461b658ef0a1)
check_type(argname="argument cron_expression", value=cron_expression, expected_type=type_hints["cron_expression"])
check_type(argname="argument flow_name", value=flow_name, expected_type=type_hints["flow_name"])
check_type(argname="argument schedule_name", value=schedule_name, expected_type=type_hints["schedule_name"])
check_type(argname="argument description", value=description, expected_type=type_hints["description"])
check_type(argname="argument enable", value=enable, expected_type=type_hints["enable"])
check_type(argname="argument payload", value=payload, expected_type=type_hints["payload"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"cron_expression": cron_expression,
"flow_name": flow_name,
"schedule_name": schedule_name,
}
if description is not None:
self._values["description"] = description
if enable is not None:
self._values["enable"] = enable
if payload is not None:
self._values["payload"] = payload
@builtins.property
def cron_expression(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property cronExpression: Cron expression.'''
result = self._values.get("cron_expression")
assert result is not None, "Required property 'cron_expression' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def flow_name(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property flowName: Flow name.'''
result = self._values.get("flow_name")
assert result is not None, "Required property 'flow_name' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def schedule_name(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property scheduleName: Schedule name.'''
result = self._values.get("schedule_name")
assert result is not None, "Required property 'schedule_name' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def description(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property description: Description of the schedule.'''
result = self._values.get("description")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def enable(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property enable: Whether enable schedule.'''
result = self._values.get("enable")
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def payload(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property payload: Payload.'''
result = self._values.get("payload")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "ScheduleProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
__all__ = [
"Flow",
"FlowProps",
"RosFlow",
"RosFlowProps",
"RosSchedule",
"RosScheduleProps",
"Schedule",
"ScheduleProps",
"datasource",
]
publication.publish()
# Loading modules to ensure their types are registered with the jsii runtime library
from . import datasource
def _typecheckingstub__86084bf95a6bd225ff4c53be4417fc04414c8db356fc614d8a8415ba62c92cdb(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[FlowProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__fe444bb9be696887dd4a006907a0e2691812230ec596e39445fb2101fc4bd013(
*,
definition: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
description: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
request_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
role_arn: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__7bdad0c85e9e5a56be83cc072cb1ff34c36ee1a309261f4f67fad901bdaef8e8(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[RosFlowProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__d04ecc771ad16bb4b75839f32207005122c9210b00ac3c7ae746e76852343b45(
props: typing.Mapping[builtins.str, typing.Any],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__e7cc43e3f54922dc7b7d092cf1296c751f766e9bdead8acc5e190155420a02cf(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__21a784feeceb7166cd353bcbe004c5072dee5047dd58ef371ecc19d6dbd1d120(
value: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__16357ad2f6454d8a3b553c4d025339e7fbca5ab395f027d4615830f4344204f3(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__941f312c20ae597d16ab9379ffd62281b7e0584efe43651dd103c180c6951977(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__84ec21ba7f1788a69360cd5da97313cfe43c44ed1d99b4b6315e8824663987c5(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__dcb0bd137e87e65da34a4eb20cf453a442c1b430ec542a29ec42a77d34ac7b23(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__32c71455a490f6e2101a7f8382831e6af09dcc411a72be3ad1da5b9f43542601(
*,
definition: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
description: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
request_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
role_arn: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__3036e27ce88cd13bbb05d387a554f3fc338c5a98c70b41fa647feb16a58ebdf3(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[RosScheduleProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__7ef4d5f87eb5b81fd7b3e6301313be7e06096d26ebb739702af7662eaecb03a4(
props: typing.Mapping[builtins.str, typing.Any],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__4c7f20f904d0c7b2bd4c480b309400992c15c962ec26c1fb45d8d2b4fc994e5e(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__b7252e6bc42c39c31fd2bf3276afa2477407da147c43bb099381effdc9c95c8d(
value: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__7cd0b14bb086f127a3b66862dd726ae67318272572dce7fad001d06f735f84c4(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__db20179b817b590ea4fcb48340098618828273ce0be6d6b25539546370c608a4(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__2e91dda3025777972a34cc4739975d3c36f49fb0a0aaaf7683b31975731de17e(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__946dee9e6c383592e57666a7b0670389ccfeb613e2a17e8d16ad831cc3a0699e(
value: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__0b419202dce3b18a3b7177027814420e1ee1414ba10f10934bd93640cac903e7(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__ba46ffc1e0fc04173f279fe95c6f8b59f7b6b3856dc2acef98588753ea0958e0(
*,
cron_expression: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
flow_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
schedule_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
description: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
enable: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
payload: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__a5d3a1ebca8d16cd88aa48c8eeba2fa3045b859816c6acaf185a303a878f81a5(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[ScheduleProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__e180f429f8f7c1cfab8bad1a65b846080d434971118296f87436461b658ef0a1(
*,
cron_expression: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
flow_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
schedule_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
description: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
enable: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
payload: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass | /ros-cdk-fnf-1.0.17.tar.gz/ros-cdk-fnf-1.0.17/src/ros_cdk_fnf/__init__.py | 0.67405 | 0.151247 | __init__.py | pypi |
import abc
import builtins
import datetime
import enum
import typing
import jsii
import publication
import typing_extensions
from typeguard import check_type
from .._jsii import *
import ros_cdk_core as _ros_cdk_core_7adfd82f
class Flows(
_ros_cdk_core_7adfd82f.Resource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-fnf.datasource.Flows",
):
'''A ROS resource type: ``DATASOURCE::FNF::Flows``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Optional[typing.Union["FlowsProps", typing.Dict[builtins.str, typing.Any]]] = None,
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
'''Create a new ``DATASOURCE::FNF::Flows``.
Param scope - scope in which this resource is defined
Param id - scoped id of the resource
Param props - resource properties
:param scope: -
:param id: -
:param props: -
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__eead93028d57f108448a147fd997578aec2541a07e92e90295d6c886880e58b9)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@builtins.property
@jsii.member(jsii_name="attrFlowNames")
def attr_flow_names(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute FlowNames: The list of flow names.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrFlowNames"))
@builtins.property
@jsii.member(jsii_name="attrFlows")
def attr_flows(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute Flows: The details about flows.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrFlows"))
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-fnf.datasource.FlowsProps",
jsii_struct_bases=[],
name_mapping={},
)
class FlowsProps:
def __init__(self) -> None:
'''Properties for defining a ``DATASOURCE::FNF::Flows``.'''
self._values: typing.Dict[builtins.str, typing.Any] = {}
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "FlowsProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class RosFlows(
_ros_cdk_core_7adfd82f.RosResource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-fnf.datasource.RosFlows",
):
'''A ROS template type: ``DATASOURCE::FNF::Flows``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["RosFlowsProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
'''Create a new ``DATASOURCE::FNF::Flows``.
:param scope: - scope in which this resource is defined.
:param id: - scoped id of the resource.
:param props: - resource properties.
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__468d29bf975e6be4da667eb3e11d9093cbab502e30c907e7477f46b69330c9da)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@jsii.member(jsii_name="renderProperties")
def _render_properties(
self,
props: typing.Mapping[builtins.str, typing.Any],
) -> typing.Mapping[builtins.str, typing.Any]:
'''
:param props: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__1fc02d06ef7cc6d46b2f47c81ccf3828d741fa3e3f71c343faf307fed96b3e74)
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))
@jsii.python.classproperty
@jsii.member(jsii_name="ROS_RESOURCE_TYPE_NAME")
def ROS_RESOURCE_TYPE_NAME(cls) -> builtins.str:
'''The resource type name for this resource class.'''
return typing.cast(builtins.str, jsii.sget(cls, "ROS_RESOURCE_TYPE_NAME"))
@builtins.property
@jsii.member(jsii_name="attrFlowNames")
def attr_flow_names(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: FlowNames: The list of flow names.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrFlowNames"))
@builtins.property
@jsii.member(jsii_name="attrFlows")
def attr_flows(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: Flows: The details about flows.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrFlows"))
@builtins.property
@jsii.member(jsii_name="rosProperties")
def _ros_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "rosProperties"))
@builtins.property
@jsii.member(jsii_name="enableResourcePropertyConstraint")
def enable_resource_property_constraint(self) -> builtins.bool:
return typing.cast(builtins.bool, jsii.get(self, "enableResourcePropertyConstraint"))
@enable_resource_property_constraint.setter
def enable_resource_property_constraint(self, value: builtins.bool) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__83cc0cdcab50a90a56cb0806d42e221d53c6aa7fff9705a2b40c49cff3ff77d1)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "enableResourcePropertyConstraint", value)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-fnf.datasource.RosFlowsProps",
jsii_struct_bases=[],
name_mapping={},
)
class RosFlowsProps:
def __init__(self) -> None:
'''Properties for defining a ``DATASOURCE::FNF::Flows``.'''
self._values: typing.Dict[builtins.str, typing.Any] = {}
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "RosFlowsProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class RosSchedules(
_ros_cdk_core_7adfd82f.RosResource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-fnf.datasource.RosSchedules",
):
'''A ROS template type: ``DATASOURCE::FNF::Schedules``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["RosSchedulesProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
'''Create a new ``DATASOURCE::FNF::Schedules``.
:param scope: - scope in which this resource is defined.
:param id: - scoped id of the resource.
:param props: - resource properties.
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__7d4f9febb90149e490eb1feb98c3b9d86180276d6f9c13742ab9586d9bbb9eee)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@jsii.member(jsii_name="renderProperties")
def _render_properties(
self,
props: typing.Mapping[builtins.str, typing.Any],
) -> typing.Mapping[builtins.str, typing.Any]:
'''
:param props: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__fed51440b20a8dc98e182ab0948fd7a0241e3e1f54e712b37aed994ac565b485)
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))
@jsii.python.classproperty
@jsii.member(jsii_name="ROS_RESOURCE_TYPE_NAME")
def ROS_RESOURCE_TYPE_NAME(cls) -> builtins.str:
'''The resource type name for this resource class.'''
return typing.cast(builtins.str, jsii.sget(cls, "ROS_RESOURCE_TYPE_NAME"))
@builtins.property
@jsii.member(jsii_name="attrScheduleNames")
def attr_schedule_names(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: ScheduleNames: The list of schedule names.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrScheduleNames"))
@builtins.property
@jsii.member(jsii_name="attrSchedules")
def attr_schedules(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: Schedules: The queried time-based schedules.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrSchedules"))
@builtins.property
@jsii.member(jsii_name="rosProperties")
def _ros_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "rosProperties"))
@builtins.property
@jsii.member(jsii_name="enableResourcePropertyConstraint")
def enable_resource_property_constraint(self) -> builtins.bool:
return typing.cast(builtins.bool, jsii.get(self, "enableResourcePropertyConstraint"))
@enable_resource_property_constraint.setter
def enable_resource_property_constraint(self, value: builtins.bool) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__f0b19cb06cb48bdb3a4f99608ccb9b2b59001170fc8c582e08f732671c698114)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "enableResourcePropertyConstraint", value)
@builtins.property
@jsii.member(jsii_name="flowName")
def flow_name(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
flowName: The name of the flow that is bound to the time-based schedule.
The name is unique within the region and cannot be modified after the time-based schedule is created. Valid values:
The name can contain letters, digits, underscores (*), and hyphens (-).
The name must start with a letter or an underscore (*).
The name is case-sensitive.
The name must be 1 to 128 characters in length.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "flowName"))
@flow_name.setter
def flow_name(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__edf0a27483dbeeb7ce553e8c511207543a4cf8049e2d4995ace9c11ec69f4ddf)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "flowName", value)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-fnf.datasource.RosSchedulesProps",
jsii_struct_bases=[],
name_mapping={"flow_name": "flowName"},
)
class RosSchedulesProps:
def __init__(
self,
*,
flow_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
'''Properties for defining a ``DATASOURCE::FNF::Schedules``.
:param flow_name:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__f75b36ae35e30f659d56f0ca403a71aa5e79c1059070ef620df8d33bb1c06d19)
check_type(argname="argument flow_name", value=flow_name, expected_type=type_hints["flow_name"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"flow_name": flow_name,
}
@builtins.property
def flow_name(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
flowName: The name of the flow that is bound to the time-based schedule.
The name is unique within the region and cannot be modified after the time-based schedule is created. Valid values:
The name can contain letters, digits, underscores (*), and hyphens (-).
The name must start with a letter or an underscore (*).
The name is case-sensitive.
The name must be 1 to 128 characters in length.
'''
result = self._values.get("flow_name")
assert result is not None, "Required property 'flow_name' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "RosSchedulesProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class Schedules(
_ros_cdk_core_7adfd82f.Resource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-fnf.datasource.Schedules",
):
'''A ROS resource type: ``DATASOURCE::FNF::Schedules``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["SchedulesProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
'''Create a new ``DATASOURCE::FNF::Schedules``.
Param scope - scope in which this resource is defined
Param id - scoped id of the resource
Param props - resource properties
:param scope: -
:param id: -
:param props: -
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__c3e4253cad6e5640158be0429a3362ac5ab71932e79e6fd4c466b571dbf832c7)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@builtins.property
@jsii.member(jsii_name="attrScheduleNames")
def attr_schedule_names(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute ScheduleNames: The list of schedule names.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrScheduleNames"))
@builtins.property
@jsii.member(jsii_name="attrSchedules")
def attr_schedules(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute Schedules: The queried time-based schedules.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrSchedules"))
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-fnf.datasource.SchedulesProps",
jsii_struct_bases=[],
name_mapping={"flow_name": "flowName"},
)
class SchedulesProps:
def __init__(
self,
*,
flow_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
'''Properties for defining a ``DATASOURCE::FNF::Schedules``.
:param flow_name: Property flowName: The name of the flow that is bound to the time-based schedule. The name is unique within the region and cannot be modified after the time-based schedule is created. Valid values: The name can contain letters, digits, underscores (*), and hyphens (-). The name must start with a letter or an underscore (*). The name is case-sensitive. The name must be 1 to 128 characters in length.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__37a78ee2b720bceb92d6fd8e93b57f94ccb38610f8f833e7811dd2652719c176)
check_type(argname="argument flow_name", value=flow_name, expected_type=type_hints["flow_name"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"flow_name": flow_name,
}
@builtins.property
def flow_name(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property flowName: The name of the flow that is bound to the time-based schedule.
The name is unique within the region and cannot be modified after the time-based schedule is created. Valid values:
The name can contain letters, digits, underscores (*), and hyphens (-).
The name must start with a letter or an underscore (*).
The name is case-sensitive.
The name must be 1 to 128 characters in length.
'''
result = self._values.get("flow_name")
assert result is not None, "Required property 'flow_name' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "SchedulesProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
__all__ = [
"Flows",
"FlowsProps",
"RosFlows",
"RosFlowsProps",
"RosSchedules",
"RosSchedulesProps",
"Schedules",
"SchedulesProps",
]
publication.publish()
def _typecheckingstub__eead93028d57f108448a147fd997578aec2541a07e92e90295d6c886880e58b9(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Optional[typing.Union[FlowsProps, typing.Dict[builtins.str, typing.Any]]] = None,
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__468d29bf975e6be4da667eb3e11d9093cbab502e30c907e7477f46b69330c9da(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[RosFlowsProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__1fc02d06ef7cc6d46b2f47c81ccf3828d741fa3e3f71c343faf307fed96b3e74(
props: typing.Mapping[builtins.str, typing.Any],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__83cc0cdcab50a90a56cb0806d42e221d53c6aa7fff9705a2b40c49cff3ff77d1(
value: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__7d4f9febb90149e490eb1feb98c3b9d86180276d6f9c13742ab9586d9bbb9eee(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[RosSchedulesProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__fed51440b20a8dc98e182ab0948fd7a0241e3e1f54e712b37aed994ac565b485(
props: typing.Mapping[builtins.str, typing.Any],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__f0b19cb06cb48bdb3a4f99608ccb9b2b59001170fc8c582e08f732671c698114(
value: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__edf0a27483dbeeb7ce553e8c511207543a4cf8049e2d4995ace9c11ec69f4ddf(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__f75b36ae35e30f659d56f0ca403a71aa5e79c1059070ef620df8d33bb1c06d19(
*,
flow_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__c3e4253cad6e5640158be0429a3362ac5ab71932e79e6fd4c466b571dbf832c7(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[SchedulesProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__37a78ee2b720bceb92d6fd8e93b57f94ccb38610f8f833e7811dd2652719c176(
*,
flow_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass | /ros-cdk-fnf-1.0.17.tar.gz/ros-cdk-fnf-1.0.17/src/ros_cdk_fnf/datasource/__init__.py | 0.637934 | 0.166218 | __init__.py | pypi |
import abc
import builtins
import datetime
import enum
import typing
import jsii
import publication
import typing_extensions
from typeguard import check_type
from .._jsii import *
import ros_cdk_core as _ros_cdk_core_7adfd82f
class Acls(
_ros_cdk_core_7adfd82f.Resource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-ga.datasource.Acls",
):
'''A ROS resource type: ``DATASOURCE::GA::Acls``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Optional[typing.Union["AclsProps", typing.Dict[builtins.str, typing.Any]]] = None,
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
'''Create a new ``DATASOURCE::GA::Acls``.
Param scope - scope in which this resource is defined
Param id - scoped id of the resource
Param props - resource properties
:param scope: -
:param id: -
:param props: -
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__272acc327d49229097523c772e82a7e78f7541f606a9640a4bcef8d0e44bf477)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@builtins.property
@jsii.member(jsii_name="attrAclIds")
def attr_acl_ids(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute AclIds: The list of acl IDs.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrAclIds"))
@builtins.property
@jsii.member(jsii_name="attrAcls")
def attr_acls(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute Acls: The list of acls.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrAcls"))
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-ga.datasource.AclsProps",
jsii_struct_bases=[],
name_mapping={
"acl_id": "aclId",
"acl_name": "aclName",
"resource_group_id": "resourceGroupId",
},
)
class AclsProps:
def __init__(
self,
*,
acl_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
acl_name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
resource_group_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``DATASOURCE::GA::Acls``.
:param acl_id: Property aclId: The ID of the Acl.
:param acl_name: Property aclName: The name of the acl.
:param resource_group_id: Property resourceGroupId: The ID of the resource group.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__8031a48d9f0cc3a2e6d5b34f9b3504ed682c51532738ef4c9facec6af6165431)
check_type(argname="argument acl_id", value=acl_id, expected_type=type_hints["acl_id"])
check_type(argname="argument acl_name", value=acl_name, expected_type=type_hints["acl_name"])
check_type(argname="argument resource_group_id", value=resource_group_id, expected_type=type_hints["resource_group_id"])
self._values: typing.Dict[builtins.str, typing.Any] = {}
if acl_id is not None:
self._values["acl_id"] = acl_id
if acl_name is not None:
self._values["acl_name"] = acl_name
if resource_group_id is not None:
self._values["resource_group_id"] = resource_group_id
@builtins.property
def acl_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property aclId: The ID of the Acl.'''
result = self._values.get("acl_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def acl_name(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property aclName: The name of the acl.'''
result = self._values.get("acl_name")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def resource_group_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property resourceGroupId: The ID of the resource group.'''
result = self._values.get("resource_group_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "AclsProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class RosAcls(
_ros_cdk_core_7adfd82f.RosResource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-ga.datasource.RosAcls",
):
'''A ROS template type: ``DATASOURCE::GA::Acls``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["RosAclsProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
'''Create a new ``DATASOURCE::GA::Acls``.
:param scope: - scope in which this resource is defined.
:param id: - scoped id of the resource.
:param props: - resource properties.
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__d9b16fd417fdba5e98487ea90da5e527540098e3173e76cd5b59b9de89b47b29)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@jsii.member(jsii_name="renderProperties")
def _render_properties(
self,
props: typing.Mapping[builtins.str, typing.Any],
) -> typing.Mapping[builtins.str, typing.Any]:
'''
:param props: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__8a3c0b39fd3e2bea7c6439d9d982e0cbf8aecc5cc6fc2cea4c87a71af1705876)
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))
@jsii.python.classproperty
@jsii.member(jsii_name="ROS_RESOURCE_TYPE_NAME")
def ROS_RESOURCE_TYPE_NAME(cls) -> builtins.str:
'''The resource type name for this resource class.'''
return typing.cast(builtins.str, jsii.sget(cls, "ROS_RESOURCE_TYPE_NAME"))
@builtins.property
@jsii.member(jsii_name="attrAclIds")
def attr_acl_ids(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: AclIds: The list of acl IDs.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrAclIds"))
@builtins.property
@jsii.member(jsii_name="attrAcls")
def attr_acls(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: Acls: The list of acls.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrAcls"))
@builtins.property
@jsii.member(jsii_name="rosProperties")
def _ros_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "rosProperties"))
@builtins.property
@jsii.member(jsii_name="enableResourcePropertyConstraint")
def enable_resource_property_constraint(self) -> builtins.bool:
return typing.cast(builtins.bool, jsii.get(self, "enableResourcePropertyConstraint"))
@enable_resource_property_constraint.setter
def enable_resource_property_constraint(self, value: builtins.bool) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__4fea47a161ff1ae38af632b08a29b0ab1eeaafb27b7b486f3a13c366595c389b)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "enableResourcePropertyConstraint", value)
@builtins.property
@jsii.member(jsii_name="aclId")
def acl_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: aclId: The ID of the Acl.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "aclId"))
@acl_id.setter
def acl_id(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__d15bd19c2e08185b51fd2cf1e522cda6eb0b1be3f65fa33e5a0645b8ac55a87e)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "aclId", value)
@builtins.property
@jsii.member(jsii_name="aclName")
def acl_name(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: aclName: The name of the acl.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "aclName"))
@acl_name.setter
def acl_name(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__487cdf264ca2a57aba5107260fff42bf8ecdac3a3a45ca5618844007125d8cc4)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "aclName", value)
@builtins.property
@jsii.member(jsii_name="resourceGroupId")
def resource_group_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: resourceGroupId: The ID of the resource group.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "resourceGroupId"))
@resource_group_id.setter
def resource_group_id(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__ac50df374c24218cd9e7483046f41bb61425d29fccc0e72a2b37c705634c9f10)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "resourceGroupId", value)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-ga.datasource.RosAclsProps",
jsii_struct_bases=[],
name_mapping={
"acl_id": "aclId",
"acl_name": "aclName",
"resource_group_id": "resourceGroupId",
},
)
class RosAclsProps:
def __init__(
self,
*,
acl_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
acl_name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
resource_group_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``DATASOURCE::GA::Acls``.
:param acl_id:
:param acl_name:
:param resource_group_id:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__e5f40968605ff1f275b9a3196414e14056e348ba7079b91b391760d58d0ea3cf)
check_type(argname="argument acl_id", value=acl_id, expected_type=type_hints["acl_id"])
check_type(argname="argument acl_name", value=acl_name, expected_type=type_hints["acl_name"])
check_type(argname="argument resource_group_id", value=resource_group_id, expected_type=type_hints["resource_group_id"])
self._values: typing.Dict[builtins.str, typing.Any] = {}
if acl_id is not None:
self._values["acl_id"] = acl_id
if acl_name is not None:
self._values["acl_name"] = acl_name
if resource_group_id is not None:
self._values["resource_group_id"] = resource_group_id
@builtins.property
def acl_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: aclId: The ID of the Acl.
'''
result = self._values.get("acl_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def acl_name(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: aclName: The name of the acl.
'''
result = self._values.get("acl_name")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def resource_group_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: resourceGroupId: The ID of the resource group.
'''
result = self._values.get("resource_group_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "RosAclsProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
__all__ = [
"Acls",
"AclsProps",
"RosAcls",
"RosAclsProps",
]
publication.publish()
def _typecheckingstub__272acc327d49229097523c772e82a7e78f7541f606a9640a4bcef8d0e44bf477(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Optional[typing.Union[AclsProps, typing.Dict[builtins.str, typing.Any]]] = None,
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__8031a48d9f0cc3a2e6d5b34f9b3504ed682c51532738ef4c9facec6af6165431(
*,
acl_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
acl_name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
resource_group_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__d9b16fd417fdba5e98487ea90da5e527540098e3173e76cd5b59b9de89b47b29(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[RosAclsProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__8a3c0b39fd3e2bea7c6439d9d982e0cbf8aecc5cc6fc2cea4c87a71af1705876(
props: typing.Mapping[builtins.str, typing.Any],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__4fea47a161ff1ae38af632b08a29b0ab1eeaafb27b7b486f3a13c366595c389b(
value: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__d15bd19c2e08185b51fd2cf1e522cda6eb0b1be3f65fa33e5a0645b8ac55a87e(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__487cdf264ca2a57aba5107260fff42bf8ecdac3a3a45ca5618844007125d8cc4(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__ac50df374c24218cd9e7483046f41bb61425d29fccc0e72a2b37c705634c9f10(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__e5f40968605ff1f275b9a3196414e14056e348ba7079b91b391760d58d0ea3cf(
*,
acl_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
acl_name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
resource_group_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass | /ros-cdk-ga-1.0.17.tar.gz/ros-cdk-ga-1.0.17/src/ros_cdk_ga/datasource/__init__.py | 0.645343 | 0.151153 | __init__.py | pypi |
import abc
import builtins
import datetime
import enum
import typing
import jsii
import publication
import typing_extensions
from typeguard import check_type
from ._jsii import *
import ros_cdk_core as _ros_cdk_core_7adfd82f
class Account(
_ros_cdk_core_7adfd82f.Resource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-gpdb.Account",
):
'''A ROS resource type: ``ALIYUN::GPDB::Account``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["AccountProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
'''Create a new ``ALIYUN::GPDB::Account``.
Param scope - scope in which this resource is defined
Param id - scoped id of the resource
Param props - resource properties
:param scope: -
:param id: -
:param props: -
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__626fe14fa2d762e0dcc84a1a0b1aa4d97e6714972017d08eb58355a1dc21fa87)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@builtins.property
@jsii.member(jsii_name="attrAccountName")
def attr_account_name(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute AccountName: The name of the account.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrAccountName"))
@builtins.property
@jsii.member(jsii_name="attrDbInstanceId")
def attr_db_instance_id(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute DBInstanceId: The ID of the instance.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrDbInstanceId"))
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-gpdb.AccountProps",
jsii_struct_bases=[],
name_mapping={
"account_name": "accountName",
"account_password": "accountPassword",
"db_instance_id": "dbInstanceId",
"account_description": "accountDescription",
},
)
class AccountProps:
def __init__(
self,
*,
account_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
account_password: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
db_instance_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
account_description: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::GPDB::Account``.
:param account_name: Property accountName: The name of the privileged account. The name can contain lowercase letters, digits, and underscores (_). The name must start with a lowercase letter and end with a lowercase letter or a digit. The name cannot start with gp. The name must be 2 to 16 characters in length.
:param account_password: Property accountPassword: The password of the privileged account. The password must contain at least three of the following character types: uppercase letters, lowercase letters, digits, and special characters. Special characters include ! @ # $ % ^ & * ( ) _ + - = The password must be 8 to 32 characters in length.
:param db_instance_id: Property dbInstanceId: The ID of the instance. Note You can call the DescribeDBInstances operation to query details of all AnalyticDB for PostgreSQL instances in a specific region, including instance IDs.
:param account_description: Property accountDescription: The description of the privileged account.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__b896ba00b09a90fabeb323569de4d08bb539272ddca78c295a33f0782800bf96)
check_type(argname="argument account_name", value=account_name, expected_type=type_hints["account_name"])
check_type(argname="argument account_password", value=account_password, expected_type=type_hints["account_password"])
check_type(argname="argument db_instance_id", value=db_instance_id, expected_type=type_hints["db_instance_id"])
check_type(argname="argument account_description", value=account_description, expected_type=type_hints["account_description"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"account_name": account_name,
"account_password": account_password,
"db_instance_id": db_instance_id,
}
if account_description is not None:
self._values["account_description"] = account_description
@builtins.property
def account_name(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property accountName: The name of the privileged account.
The name can contain lowercase letters, digits, and underscores (_).
The name must start with a lowercase letter and end with a lowercase letter or a digit.
The name cannot start with gp.
The name must be 2 to 16 characters in length.
'''
result = self._values.get("account_name")
assert result is not None, "Required property 'account_name' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def account_password(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property accountPassword: The password of the privileged account.
The password must contain at least three of the following character types: uppercase
letters, lowercase letters, digits, and special characters.
Special characters include ! @ # $ % ^ & * ( ) _ + - =
The password must be 8 to 32 characters in length.
'''
result = self._values.get("account_password")
assert result is not None, "Required property 'account_password' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def db_instance_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property dbInstanceId: The ID of the instance.
Note You can call the DescribeDBInstances operation to query details of all AnalyticDB for PostgreSQL instances in a specific
region, including instance IDs.
'''
result = self._values.get("db_instance_id")
assert result is not None, "Required property 'db_instance_id' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def account_description(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property accountDescription: The description of the privileged account.'''
result = self._values.get("account_description")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "AccountProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class DBInstance(
_ros_cdk_core_7adfd82f.Resource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-gpdb.DBInstance",
):
'''A ROS resource type: ``ALIYUN::GPDB::DBInstance``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["DBInstanceProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
'''Create a new ``ALIYUN::GPDB::DBInstance``.
Param scope - scope in which this resource is defined
Param id - scoped id of the resource
Param props - resource properties
:param scope: -
:param id: -
:param props: -
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__0ac5d3d197db2461e111c98b052eeee02d0fc03f17a683073e66a3d597f7a030)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@builtins.property
@jsii.member(jsii_name="attrConnectionString")
def attr_connection_string(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute ConnectionString: The endpoint of the instance.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrConnectionString"))
@builtins.property
@jsii.member(jsii_name="attrDbInstanceId")
def attr_db_instance_id(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute DBInstanceId: The ID of the instance.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrDbInstanceId"))
@builtins.property
@jsii.member(jsii_name="attrOrderId")
def attr_order_id(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute OrderId: The order ID of the instance.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrOrderId"))
@builtins.property
@jsii.member(jsii_name="attrPort")
def attr_port(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute Port: The port used to connect to the instance.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrPort"))
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-gpdb.DBInstanceProps",
jsii_struct_bases=[],
name_mapping={
"engine_version": "engineVersion",
"v_switch_id": "vSwitchId",
"zone_id": "zoneId",
"create_sample_data": "createSampleData",
"db_instance_category": "dbInstanceCategory",
"db_instance_class": "dbInstanceClass",
"db_instance_description": "dbInstanceDescription",
"db_instance_group_count": "dbInstanceGroupCount",
"db_instance_mode": "dbInstanceMode",
"encryption_key": "encryptionKey",
"encryption_type": "encryptionType",
"idle_time": "idleTime",
"instance_spec": "instanceSpec",
"master_node_num": "masterNodeNum",
"pay_type": "payType",
"period": "period",
"period_unit": "periodUnit",
"private_ip_address": "privateIpAddress",
"security_ip_list": "securityIpList",
"seg_disk_performance_level": "segDiskPerformanceLevel",
"seg_node_num": "segNodeNum",
"seg_storage_type": "segStorageType",
"serverless_mode": "serverlessMode",
"serverless_resource": "serverlessResource",
"storage_size": "storageSize",
"tags": "tags",
"vector_configuration_status": "vectorConfigurationStatus",
"vpc_id": "vpcId",
},
)
class DBInstanceProps:
def __init__(
self,
*,
engine_version: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
v_switch_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
zone_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
create_sample_data: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
db_instance_category: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
db_instance_class: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
db_instance_description: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
db_instance_group_count: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
db_instance_mode: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
encryption_key: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
encryption_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
idle_time: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
instance_spec: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
master_node_num: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
pay_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
period: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
period_unit: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
private_ip_address: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
security_ip_list: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
seg_disk_performance_level: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
seg_node_num: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
seg_storage_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
serverless_mode: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
serverless_resource: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
storage_size: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
tags: typing.Optional[typing.Sequence[typing.Union["RosDBInstance.TagsProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
vector_configuration_status: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
vpc_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::GPDB::DBInstance``.
:param engine_version: Property engineVersion: The version of the database engine. For example: 6.0、7.0
:param v_switch_id: Property vSwitchId: The vSwitch ID of the instance.
:param zone_id: Property zoneId: The zone ID of the instance, such as cn-hangzhou-d. You can call the DescribeRegions operation to query the most recent zone list.
:param create_sample_data: Property createSampleData: Whether to load the sample data set after the instance is created. The value can be: true: load the sample dataset. false: not to load the sample dataset
:param db_instance_category: Property dbInstanceCategory: DB instance category, valid values: Basic, HighAvailability. This parameter must be passed in to create a storage reservation mode instance.
:param db_instance_class: Property dbInstanceClass: The instance type.
:param db_instance_description: Property dbInstanceDescription: The description of the instance. The description cannot exceed 256 characters in length.
:param db_instance_group_count: Property dbInstanceGroupCount: The number of compute nodes in the instance. The value can be 2, 4, 8, 12, 16, 24, 32, 64, 96, or 128.
:param db_instance_mode: Property dbInstanceMode: The db instance mode. Valid values: StorageElastic, Serverless, Classic.
:param encryption_key: Property encryptionKey: If the EncryptionType parameter is set to CloudDisk, you must specify this parameter to the encryption key that is in the same region with the disks that is specified by the EncryptionType parameter. Otherwise, leave this parameter empty.
:param encryption_type: Property encryptionType: The type of the encryption. Default value: NULL. Valid values: NULL: Encryption is disabled. CloudDisk: Encryption is enabled on disks and the encryption key is specified by using the EncryptionKey parameter. Note: Disk encryption cannot be disabled after it is enabled.
:param idle_time: Property idleTime: Idle release wait time. That is, when the period of no service traffic reaches the specified period, the instance becomes idle. The unit is second. The minimum value is 60. The default value is 600.
:param instance_spec: Property instanceSpec: The specification of segment nodes. - When DBInstanceCategory is HighAvailability, Valid values: 2C16G, 4C32G, 8C64G, 16C128G. - When DBInstanceCategory is Basic, Valid values: 2C8G, 4C16G, 8C32G, 16C64G. - When DBInstanceCategory is Serverless, Valid values: 4C16G, 8C32G. This parameter must be passed to create a storage elastic mode instance and a serverless version instance.
:param master_node_num: Property masterNodeNum: The number of master nodes. Minimum is 1, max is 2.
:param pay_type: Property payType: The billing method of the instance. Default value: Postpaid. Valid values: Postpaid: pay-as-you-go Prepaid: subscription
:param period: Property period: The subscription period. While choose by pay by month, it could be from 1 to 11. While choose pay by year, it could be from 1 to 3.
:param period_unit: Property periodUnit: Unit of subscription period, it could be Month/Year. Default value is Month.
:param private_ip_address: Property privateIpAddress: Private IP address.
:param security_ip_list: Property securityIpList: The whitelist of IP addresses that are allowed to access the instance. Default value: 127.0.0.1.
:param seg_disk_performance_level: Property segDiskPerformanceLevel: Seg disk performance level. The value can be: pl0、pl1 and pl2
:param seg_node_num: Property segNodeNum: Calculate the number of nodes. The value can be: - When DBInstanceMode is StorageElastic and DBInstanceCategory is HighAvailability, the value ranges from 4 to 512. The value must be a multiple of 4. - When DBInstanceMode is StorageElastic and DBInstanceCategory is Basic, the value ranges from 2 to 512. The value must be a multiple of 2. - When DBInstanceMode is Serverless, The value ranges from 2 to 512. The value must be a multiple of 2.
:param seg_storage_type: Property segStorageType: The disk type of segment nodes. For example: cloud_essd, cloud_efficiency. This parameter must be passed in to create a storage elastic mode instance. Storage Elastic Mode Basic Edition instances only support ESSD cloud disks.
:param serverless_mode: Property serverlessMode: Mode of the Serverless instance. The value can be: Manual: manual scheduling is the default value. Auto: indicates automatic scheduling.
:param serverless_resource: Property serverlessResource: Computing resource threshold. The value ranges from 8 to 32. The step length is 8. The unit is ACU. The default value is 32.
:param storage_size: Property storageSize: The storage capacity of per segment node. Unit: GB. Minimum is 50, max is 4000, step is 50.
:param tags: Property tags: Tags to attach to instance. Max support 20 tags to add during create instance. Each tag with two properties Key and Value, and Key is required.
:param vector_configuration_status: Property vectorConfigurationStatus: the status of vector configuration. The value can be:Y: Turn on vector engine optimization.N: Turn off vector engine optimization (default value).
:param vpc_id: Property vpcId: The VPC ID of the instance. If you set the InstanceNetworkType parameter to VPC, you must also specify the VPCId parameter. The specified region of the VPC must be the same as the RegionId value.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__777da448732a953451d42cdf65572b1b2e1df0fbb772a44ee39827922339ff39)
check_type(argname="argument engine_version", value=engine_version, expected_type=type_hints["engine_version"])
check_type(argname="argument v_switch_id", value=v_switch_id, expected_type=type_hints["v_switch_id"])
check_type(argname="argument zone_id", value=zone_id, expected_type=type_hints["zone_id"])
check_type(argname="argument create_sample_data", value=create_sample_data, expected_type=type_hints["create_sample_data"])
check_type(argname="argument db_instance_category", value=db_instance_category, expected_type=type_hints["db_instance_category"])
check_type(argname="argument db_instance_class", value=db_instance_class, expected_type=type_hints["db_instance_class"])
check_type(argname="argument db_instance_description", value=db_instance_description, expected_type=type_hints["db_instance_description"])
check_type(argname="argument db_instance_group_count", value=db_instance_group_count, expected_type=type_hints["db_instance_group_count"])
check_type(argname="argument db_instance_mode", value=db_instance_mode, expected_type=type_hints["db_instance_mode"])
check_type(argname="argument encryption_key", value=encryption_key, expected_type=type_hints["encryption_key"])
check_type(argname="argument encryption_type", value=encryption_type, expected_type=type_hints["encryption_type"])
check_type(argname="argument idle_time", value=idle_time, expected_type=type_hints["idle_time"])
check_type(argname="argument instance_spec", value=instance_spec, expected_type=type_hints["instance_spec"])
check_type(argname="argument master_node_num", value=master_node_num, expected_type=type_hints["master_node_num"])
check_type(argname="argument pay_type", value=pay_type, expected_type=type_hints["pay_type"])
check_type(argname="argument period", value=period, expected_type=type_hints["period"])
check_type(argname="argument period_unit", value=period_unit, expected_type=type_hints["period_unit"])
check_type(argname="argument private_ip_address", value=private_ip_address, expected_type=type_hints["private_ip_address"])
check_type(argname="argument security_ip_list", value=security_ip_list, expected_type=type_hints["security_ip_list"])
check_type(argname="argument seg_disk_performance_level", value=seg_disk_performance_level, expected_type=type_hints["seg_disk_performance_level"])
check_type(argname="argument seg_node_num", value=seg_node_num, expected_type=type_hints["seg_node_num"])
check_type(argname="argument seg_storage_type", value=seg_storage_type, expected_type=type_hints["seg_storage_type"])
check_type(argname="argument serverless_mode", value=serverless_mode, expected_type=type_hints["serverless_mode"])
check_type(argname="argument serverless_resource", value=serverless_resource, expected_type=type_hints["serverless_resource"])
check_type(argname="argument storage_size", value=storage_size, expected_type=type_hints["storage_size"])
check_type(argname="argument tags", value=tags, expected_type=type_hints["tags"])
check_type(argname="argument vector_configuration_status", value=vector_configuration_status, expected_type=type_hints["vector_configuration_status"])
check_type(argname="argument vpc_id", value=vpc_id, expected_type=type_hints["vpc_id"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"engine_version": engine_version,
"v_switch_id": v_switch_id,
"zone_id": zone_id,
}
if create_sample_data is not None:
self._values["create_sample_data"] = create_sample_data
if db_instance_category is not None:
self._values["db_instance_category"] = db_instance_category
if db_instance_class is not None:
self._values["db_instance_class"] = db_instance_class
if db_instance_description is not None:
self._values["db_instance_description"] = db_instance_description
if db_instance_group_count is not None:
self._values["db_instance_group_count"] = db_instance_group_count
if db_instance_mode is not None:
self._values["db_instance_mode"] = db_instance_mode
if encryption_key is not None:
self._values["encryption_key"] = encryption_key
if encryption_type is not None:
self._values["encryption_type"] = encryption_type
if idle_time is not None:
self._values["idle_time"] = idle_time
if instance_spec is not None:
self._values["instance_spec"] = instance_spec
if master_node_num is not None:
self._values["master_node_num"] = master_node_num
if pay_type is not None:
self._values["pay_type"] = pay_type
if period is not None:
self._values["period"] = period
if period_unit is not None:
self._values["period_unit"] = period_unit
if private_ip_address is not None:
self._values["private_ip_address"] = private_ip_address
if security_ip_list is not None:
self._values["security_ip_list"] = security_ip_list
if seg_disk_performance_level is not None:
self._values["seg_disk_performance_level"] = seg_disk_performance_level
if seg_node_num is not None:
self._values["seg_node_num"] = seg_node_num
if seg_storage_type is not None:
self._values["seg_storage_type"] = seg_storage_type
if serverless_mode is not None:
self._values["serverless_mode"] = serverless_mode
if serverless_resource is not None:
self._values["serverless_resource"] = serverless_resource
if storage_size is not None:
self._values["storage_size"] = storage_size
if tags is not None:
self._values["tags"] = tags
if vector_configuration_status is not None:
self._values["vector_configuration_status"] = vector_configuration_status
if vpc_id is not None:
self._values["vpc_id"] = vpc_id
@builtins.property
def engine_version(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property engineVersion: The version of the database engine.
For example: 6.0、7.0
'''
result = self._values.get("engine_version")
assert result is not None, "Required property 'engine_version' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def v_switch_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property vSwitchId: The vSwitch ID of the instance.'''
result = self._values.get("v_switch_id")
assert result is not None, "Required property 'v_switch_id' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def zone_id(self) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property zoneId: The zone ID of the instance, such as cn-hangzhou-d.
You can call the DescribeRegions
operation to query the most recent zone list.
'''
result = self._values.get("zone_id")
assert result is not None, "Required property 'zone_id' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def create_sample_data(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property createSampleData: Whether to load the sample data set after the instance is created.
The value can be:
true: load the sample dataset.
false: not to load the sample dataset
'''
result = self._values.get("create_sample_data")
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def db_instance_category(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property dbInstanceCategory: DB instance category, valid values: Basic, HighAvailability.
This parameter must be passed in to create a storage reservation mode instance.
'''
result = self._values.get("db_instance_category")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def db_instance_class(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property dbInstanceClass: The instance type.'''
result = self._values.get("db_instance_class")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def db_instance_description(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property dbInstanceDescription: The description of the instance.
The description cannot exceed 256 characters in length.
'''
result = self._values.get("db_instance_description")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def db_instance_group_count(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property dbInstanceGroupCount: The number of compute nodes in the instance.
The value can be 2, 4, 8, 12, 16, 24, 32, 64, 96, or 128.
'''
result = self._values.get("db_instance_group_count")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def db_instance_mode(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property dbInstanceMode: The db instance mode.
Valid values: StorageElastic, Serverless, Classic.
'''
result = self._values.get("db_instance_mode")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def encryption_key(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property encryptionKey: If the EncryptionType parameter is set to CloudDisk, you must specify this parameter to the encryption key that is in the same region with the disks that is specified by the EncryptionType parameter.
Otherwise, leave this parameter empty.
'''
result = self._values.get("encryption_key")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def encryption_type(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property encryptionType: The type of the encryption.
Default value: NULL. Valid values:
NULL: Encryption is disabled.
CloudDisk: Encryption is enabled on disks and the encryption key is specified by using the EncryptionKey parameter.
Note: Disk encryption cannot be disabled after it is enabled.
'''
result = self._values.get("encryption_type")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def idle_time(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property idleTime: Idle release wait time.
That is, when the period of no service traffic reaches the specified period, the instance becomes idle. The unit is second. The minimum value is 60. The default value is 600.
'''
result = self._values.get("idle_time")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def instance_spec(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property instanceSpec: The specification of segment nodes.
- When DBInstanceCategory is HighAvailability, Valid values: 2C16G, 4C32G, 8C64G, 16C128G.
- When DBInstanceCategory is Basic, Valid values: 2C8G, 4C16G, 8C32G, 16C64G.
- When DBInstanceCategory is Serverless, Valid values: 4C16G, 8C32G.
This parameter must be passed to create a storage elastic mode instance and a serverless version instance.
'''
result = self._values.get("instance_spec")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def master_node_num(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property masterNodeNum: The number of master nodes.
Minimum is 1, max is 2.
'''
result = self._values.get("master_node_num")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def pay_type(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property payType: The billing method of the instance.
Default value: Postpaid. Valid values:
Postpaid: pay-as-you-go
Prepaid: subscription
'''
result = self._values.get("pay_type")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def period(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property period: The subscription period.
While choose by pay by month, it could be from 1 to 11. While choose pay by year, it could be from 1 to 3.
'''
result = self._values.get("period")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def period_unit(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property periodUnit: Unit of subscription period, it could be Month/Year.
Default value is Month.
'''
result = self._values.get("period_unit")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def private_ip_address(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property privateIpAddress: Private IP address.'''
result = self._values.get("private_ip_address")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def security_ip_list(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property securityIpList: The whitelist of IP addresses that are allowed to access the instance.
Default value:
127.0.0.1.
'''
result = self._values.get("security_ip_list")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def seg_disk_performance_level(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property segDiskPerformanceLevel: Seg disk performance level.
The value can be:
pl0、pl1 and pl2
'''
result = self._values.get("seg_disk_performance_level")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def seg_node_num(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property segNodeNum: Calculate the number of nodes.
The value can be:
- When DBInstanceMode is StorageElastic and DBInstanceCategory is HighAvailability, the value ranges from 4 to 512. The value must be a multiple of 4.
- When DBInstanceMode is StorageElastic and DBInstanceCategory is Basic, the value ranges from 2 to 512. The value must be a multiple of 2.
- When DBInstanceMode is Serverless, The value ranges from 2 to 512. The value must be a multiple of 2.
'''
result = self._values.get("seg_node_num")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def seg_storage_type(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property segStorageType: The disk type of segment nodes.
For example: cloud_essd, cloud_efficiency.
This parameter must be passed in to create a storage elastic mode instance.
Storage Elastic Mode Basic Edition instances only support ESSD cloud disks.
'''
result = self._values.get("seg_storage_type")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def serverless_mode(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property serverlessMode: Mode of the Serverless instance.
The value can be:
Manual: manual scheduling is the default value.
Auto: indicates automatic scheduling.
'''
result = self._values.get("serverless_mode")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def serverless_resource(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property serverlessResource: Computing resource threshold.
The value ranges from 8 to 32. The step length is 8.
The unit is ACU. The default value is 32.
'''
result = self._values.get("serverless_resource")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def storage_size(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property storageSize: The storage capacity of per segment node.
Unit: GB. Minimum is 50, max is 4000, step is 50.
'''
result = self._values.get("storage_size")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def tags(self) -> typing.Optional[typing.List["RosDBInstance.TagsProperty"]]:
'''Property tags: Tags to attach to instance.
Max support 20 tags to add during create instance. Each tag with two properties Key and Value, and Key is required.
'''
result = self._values.get("tags")
return typing.cast(typing.Optional[typing.List["RosDBInstance.TagsProperty"]], result)
@builtins.property
def vector_configuration_status(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property vectorConfigurationStatus: the status of vector configuration.
The value can be:Y: Turn on vector engine optimization.N: Turn off vector engine optimization (default value).
'''
result = self._values.get("vector_configuration_status")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def vpc_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property vpcId: The VPC ID of the instance.
If you set the InstanceNetworkType parameter to VPC, you
must also specify the VPCId parameter. The specified region of the VPC must be the
same as the RegionId value.
'''
result = self._values.get("vpc_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "DBInstanceProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class ElasticDBInstance(
_ros_cdk_core_7adfd82f.Resource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-gpdb.ElasticDBInstance",
):
'''A ROS resource type: ``ALIYUN::GPDB::ElasticDBInstance``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["ElasticDBInstanceProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
'''Create a new ``ALIYUN::GPDB::ElasticDBInstance``.
Param scope - scope in which this resource is defined
Param id - scoped id of the resource
Param props - resource properties
:param scope: -
:param id: -
:param props: -
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__afb41ab807caa4ef994103ba46105f295d1116b7a47d1f04b83115ed59994f69)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@builtins.property
@jsii.member(jsii_name="attrConnectionString")
def attr_connection_string(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute ConnectionString: The endpoint of the instance.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrConnectionString"))
@builtins.property
@jsii.member(jsii_name="attrDbInstanceId")
def attr_db_instance_id(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute DBInstanceId: The ID of the instance.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrDbInstanceId"))
@builtins.property
@jsii.member(jsii_name="attrOrderId")
def attr_order_id(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute OrderId: The order ID of the instance.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrOrderId"))
@builtins.property
@jsii.member(jsii_name="attrPort")
def attr_port(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute Port: The port used to connect to the instance.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrPort"))
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-gpdb.ElasticDBInstanceProps",
jsii_struct_bases=[],
name_mapping={
"engine_version": "engineVersion",
"instance_spec": "instanceSpec",
"seg_node_num": "segNodeNum",
"seg_storage_type": "segStorageType",
"storage_size": "storageSize",
"v_switch_id": "vSwitchId",
"zone_id": "zoneId",
"db_instance_category": "dbInstanceCategory",
"db_instance_description": "dbInstanceDescription",
"db_instance_mode": "dbInstanceMode",
"encryption_key": "encryptionKey",
"encryption_type": "encryptionType",
"master_node_num": "masterNodeNum",
"pay_type": "payType",
"period": "period",
"period_unit": "periodUnit",
"private_ip_address": "privateIpAddress",
"security_ip_list": "securityIpList",
"tags": "tags",
"vpc_id": "vpcId",
},
)
class ElasticDBInstanceProps:
def __init__(
self,
*,
engine_version: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
instance_spec: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
seg_node_num: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
seg_storage_type: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
storage_size: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
v_switch_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
zone_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
db_instance_category: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
db_instance_description: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
db_instance_mode: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
encryption_key: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
encryption_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
master_node_num: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
pay_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
period: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
period_unit: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
private_ip_address: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
security_ip_list: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
tags: typing.Optional[typing.Sequence[typing.Union["RosElasticDBInstance.TagsProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
vpc_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::GPDB::ElasticDBInstance``.
:param engine_version: Property engineVersion: The version of the database engine. For example: 6.0、7.0
:param instance_spec: Property instanceSpec: The specification of segment nodes. For example: 2C16G, 4C32G, 16C128G.
:param seg_node_num: Property segNodeNum: The number of segment nodes. For the high availability version, the value ranges from 4 to 512. The basic version ranges from 2 to 512.
:param seg_storage_type: Property segStorageType: The disk type of segment nodes. For example: cloud_essd, cloud_efficiency.
:param storage_size: Property storageSize: The storage capacity of per segment node. Unit: GB. Minimum is 50, max is 4000, step is 50.
:param v_switch_id: Property vSwitchId: The vSwitch ID of the instance.
:param zone_id: Property zoneId: The zone ID of the instance, such as cn-hangzhou-d. You can call the DescribeRegions operation to query the most recent zone list.
:param db_instance_category: Property dbInstanceCategory: DB instance category, valid values: Basic, HighAvailability. This parameter must be passed in to create a storage reservation mode instance.
:param db_instance_description: Property dbInstanceDescription: The description of the instance. The description cannot exceed 256 characters in length.
:param db_instance_mode: Property dbInstanceMode: The db instance mode. Valid values: StorageElastic, Serverless, Classic.
:param encryption_key: Property encryptionKey: If the EncryptionType parameter is set to CloudDisk, you must specify this parameter to the encryption key that is in the same region with the disks that is specified by the EncryptionType parameter. Otherwise, leave this parameter empty.
:param encryption_type: Property encryptionType: The type of the encryption. Default value: NULL. Valid values: NULL: Encryption is disabled. CloudDisk: Encryption is enabled on disks and the encryption key is specified by using the EncryptionKey parameter. Note: Disk encryption cannot be disabled after it is enabled.
:param master_node_num: Property masterNodeNum: The number of master nodes. Minimum is 1, max is 2.
:param pay_type: Property payType: The billing method of the instance. Default value: Postpaid. Valid values: Postpaid: pay-as-you-go Prepaid: subscription
:param period: Property period: The subscription period. While choose by pay by month, it could be from 1 to 11. While choose pay by year, it could be from 1 to 3.
:param period_unit: Property periodUnit: Unit of subscription period, it could be Month/Year. Default value is Month.
:param private_ip_address: Property privateIpAddress: Private IP address.
:param security_ip_list: Property securityIpList: The whitelist of IP addresses that are allowed to access the instance. Default value: 127.0.0.1.
:param tags: Property tags: Tags to attach to instance. Max support 20 tags to add during create instance. Each tag with two properties Key and Value, and Key is required.
:param vpc_id: Property vpcId: The VPC ID of the instance. If you set the InstanceNetworkType parameter to VPC, you must also specify the VPCId parameter. The specified region of the VPC must be the same as the RegionId value.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__b50bd0f1c53fcb1f2492c8e557bc5a1871227ec9e19eb918772302abd834fde8)
check_type(argname="argument engine_version", value=engine_version, expected_type=type_hints["engine_version"])
check_type(argname="argument instance_spec", value=instance_spec, expected_type=type_hints["instance_spec"])
check_type(argname="argument seg_node_num", value=seg_node_num, expected_type=type_hints["seg_node_num"])
check_type(argname="argument seg_storage_type", value=seg_storage_type, expected_type=type_hints["seg_storage_type"])
check_type(argname="argument storage_size", value=storage_size, expected_type=type_hints["storage_size"])
check_type(argname="argument v_switch_id", value=v_switch_id, expected_type=type_hints["v_switch_id"])
check_type(argname="argument zone_id", value=zone_id, expected_type=type_hints["zone_id"])
check_type(argname="argument db_instance_category", value=db_instance_category, expected_type=type_hints["db_instance_category"])
check_type(argname="argument db_instance_description", value=db_instance_description, expected_type=type_hints["db_instance_description"])
check_type(argname="argument db_instance_mode", value=db_instance_mode, expected_type=type_hints["db_instance_mode"])
check_type(argname="argument encryption_key", value=encryption_key, expected_type=type_hints["encryption_key"])
check_type(argname="argument encryption_type", value=encryption_type, expected_type=type_hints["encryption_type"])
check_type(argname="argument master_node_num", value=master_node_num, expected_type=type_hints["master_node_num"])
check_type(argname="argument pay_type", value=pay_type, expected_type=type_hints["pay_type"])
check_type(argname="argument period", value=period, expected_type=type_hints["period"])
check_type(argname="argument period_unit", value=period_unit, expected_type=type_hints["period_unit"])
check_type(argname="argument private_ip_address", value=private_ip_address, expected_type=type_hints["private_ip_address"])
check_type(argname="argument security_ip_list", value=security_ip_list, expected_type=type_hints["security_ip_list"])
check_type(argname="argument tags", value=tags, expected_type=type_hints["tags"])
check_type(argname="argument vpc_id", value=vpc_id, expected_type=type_hints["vpc_id"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"engine_version": engine_version,
"instance_spec": instance_spec,
"seg_node_num": seg_node_num,
"seg_storage_type": seg_storage_type,
"storage_size": storage_size,
"v_switch_id": v_switch_id,
"zone_id": zone_id,
}
if db_instance_category is not None:
self._values["db_instance_category"] = db_instance_category
if db_instance_description is not None:
self._values["db_instance_description"] = db_instance_description
if db_instance_mode is not None:
self._values["db_instance_mode"] = db_instance_mode
if encryption_key is not None:
self._values["encryption_key"] = encryption_key
if encryption_type is not None:
self._values["encryption_type"] = encryption_type
if master_node_num is not None:
self._values["master_node_num"] = master_node_num
if pay_type is not None:
self._values["pay_type"] = pay_type
if period is not None:
self._values["period"] = period
if period_unit is not None:
self._values["period_unit"] = period_unit
if private_ip_address is not None:
self._values["private_ip_address"] = private_ip_address
if security_ip_list is not None:
self._values["security_ip_list"] = security_ip_list
if tags is not None:
self._values["tags"] = tags
if vpc_id is not None:
self._values["vpc_id"] = vpc_id
@builtins.property
def engine_version(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property engineVersion: The version of the database engine.
For example: 6.0、7.0
'''
result = self._values.get("engine_version")
assert result is not None, "Required property 'engine_version' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def instance_spec(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property instanceSpec: The specification of segment nodes.
For example: 2C16G, 4C32G, 16C128G.
'''
result = self._values.get("instance_spec")
assert result is not None, "Required property 'instance_spec' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def seg_node_num(
self,
) -> typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property segNodeNum: The number of segment nodes.
For the high availability version, the value ranges from 4 to 512.
The basic version ranges from 2 to 512.
'''
result = self._values.get("seg_node_num")
assert result is not None, "Required property 'seg_node_num' is missing"
return typing.cast(typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def seg_storage_type(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property segStorageType: The disk type of segment nodes.
For example: cloud_essd, cloud_efficiency.
'''
result = self._values.get("seg_storage_type")
assert result is not None, "Required property 'seg_storage_type' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def storage_size(
self,
) -> typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property storageSize: The storage capacity of per segment node.
Unit: GB. Minimum is 50, max is 4000, step is 50.
'''
result = self._values.get("storage_size")
assert result is not None, "Required property 'storage_size' is missing"
return typing.cast(typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def v_switch_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property vSwitchId: The vSwitch ID of the instance.'''
result = self._values.get("v_switch_id")
assert result is not None, "Required property 'v_switch_id' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def zone_id(self) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property zoneId: The zone ID of the instance, such as cn-hangzhou-d.
You can call the DescribeRegions
operation to query the most recent zone list.
'''
result = self._values.get("zone_id")
assert result is not None, "Required property 'zone_id' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def db_instance_category(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property dbInstanceCategory: DB instance category, valid values: Basic, HighAvailability.
This parameter must be passed in to create a storage reservation mode instance.
'''
result = self._values.get("db_instance_category")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def db_instance_description(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property dbInstanceDescription: The description of the instance.
The description cannot exceed 256 characters in length.
'''
result = self._values.get("db_instance_description")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def db_instance_mode(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property dbInstanceMode: The db instance mode.
Valid values: StorageElastic, Serverless, Classic.
'''
result = self._values.get("db_instance_mode")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def encryption_key(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property encryptionKey: If the EncryptionType parameter is set to CloudDisk, you must specify this parameter to the encryption key that is in the same region with the disks that is specified by the EncryptionType parameter.
Otherwise, leave this parameter empty.
'''
result = self._values.get("encryption_key")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def encryption_type(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property encryptionType: The type of the encryption.
Default value: NULL. Valid values:
NULL: Encryption is disabled.
CloudDisk: Encryption is enabled on disks and the encryption key is specified by using the EncryptionKey parameter.
Note: Disk encryption cannot be disabled after it is enabled.
'''
result = self._values.get("encryption_type")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def master_node_num(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property masterNodeNum: The number of master nodes.
Minimum is 1, max is 2.
'''
result = self._values.get("master_node_num")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def pay_type(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property payType: The billing method of the instance.
Default value: Postpaid. Valid values:
Postpaid: pay-as-you-go
Prepaid: subscription
'''
result = self._values.get("pay_type")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def period(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property period: The subscription period.
While choose by pay by month, it could be from 1 to 11. While choose pay by year, it could be from 1 to 3.
'''
result = self._values.get("period")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def period_unit(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property periodUnit: Unit of subscription period, it could be Month/Year.
Default value is Month.
'''
result = self._values.get("period_unit")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def private_ip_address(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property privateIpAddress: Private IP address.'''
result = self._values.get("private_ip_address")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def security_ip_list(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property securityIpList: The whitelist of IP addresses that are allowed to access the instance.
Default value:
127.0.0.1.
'''
result = self._values.get("security_ip_list")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def tags(self) -> typing.Optional[typing.List["RosElasticDBInstance.TagsProperty"]]:
'''Property tags: Tags to attach to instance.
Max support 20 tags to add during create instance. Each tag with two properties Key and Value, and Key is required.
'''
result = self._values.get("tags")
return typing.cast(typing.Optional[typing.List["RosElasticDBInstance.TagsProperty"]], result)
@builtins.property
def vpc_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property vpcId: The VPC ID of the instance.
If you set the InstanceNetworkType parameter to VPC, you
must also specify the VPCId parameter. The specified region of the VPC must be the
same as the RegionId value.
'''
result = self._values.get("vpc_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "ElasticDBInstanceProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class InstancePublicConnection(
_ros_cdk_core_7adfd82f.Resource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-gpdb.InstancePublicConnection",
):
'''A ROS resource type: ``ALIYUN::GPDB::InstancePublicConnection``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["InstancePublicConnectionProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
'''Create a new ``ALIYUN::GPDB::InstancePublicConnection``.
Param scope - scope in which this resource is defined
Param id - scoped id of the resource
Param props - resource properties
:param scope: -
:param id: -
:param props: -
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__aea14d34091cbdf41869d8355483911a5f080c68068fdefbfed38f85b972a571)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@builtins.property
@jsii.member(jsii_name="attrConnectionString")
def attr_connection_string(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute ConnectionString: The connection string of the instance.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrConnectionString"))
@builtins.property
@jsii.member(jsii_name="attrDbInstanceId")
def attr_db_instance_id(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute DBInstanceId: The ID of the instance.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrDbInstanceId"))
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-gpdb.InstancePublicConnectionProps",
jsii_struct_bases=[],
name_mapping={
"connection_string_prefix": "connectionStringPrefix",
"db_instance_id": "dbInstanceId",
"port": "port",
},
)
class InstancePublicConnectionProps:
def __init__(
self,
*,
connection_string_prefix: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
db_instance_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
port: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
'''Properties for defining a ``ALIYUN::GPDB::InstancePublicConnection``.
:param connection_string_prefix: Property connectionStringPrefix: The endpoint that is used to connect to the specified database.
:param db_instance_id: Property dbInstanceId: The ID of the instance.
:param port: Property port: The port number of the instance.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__cee4236c08b63e7091ee29fd6b36fa1e107bdee356282b75ce12080220ff78e5)
check_type(argname="argument connection_string_prefix", value=connection_string_prefix, expected_type=type_hints["connection_string_prefix"])
check_type(argname="argument db_instance_id", value=db_instance_id, expected_type=type_hints["db_instance_id"])
check_type(argname="argument port", value=port, expected_type=type_hints["port"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"connection_string_prefix": connection_string_prefix,
"db_instance_id": db_instance_id,
"port": port,
}
@builtins.property
def connection_string_prefix(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property connectionStringPrefix: The endpoint that is used to connect to the specified database.'''
result = self._values.get("connection_string_prefix")
assert result is not None, "Required property 'connection_string_prefix' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def db_instance_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property dbInstanceId: The ID of the instance.'''
result = self._values.get("db_instance_id")
assert result is not None, "Required property 'db_instance_id' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def port(self) -> typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property port: The port number of the instance.'''
result = self._values.get("port")
assert result is not None, "Required property 'port' is missing"
return typing.cast(typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "InstancePublicConnectionProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class RosAccount(
_ros_cdk_core_7adfd82f.RosResource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-gpdb.RosAccount",
):
'''A ROS template type: ``ALIYUN::GPDB::Account``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["RosAccountProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
'''Create a new ``ALIYUN::GPDB::Account``.
:param scope: - scope in which this resource is defined.
:param id: - scoped id of the resource.
:param props: - resource properties.
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__56c85415ad5c3a2e3fa6805fa8f045cbda34d54e214235afb4e03c69085b814f)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@jsii.member(jsii_name="renderProperties")
def _render_properties(
self,
props: typing.Mapping[builtins.str, typing.Any],
) -> typing.Mapping[builtins.str, typing.Any]:
'''
:param props: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__bf297c10f14eeed3e89f98a84988016d65e3fc269af72f1a3d3fe0b5295b405c)
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))
@jsii.python.classproperty
@jsii.member(jsii_name="ROS_RESOURCE_TYPE_NAME")
def ROS_RESOURCE_TYPE_NAME(cls) -> builtins.str:
'''The resource type name for this resource class.'''
return typing.cast(builtins.str, jsii.sget(cls, "ROS_RESOURCE_TYPE_NAME"))
@builtins.property
@jsii.member(jsii_name="attrAccountName")
def attr_account_name(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: AccountName: The name of the account.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrAccountName"))
@builtins.property
@jsii.member(jsii_name="attrDbInstanceId")
def attr_db_instance_id(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: DBInstanceId: The ID of the instance.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrDbInstanceId"))
@builtins.property
@jsii.member(jsii_name="rosProperties")
def _ros_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "rosProperties"))
@builtins.property
@jsii.member(jsii_name="accountName")
def account_name(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
accountName: The name of the privileged account.
The name can contain lowercase letters, digits, and underscores (_).
The name must start with a lowercase letter and end with a lowercase letter or a digit.
The name cannot start with gp.
The name must be 2 to 16 characters in length.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "accountName"))
@account_name.setter
def account_name(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__64b2b15304e8ed8a75fe6ec84d6ee1d069c05d764dc913deb233fcb9d7ba7fe4)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "accountName", value)
@builtins.property
@jsii.member(jsii_name="accountPassword")
def account_password(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
::
$ % ^ & * ( ) _ + - =
The password must be 8 to 32 characters in length.
:Property:
accountPassword: The password of the privileged account.
The password must contain at least three of the following character types: uppercase
letters, lowercase letters, digits, and special characters.
Special characters include !
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "accountPassword"))
@account_password.setter
def account_password(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__db96de02923d764a6f7f5fbff83f18ad66a1135ba5cd21ba0837465a761370c8)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "accountPassword", value)
@builtins.property
@jsii.member(jsii_name="dbInstanceId")
def db_instance_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
dbInstanceId: The ID of the instance.
Note You can call the DescribeDBInstances operation to query details of all AnalyticDB for PostgreSQL instances in a specific
region, including instance IDs.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "dbInstanceId"))
@db_instance_id.setter
def db_instance_id(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__edb7fa52bc478dfcd68abf8e4f9b72455171caac9a9f3dca5eb94c25479e3786)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "dbInstanceId", value)
@builtins.property
@jsii.member(jsii_name="enableResourcePropertyConstraint")
def enable_resource_property_constraint(self) -> builtins.bool:
return typing.cast(builtins.bool, jsii.get(self, "enableResourcePropertyConstraint"))
@enable_resource_property_constraint.setter
def enable_resource_property_constraint(self, value: builtins.bool) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__60f7e8657e3def39d0e384cc415b6de1f3b9d73f1a62ae3e3d3d3b4b06f7416d)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "enableResourcePropertyConstraint", value)
@builtins.property
@jsii.member(jsii_name="accountDescription")
def account_description(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: accountDescription: The description of the privileged account.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "accountDescription"))
@account_description.setter
def account_description(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__806ced7a73d7e8844f06c183a7add7244719a7f5c58cf75e2ede4bd44d54bb4e)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "accountDescription", value)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-gpdb.RosAccountProps",
jsii_struct_bases=[],
name_mapping={
"account_name": "accountName",
"account_password": "accountPassword",
"db_instance_id": "dbInstanceId",
"account_description": "accountDescription",
},
)
class RosAccountProps:
def __init__(
self,
*,
account_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
account_password: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
db_instance_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
account_description: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::GPDB::Account``.
:param account_name:
:param account_password:
:param db_instance_id:
:param account_description:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__dde61a3e29477468f8d60e9b12d581b8e8c20d15f25c8b5f24c4998dec7db5a1)
check_type(argname="argument account_name", value=account_name, expected_type=type_hints["account_name"])
check_type(argname="argument account_password", value=account_password, expected_type=type_hints["account_password"])
check_type(argname="argument db_instance_id", value=db_instance_id, expected_type=type_hints["db_instance_id"])
check_type(argname="argument account_description", value=account_description, expected_type=type_hints["account_description"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"account_name": account_name,
"account_password": account_password,
"db_instance_id": db_instance_id,
}
if account_description is not None:
self._values["account_description"] = account_description
@builtins.property
def account_name(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
accountName: The name of the privileged account.
The name can contain lowercase letters, digits, and underscores (_).
The name must start with a lowercase letter and end with a lowercase letter or a digit.
The name cannot start with gp.
The name must be 2 to 16 characters in length.
'''
result = self._values.get("account_name")
assert result is not None, "Required property 'account_name' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def account_password(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
::
$ % ^ & * ( ) _ + - =
The password must be 8 to 32 characters in length.
:Property:
accountPassword: The password of the privileged account.
The password must contain at least three of the following character types: uppercase
letters, lowercase letters, digits, and special characters.
Special characters include !
'''
result = self._values.get("account_password")
assert result is not None, "Required property 'account_password' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def db_instance_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
dbInstanceId: The ID of the instance.
Note You can call the DescribeDBInstances operation to query details of all AnalyticDB for PostgreSQL instances in a specific
region, including instance IDs.
'''
result = self._values.get("db_instance_id")
assert result is not None, "Required property 'db_instance_id' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def account_description(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: accountDescription: The description of the privileged account.
'''
result = self._values.get("account_description")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "RosAccountProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class RosDBInstance(
_ros_cdk_core_7adfd82f.RosResource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-gpdb.RosDBInstance",
):
'''A ROS template type: ``ALIYUN::GPDB::DBInstance``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["RosDBInstanceProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
'''Create a new ``ALIYUN::GPDB::DBInstance``.
:param scope: - scope in which this resource is defined.
:param id: - scoped id of the resource.
:param props: - resource properties.
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__e1ac5871bdf5eda60758a3f56134d6bc536d3421427c8646056634dd28789b93)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@jsii.member(jsii_name="renderProperties")
def _render_properties(
self,
props: typing.Mapping[builtins.str, typing.Any],
) -> typing.Mapping[builtins.str, typing.Any]:
'''
:param props: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__b4da4a02ca6762649ce6d834482ce0cec1bd252e488ee806453ce13274969a99)
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))
@jsii.python.classproperty
@jsii.member(jsii_name="ROS_RESOURCE_TYPE_NAME")
def ROS_RESOURCE_TYPE_NAME(cls) -> builtins.str:
'''The resource type name for this resource class.'''
return typing.cast(builtins.str, jsii.sget(cls, "ROS_RESOURCE_TYPE_NAME"))
@builtins.property
@jsii.member(jsii_name="attrConnectionString")
def attr_connection_string(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: ConnectionString: The endpoint of the instance.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrConnectionString"))
@builtins.property
@jsii.member(jsii_name="attrDbInstanceId")
def attr_db_instance_id(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: DBInstanceId: The ID of the instance.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrDbInstanceId"))
@builtins.property
@jsii.member(jsii_name="attrOrderId")
def attr_order_id(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: OrderId: The order ID of the instance.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrOrderId"))
@builtins.property
@jsii.member(jsii_name="attrPort")
def attr_port(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: Port: The port used to connect to the instance.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrPort"))
@builtins.property
@jsii.member(jsii_name="rosProperties")
def _ros_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "rosProperties"))
@builtins.property
@jsii.member(jsii_name="enableResourcePropertyConstraint")
def enable_resource_property_constraint(self) -> builtins.bool:
return typing.cast(builtins.bool, jsii.get(self, "enableResourcePropertyConstraint"))
@enable_resource_property_constraint.setter
def enable_resource_property_constraint(self, value: builtins.bool) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__097e69af8a79977a70b892c24dc58d52a0ca7d25d25a7a0128cd7643b2f5ad71)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "enableResourcePropertyConstraint", value)
@builtins.property
@jsii.member(jsii_name="engineVersion")
def engine_version(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: engineVersion: The version of the database engine. For example: 6.0、7.0
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "engineVersion"))
@engine_version.setter
def engine_version(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__03aea9fd80f1bcd09f065453fee4935e1e938640d10a779957681841e21febf9)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "engineVersion", value)
@builtins.property
@jsii.member(jsii_name="vSwitchId")
def v_switch_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: vSwitchId: The vSwitch ID of the instance.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "vSwitchId"))
@v_switch_id.setter
def v_switch_id(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__8d2018019c2d652687405116b0a267d95331ea4ac129fcaa6f42ffcfc3ea0811)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "vSwitchId", value)
@builtins.property
@jsii.member(jsii_name="zoneId")
def zone_id(self) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
zoneId: The zone ID of the instance, such as cn-hangzhou-d. You can call the DescribeRegions
operation to query the most recent zone list.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "zoneId"))
@zone_id.setter
def zone_id(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__b3c51d9ed5ee9683f1aa565eefd5604341299f1107fafad10f12a24199e71eaa)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "zoneId", value)
@builtins.property
@jsii.member(jsii_name="createSampleData")
def create_sample_data(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
createSampleData: Whether to load the sample data set after the instance is created. The value can be:
true: load the sample dataset.
false: not to load the sample dataset
'''
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "createSampleData"))
@create_sample_data.setter
def create_sample_data(
self,
value: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__1f9d5e65e164f80bf0197e5a576d49253759a0ed9c3a1afb39b7bdb66a230964)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "createSampleData", value)
@builtins.property
@jsii.member(jsii_name="dbInstanceCategory")
def db_instance_category(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
dbInstanceCategory: DB instance category, valid values: Basic, HighAvailability.
This parameter must be passed in to create a storage reservation mode instance.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "dbInstanceCategory"))
@db_instance_category.setter
def db_instance_category(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__e5f01851b432982057eb6fa3bccf9fb9741a32f77e543624fde8e0241d7051cc)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "dbInstanceCategory", value)
@builtins.property
@jsii.member(jsii_name="dbInstanceClass")
def db_instance_class(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: dbInstanceClass: The instance type.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "dbInstanceClass"))
@db_instance_class.setter
def db_instance_class(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__5770ba995a64bc46d7478a45b687eea2e3de524d8aa9d6314701b8ad10ab58b8)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "dbInstanceClass", value)
@builtins.property
@jsii.member(jsii_name="dbInstanceDescription")
def db_instance_description(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: dbInstanceDescription: The description of the instance. The description cannot exceed 256 characters in length.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "dbInstanceDescription"))
@db_instance_description.setter
def db_instance_description(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__de2ea367343456b3819fece649d82be3622bda8ba238834af2e0a7c97e55cb32)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "dbInstanceDescription", value)
@builtins.property
@jsii.member(jsii_name="dbInstanceGroupCount")
def db_instance_group_count(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
dbInstanceGroupCount: The number of compute nodes in the instance.
The value can be 2, 4, 8, 12, 16, 24, 32, 64, 96, or 128.
'''
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "dbInstanceGroupCount"))
@db_instance_group_count.setter
def db_instance_group_count(
self,
value: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__7bdad23d1b60401833f10a183b23ed0f4938313167e7e46180a1a5a937fe87cf)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "dbInstanceGroupCount", value)
@builtins.property
@jsii.member(jsii_name="dbInstanceMode")
def db_instance_mode(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: dbInstanceMode: The db instance mode. Valid values: StorageElastic, Serverless, Classic.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "dbInstanceMode"))
@db_instance_mode.setter
def db_instance_mode(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__78488974967dd6df1f37bd9f6cf018ba8a9d83a2590c9204cb7f10a9c4a81e4f)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "dbInstanceMode", value)
@builtins.property
@jsii.member(jsii_name="encryptionKey")
def encryption_key(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: encryptionKey: If the EncryptionType parameter is set to CloudDisk, you must specify this parameter to the encryption key that is in the same region with the disks that is specified by the EncryptionType parameter. Otherwise, leave this parameter empty.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "encryptionKey"))
@encryption_key.setter
def encryption_key(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__41ddabcaa8a9058f28282ba1b3acbb8a9fe853c829fc9fe936f9ede218a03f97)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "encryptionKey", value)
@builtins.property
@jsii.member(jsii_name="encryptionType")
def encryption_type(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
encryptionType: The type of the encryption. Default value: NULL. Valid values:
NULL: Encryption is disabled.
CloudDisk: Encryption is enabled on disks and the encryption key is specified by using the EncryptionKey parameter.
Note: Disk encryption cannot be disabled after it is enabled.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "encryptionType"))
@encryption_type.setter
def encryption_type(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__102b536a47bfa185aab366f8fda7bc6c0de44967f96be577626d6321a7673b97)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "encryptionType", value)
@builtins.property
@jsii.member(jsii_name="idleTime")
def idle_time(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: idleTime: Idle release wait time. That is, when the period of no service traffic reaches the specified period, the instance becomes idle. The unit is second. The minimum value is 60. The default value is 600.
'''
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "idleTime"))
@idle_time.setter
def idle_time(
self,
value: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__e3d5f75f23a3cb3acc7dcd4b18c0e00b4699e931aa40354b4af9565bbf829020)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "idleTime", value)
@builtins.property
@jsii.member(jsii_name="instanceSpec")
def instance_spec(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
instanceSpec: The specification of segment nodes.
- When DBInstanceCategory is HighAvailability, Valid values: 2C16G, 4C32G, 8C64G, 16C128G.
- When DBInstanceCategory is Basic, Valid values: 2C8G, 4C16G, 8C32G, 16C64G.
- When DBInstanceCategory is Serverless, Valid values: 4C16G, 8C32G.
This parameter must be passed to create a storage elastic mode instance and a serverless version instance.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "instanceSpec"))
@instance_spec.setter
def instance_spec(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__855903d76f2238be44b32d350988a2219600c43f51719ad00b13e87c11a7707f)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "instanceSpec", value)
@builtins.property
@jsii.member(jsii_name="masterNodeNum")
def master_node_num(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: masterNodeNum: The number of master nodes. Minimum is 1, max is 2.
'''
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "masterNodeNum"))
@master_node_num.setter
def master_node_num(
self,
value: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__a7cf00876e4beb50e61c2f63b02445b537ffc2d44316f4d016df7276085228b6)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "masterNodeNum", value)
@builtins.property
@jsii.member(jsii_name="payType")
def pay_type(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
payType: The billing method of the instance. Default value: Postpaid. Valid values:
Postpaid: pay-as-you-go
Prepaid: subscription
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "payType"))
@pay_type.setter
def pay_type(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__a1d771433f9bbebba21253100d385479413da746005cd80b3ca1494d46697520)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "payType", value)
@builtins.property
@jsii.member(jsii_name="period")
def period(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: period: The subscription period. While choose by pay by month, it could be from 1 to 11. While choose pay by year, it could be from 1 to 3.
'''
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "period"))
@period.setter
def period(
self,
value: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__4e9877d63ce7eb2ba0d47c72ab9d1b1352548afe3670db61f8b27e9bb9c3e497)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "period", value)
@builtins.property
@jsii.member(jsii_name="periodUnit")
def period_unit(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: periodUnit: Unit of subscription period, it could be Month/Year. Default value is Month.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "periodUnit"))
@period_unit.setter
def period_unit(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__9ae419b93987a5b888a593ee77c7453f6e3ada09b43dc097006ecccfdf9ecd95)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "periodUnit", value)
@builtins.property
@jsii.member(jsii_name="privateIpAddress")
def private_ip_address(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: privateIpAddress: Private IP address.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "privateIpAddress"))
@private_ip_address.setter
def private_ip_address(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__83379ba95901c4a4ededccc633d12d97e2f7d20ea9153bf99f76075ba0a3706a)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "privateIpAddress", value)
@builtins.property
@jsii.member(jsii_name="securityIpList")
def security_ip_list(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
securityIpList: The whitelist of IP addresses that are allowed to access the instance. Default value:
127.0.0.1.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "securityIpList"))
@security_ip_list.setter
def security_ip_list(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__fc6fb832af7389686cba9ec143f920189f9c1f68029961d804a3a40891e827fe)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "securityIpList", value)
@builtins.property
@jsii.member(jsii_name="segDiskPerformanceLevel")
def seg_disk_performance_level(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
segDiskPerformanceLevel: Seg disk performance level. The value can be:
pl0、pl1 and pl2
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "segDiskPerformanceLevel"))
@seg_disk_performance_level.setter
def seg_disk_performance_level(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__511db6d48b32b9e12af31b2f44ba94c0a56e5ffc0020d59e1a8f42d0de01f4c3)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "segDiskPerformanceLevel", value)
@builtins.property
@jsii.member(jsii_name="segNodeNum")
def seg_node_num(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
segNodeNum: Calculate the number of nodes. The value can be:
- When DBInstanceMode is StorageElastic and DBInstanceCategory is HighAvailability, the value ranges from 4 to 512. The value must be a multiple of 4.
- When DBInstanceMode is StorageElastic and DBInstanceCategory is Basic, the value ranges from 2 to 512. The value must be a multiple of 2.
- When DBInstanceMode is Serverless, The value ranges from 2 to 512. The value must be a multiple of 2.
'''
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "segNodeNum"))
@seg_node_num.setter
def seg_node_num(
self,
value: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__e986928180e4e4678640741471e6c349e5c5254ae5e590f27ea0b9637ca5cee7)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "segNodeNum", value)
@builtins.property
@jsii.member(jsii_name="segStorageType")
def seg_storage_type(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
segStorageType: The disk type of segment nodes. For example: cloud_essd, cloud_efficiency.
This parameter must be passed in to create a storage elastic mode instance.
Storage Elastic Mode Basic Edition instances only support ESSD cloud disks.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "segStorageType"))
@seg_storage_type.setter
def seg_storage_type(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__d03d862a7372f5bd7810819fdeda4cee6066f6d68dab3b3283fbd65ff9036146)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "segStorageType", value)
@builtins.property
@jsii.member(jsii_name="serverlessMode")
def serverless_mode(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
serverlessMode: Mode of the Serverless instance. The value can be:
Manual: manual scheduling is the default value.
Auto: indicates automatic scheduling.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "serverlessMode"))
@serverless_mode.setter
def serverless_mode(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__18b1ba84740f2e0a74f8213f5d25dd03b2ee9c7462b52c6ab7248b34a26e29ea)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "serverlessMode", value)
@builtins.property
@jsii.member(jsii_name="serverlessResource")
def serverless_resource(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
serverlessResource: Computing resource threshold. The value ranges from 8 to 32. The step length is 8.
The unit is ACU. The default value is 32.
'''
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "serverlessResource"))
@serverless_resource.setter
def serverless_resource(
self,
value: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__83517dd393c6a5df9536a6714988bf4c5d3d1c35068ae0c87499f7cae6473a57)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "serverlessResource", value)
@builtins.property
@jsii.member(jsii_name="storageSize")
def storage_size(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: storageSize: The storage capacity of per segment node. Unit: GB. Minimum is 50, max is 4000, step is 50.
'''
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "storageSize"))
@storage_size.setter
def storage_size(
self,
value: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__727f55d1217544aa020d986509ea115734756524206fc5f8b42cf7af1bed1762)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "storageSize", value)
@builtins.property
@jsii.member(jsii_name="tags")
def tags(self) -> typing.Optional[typing.List["RosDBInstance.TagsProperty"]]:
'''
:Property: tags: Tags to attach to instance. Max support 20 tags to add during create instance. Each tag with two properties Key and Value, and Key is required.
'''
return typing.cast(typing.Optional[typing.List["RosDBInstance.TagsProperty"]], jsii.get(self, "tags"))
@tags.setter
def tags(
self,
value: typing.Optional[typing.List["RosDBInstance.TagsProperty"]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__00ad71ac7fe2c264ec20770b02fffd8b3af4ee4a02aeb9adc8a253fc98875a56)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "tags", value)
@builtins.property
@jsii.member(jsii_name="vectorConfigurationStatus")
def vector_configuration_status(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: vectorConfigurationStatus: the status of vector configuration. The value can be:Y: Turn on vector engine optimization.N: Turn off vector engine optimization (default value).
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "vectorConfigurationStatus"))
@vector_configuration_status.setter
def vector_configuration_status(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__f66ea83fc66d39f0109972d07451d2d95c7f675ae9116c0171753ff715734c7a)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "vectorConfigurationStatus", value)
@builtins.property
@jsii.member(jsii_name="vpcId")
def vpc_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
vpcId: The VPC ID of the instance. If you set the InstanceNetworkType parameter to VPC, you
must also specify the VPCId parameter. The specified region of the VPC must be the
same as the RegionId value.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "vpcId"))
@vpc_id.setter
def vpc_id(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__e962829a5935162e80cde0cda7eb491fcca73ca46cb0d20639c137209f6c594a)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "vpcId", value)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-gpdb.RosDBInstance.TagsProperty",
jsii_struct_bases=[],
name_mapping={"key": "key", "value": "value"},
)
class TagsProperty:
def __init__(
self,
*,
key: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''
:param key:
:param value:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__591c06a9522e824d65cc9cd6355d23819469eee76d979c6bc80d228fc619632d)
check_type(argname="argument key", value=key, expected_type=type_hints["key"])
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"key": key,
}
if value is not None:
self._values["value"] = value
@builtins.property
def key(self) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: key: undefined
'''
result = self._values.get("key")
assert result is not None, "Required property 'key' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def value(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: value: undefined
'''
result = self._values.get("value")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "TagsProperty(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-gpdb.RosDBInstanceProps",
jsii_struct_bases=[],
name_mapping={
"engine_version": "engineVersion",
"v_switch_id": "vSwitchId",
"zone_id": "zoneId",
"create_sample_data": "createSampleData",
"db_instance_category": "dbInstanceCategory",
"db_instance_class": "dbInstanceClass",
"db_instance_description": "dbInstanceDescription",
"db_instance_group_count": "dbInstanceGroupCount",
"db_instance_mode": "dbInstanceMode",
"encryption_key": "encryptionKey",
"encryption_type": "encryptionType",
"idle_time": "idleTime",
"instance_spec": "instanceSpec",
"master_node_num": "masterNodeNum",
"pay_type": "payType",
"period": "period",
"period_unit": "periodUnit",
"private_ip_address": "privateIpAddress",
"security_ip_list": "securityIpList",
"seg_disk_performance_level": "segDiskPerformanceLevel",
"seg_node_num": "segNodeNum",
"seg_storage_type": "segStorageType",
"serverless_mode": "serverlessMode",
"serverless_resource": "serverlessResource",
"storage_size": "storageSize",
"tags": "tags",
"vector_configuration_status": "vectorConfigurationStatus",
"vpc_id": "vpcId",
},
)
class RosDBInstanceProps:
def __init__(
self,
*,
engine_version: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
v_switch_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
zone_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
create_sample_data: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
db_instance_category: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
db_instance_class: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
db_instance_description: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
db_instance_group_count: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
db_instance_mode: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
encryption_key: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
encryption_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
idle_time: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
instance_spec: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
master_node_num: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
pay_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
period: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
period_unit: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
private_ip_address: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
security_ip_list: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
seg_disk_performance_level: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
seg_node_num: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
seg_storage_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
serverless_mode: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
serverless_resource: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
storage_size: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
tags: typing.Optional[typing.Sequence[typing.Union[RosDBInstance.TagsProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
vector_configuration_status: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
vpc_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::GPDB::DBInstance``.
:param engine_version:
:param v_switch_id:
:param zone_id:
:param create_sample_data:
:param db_instance_category:
:param db_instance_class:
:param db_instance_description:
:param db_instance_group_count:
:param db_instance_mode:
:param encryption_key:
:param encryption_type:
:param idle_time:
:param instance_spec:
:param master_node_num:
:param pay_type:
:param period:
:param period_unit:
:param private_ip_address:
:param security_ip_list:
:param seg_disk_performance_level:
:param seg_node_num:
:param seg_storage_type:
:param serverless_mode:
:param serverless_resource:
:param storage_size:
:param tags:
:param vector_configuration_status:
:param vpc_id:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__721a4ff50df01d40cf6cc5df6e22043bfc3fa7f595e6f2b217c2b691258d6d17)
check_type(argname="argument engine_version", value=engine_version, expected_type=type_hints["engine_version"])
check_type(argname="argument v_switch_id", value=v_switch_id, expected_type=type_hints["v_switch_id"])
check_type(argname="argument zone_id", value=zone_id, expected_type=type_hints["zone_id"])
check_type(argname="argument create_sample_data", value=create_sample_data, expected_type=type_hints["create_sample_data"])
check_type(argname="argument db_instance_category", value=db_instance_category, expected_type=type_hints["db_instance_category"])
check_type(argname="argument db_instance_class", value=db_instance_class, expected_type=type_hints["db_instance_class"])
check_type(argname="argument db_instance_description", value=db_instance_description, expected_type=type_hints["db_instance_description"])
check_type(argname="argument db_instance_group_count", value=db_instance_group_count, expected_type=type_hints["db_instance_group_count"])
check_type(argname="argument db_instance_mode", value=db_instance_mode, expected_type=type_hints["db_instance_mode"])
check_type(argname="argument encryption_key", value=encryption_key, expected_type=type_hints["encryption_key"])
check_type(argname="argument encryption_type", value=encryption_type, expected_type=type_hints["encryption_type"])
check_type(argname="argument idle_time", value=idle_time, expected_type=type_hints["idle_time"])
check_type(argname="argument instance_spec", value=instance_spec, expected_type=type_hints["instance_spec"])
check_type(argname="argument master_node_num", value=master_node_num, expected_type=type_hints["master_node_num"])
check_type(argname="argument pay_type", value=pay_type, expected_type=type_hints["pay_type"])
check_type(argname="argument period", value=period, expected_type=type_hints["period"])
check_type(argname="argument period_unit", value=period_unit, expected_type=type_hints["period_unit"])
check_type(argname="argument private_ip_address", value=private_ip_address, expected_type=type_hints["private_ip_address"])
check_type(argname="argument security_ip_list", value=security_ip_list, expected_type=type_hints["security_ip_list"])
check_type(argname="argument seg_disk_performance_level", value=seg_disk_performance_level, expected_type=type_hints["seg_disk_performance_level"])
check_type(argname="argument seg_node_num", value=seg_node_num, expected_type=type_hints["seg_node_num"])
check_type(argname="argument seg_storage_type", value=seg_storage_type, expected_type=type_hints["seg_storage_type"])
check_type(argname="argument serverless_mode", value=serverless_mode, expected_type=type_hints["serverless_mode"])
check_type(argname="argument serverless_resource", value=serverless_resource, expected_type=type_hints["serverless_resource"])
check_type(argname="argument storage_size", value=storage_size, expected_type=type_hints["storage_size"])
check_type(argname="argument tags", value=tags, expected_type=type_hints["tags"])
check_type(argname="argument vector_configuration_status", value=vector_configuration_status, expected_type=type_hints["vector_configuration_status"])
check_type(argname="argument vpc_id", value=vpc_id, expected_type=type_hints["vpc_id"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"engine_version": engine_version,
"v_switch_id": v_switch_id,
"zone_id": zone_id,
}
if create_sample_data is not None:
self._values["create_sample_data"] = create_sample_data
if db_instance_category is not None:
self._values["db_instance_category"] = db_instance_category
if db_instance_class is not None:
self._values["db_instance_class"] = db_instance_class
if db_instance_description is not None:
self._values["db_instance_description"] = db_instance_description
if db_instance_group_count is not None:
self._values["db_instance_group_count"] = db_instance_group_count
if db_instance_mode is not None:
self._values["db_instance_mode"] = db_instance_mode
if encryption_key is not None:
self._values["encryption_key"] = encryption_key
if encryption_type is not None:
self._values["encryption_type"] = encryption_type
if idle_time is not None:
self._values["idle_time"] = idle_time
if instance_spec is not None:
self._values["instance_spec"] = instance_spec
if master_node_num is not None:
self._values["master_node_num"] = master_node_num
if pay_type is not None:
self._values["pay_type"] = pay_type
if period is not None:
self._values["period"] = period
if period_unit is not None:
self._values["period_unit"] = period_unit
if private_ip_address is not None:
self._values["private_ip_address"] = private_ip_address
if security_ip_list is not None:
self._values["security_ip_list"] = security_ip_list
if seg_disk_performance_level is not None:
self._values["seg_disk_performance_level"] = seg_disk_performance_level
if seg_node_num is not None:
self._values["seg_node_num"] = seg_node_num
if seg_storage_type is not None:
self._values["seg_storage_type"] = seg_storage_type
if serverless_mode is not None:
self._values["serverless_mode"] = serverless_mode
if serverless_resource is not None:
self._values["serverless_resource"] = serverless_resource
if storage_size is not None:
self._values["storage_size"] = storage_size
if tags is not None:
self._values["tags"] = tags
if vector_configuration_status is not None:
self._values["vector_configuration_status"] = vector_configuration_status
if vpc_id is not None:
self._values["vpc_id"] = vpc_id
@builtins.property
def engine_version(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: engineVersion: The version of the database engine. For example: 6.0、7.0
'''
result = self._values.get("engine_version")
assert result is not None, "Required property 'engine_version' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def v_switch_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: vSwitchId: The vSwitch ID of the instance.
'''
result = self._values.get("v_switch_id")
assert result is not None, "Required property 'v_switch_id' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def zone_id(self) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
zoneId: The zone ID of the instance, such as cn-hangzhou-d. You can call the DescribeRegions
operation to query the most recent zone list.
'''
result = self._values.get("zone_id")
assert result is not None, "Required property 'zone_id' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def create_sample_data(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
createSampleData: Whether to load the sample data set after the instance is created. The value can be:
true: load the sample dataset.
false: not to load the sample dataset
'''
result = self._values.get("create_sample_data")
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def db_instance_category(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
dbInstanceCategory: DB instance category, valid values: Basic, HighAvailability.
This parameter must be passed in to create a storage reservation mode instance.
'''
result = self._values.get("db_instance_category")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def db_instance_class(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: dbInstanceClass: The instance type.
'''
result = self._values.get("db_instance_class")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def db_instance_description(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: dbInstanceDescription: The description of the instance. The description cannot exceed 256 characters in length.
'''
result = self._values.get("db_instance_description")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def db_instance_group_count(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
dbInstanceGroupCount: The number of compute nodes in the instance.
The value can be 2, 4, 8, 12, 16, 24, 32, 64, 96, or 128.
'''
result = self._values.get("db_instance_group_count")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def db_instance_mode(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: dbInstanceMode: The db instance mode. Valid values: StorageElastic, Serverless, Classic.
'''
result = self._values.get("db_instance_mode")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def encryption_key(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: encryptionKey: If the EncryptionType parameter is set to CloudDisk, you must specify this parameter to the encryption key that is in the same region with the disks that is specified by the EncryptionType parameter. Otherwise, leave this parameter empty.
'''
result = self._values.get("encryption_key")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def encryption_type(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
encryptionType: The type of the encryption. Default value: NULL. Valid values:
NULL: Encryption is disabled.
CloudDisk: Encryption is enabled on disks and the encryption key is specified by using the EncryptionKey parameter.
Note: Disk encryption cannot be disabled after it is enabled.
'''
result = self._values.get("encryption_type")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def idle_time(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: idleTime: Idle release wait time. That is, when the period of no service traffic reaches the specified period, the instance becomes idle. The unit is second. The minimum value is 60. The default value is 600.
'''
result = self._values.get("idle_time")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def instance_spec(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
instanceSpec: The specification of segment nodes.
- When DBInstanceCategory is HighAvailability, Valid values: 2C16G, 4C32G, 8C64G, 16C128G.
- When DBInstanceCategory is Basic, Valid values: 2C8G, 4C16G, 8C32G, 16C64G.
- When DBInstanceCategory is Serverless, Valid values: 4C16G, 8C32G.
This parameter must be passed to create a storage elastic mode instance and a serverless version instance.
'''
result = self._values.get("instance_spec")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def master_node_num(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: masterNodeNum: The number of master nodes. Minimum is 1, max is 2.
'''
result = self._values.get("master_node_num")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def pay_type(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
payType: The billing method of the instance. Default value: Postpaid. Valid values:
Postpaid: pay-as-you-go
Prepaid: subscription
'''
result = self._values.get("pay_type")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def period(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: period: The subscription period. While choose by pay by month, it could be from 1 to 11. While choose pay by year, it could be from 1 to 3.
'''
result = self._values.get("period")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def period_unit(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: periodUnit: Unit of subscription period, it could be Month/Year. Default value is Month.
'''
result = self._values.get("period_unit")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def private_ip_address(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: privateIpAddress: Private IP address.
'''
result = self._values.get("private_ip_address")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def security_ip_list(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
securityIpList: The whitelist of IP addresses that are allowed to access the instance. Default value:
127.0.0.1.
'''
result = self._values.get("security_ip_list")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def seg_disk_performance_level(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
segDiskPerformanceLevel: Seg disk performance level. The value can be:
pl0、pl1 and pl2
'''
result = self._values.get("seg_disk_performance_level")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def seg_node_num(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
segNodeNum: Calculate the number of nodes. The value can be:
- When DBInstanceMode is StorageElastic and DBInstanceCategory is HighAvailability, the value ranges from 4 to 512. The value must be a multiple of 4.
- When DBInstanceMode is StorageElastic and DBInstanceCategory is Basic, the value ranges from 2 to 512. The value must be a multiple of 2.
- When DBInstanceMode is Serverless, The value ranges from 2 to 512. The value must be a multiple of 2.
'''
result = self._values.get("seg_node_num")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def seg_storage_type(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
segStorageType: The disk type of segment nodes. For example: cloud_essd, cloud_efficiency.
This parameter must be passed in to create a storage elastic mode instance.
Storage Elastic Mode Basic Edition instances only support ESSD cloud disks.
'''
result = self._values.get("seg_storage_type")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def serverless_mode(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
serverlessMode: Mode of the Serverless instance. The value can be:
Manual: manual scheduling is the default value.
Auto: indicates automatic scheduling.
'''
result = self._values.get("serverless_mode")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def serverless_resource(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
serverlessResource: Computing resource threshold. The value ranges from 8 to 32. The step length is 8.
The unit is ACU. The default value is 32.
'''
result = self._values.get("serverless_resource")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def storage_size(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: storageSize: The storage capacity of per segment node. Unit: GB. Minimum is 50, max is 4000, step is 50.
'''
result = self._values.get("storage_size")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def tags(self) -> typing.Optional[typing.List[RosDBInstance.TagsProperty]]:
'''
:Property: tags: Tags to attach to instance. Max support 20 tags to add during create instance. Each tag with two properties Key and Value, and Key is required.
'''
result = self._values.get("tags")
return typing.cast(typing.Optional[typing.List[RosDBInstance.TagsProperty]], result)
@builtins.property
def vector_configuration_status(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: vectorConfigurationStatus: the status of vector configuration. The value can be:Y: Turn on vector engine optimization.N: Turn off vector engine optimization (default value).
'''
result = self._values.get("vector_configuration_status")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def vpc_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
vpcId: The VPC ID of the instance. If you set the InstanceNetworkType parameter to VPC, you
must also specify the VPCId parameter. The specified region of the VPC must be the
same as the RegionId value.
'''
result = self._values.get("vpc_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "RosDBInstanceProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class RosElasticDBInstance(
_ros_cdk_core_7adfd82f.RosResource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-gpdb.RosElasticDBInstance",
):
'''A ROS template type: ``ALIYUN::GPDB::ElasticDBInstance``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["RosElasticDBInstanceProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
'''Create a new ``ALIYUN::GPDB::ElasticDBInstance``.
:param scope: - scope in which this resource is defined.
:param id: - scoped id of the resource.
:param props: - resource properties.
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__89aad62043fc84e59bcce114e39f1f5fba3318425c1acece48c74056d4c1ca68)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@jsii.member(jsii_name="renderProperties")
def _render_properties(
self,
props: typing.Mapping[builtins.str, typing.Any],
) -> typing.Mapping[builtins.str, typing.Any]:
'''
:param props: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__96d0fef3e1b16e30f97861f68a50b00f0477a22bf3d3d6a150ad4ec108b9fbdb)
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))
@jsii.python.classproperty
@jsii.member(jsii_name="ROS_RESOURCE_TYPE_NAME")
def ROS_RESOURCE_TYPE_NAME(cls) -> builtins.str:
'''The resource type name for this resource class.'''
return typing.cast(builtins.str, jsii.sget(cls, "ROS_RESOURCE_TYPE_NAME"))
@builtins.property
@jsii.member(jsii_name="attrConnectionString")
def attr_connection_string(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: ConnectionString: The endpoint of the instance.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrConnectionString"))
@builtins.property
@jsii.member(jsii_name="attrDbInstanceId")
def attr_db_instance_id(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: DBInstanceId: The ID of the instance.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrDbInstanceId"))
@builtins.property
@jsii.member(jsii_name="attrOrderId")
def attr_order_id(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: OrderId: The order ID of the instance.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrOrderId"))
@builtins.property
@jsii.member(jsii_name="attrPort")
def attr_port(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: Port: The port used to connect to the instance.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrPort"))
@builtins.property
@jsii.member(jsii_name="rosProperties")
def _ros_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "rosProperties"))
@builtins.property
@jsii.member(jsii_name="enableResourcePropertyConstraint")
def enable_resource_property_constraint(self) -> builtins.bool:
return typing.cast(builtins.bool, jsii.get(self, "enableResourcePropertyConstraint"))
@enable_resource_property_constraint.setter
def enable_resource_property_constraint(self, value: builtins.bool) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__50c15121cbf6399e2ada1d3597ac27d96b6437f8e0347fbffa6e6cc160a1ad38)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "enableResourcePropertyConstraint", value)
@builtins.property
@jsii.member(jsii_name="engineVersion")
def engine_version(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: engineVersion: The version of the database engine. For example: 6.0、7.0
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "engineVersion"))
@engine_version.setter
def engine_version(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__b799c1963b9eff6466440e4ac85f13235c4ece45cd3183faca5404e5c8d710c6)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "engineVersion", value)
@builtins.property
@jsii.member(jsii_name="instanceSpec")
def instance_spec(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: instanceSpec: The specification of segment nodes. For example: 2C16G, 4C32G, 16C128G.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "instanceSpec"))
@instance_spec.setter
def instance_spec(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__15376d6a87045e74fb702444b606698d53c4345e02ea16e3da7951f0ce847662)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "instanceSpec", value)
@builtins.property
@jsii.member(jsii_name="segNodeNum")
def seg_node_num(
self,
) -> typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
segNodeNum: The number of segment nodes.
For the high availability version, the value ranges from 4 to 512.
The basic version ranges from 2 to 512.
'''
return typing.cast(typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "segNodeNum"))
@seg_node_num.setter
def seg_node_num(
self,
value: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__7eedd66b72c81a92aaeeb432556f363f974c62907cce508ad2779e49da9d6ca9)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "segNodeNum", value)
@builtins.property
@jsii.member(jsii_name="segStorageType")
def seg_storage_type(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: segStorageType: The disk type of segment nodes. For example: cloud_essd, cloud_efficiency.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "segStorageType"))
@seg_storage_type.setter
def seg_storage_type(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__cc128867dd5a4f68bbf675d380e093963847d79bc7234e714da71896b8ba1e67)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "segStorageType", value)
@builtins.property
@jsii.member(jsii_name="storageSize")
def storage_size(
self,
) -> typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: storageSize: The storage capacity of per segment node. Unit: GB. Minimum is 50, max is 4000, step is 50.
'''
return typing.cast(typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "storageSize"))
@storage_size.setter
def storage_size(
self,
value: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__4cb4bc51217bdf168b5b57a8f65efc60a09486a98396df706f29fb3026d609c6)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "storageSize", value)
@builtins.property
@jsii.member(jsii_name="vSwitchId")
def v_switch_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: vSwitchId: The vSwitch ID of the instance.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "vSwitchId"))
@v_switch_id.setter
def v_switch_id(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__570ec1d9eabd46950d0d6f95eb32f1ee5e0a55c5c5e2e7c31fa8d3c1780f94b3)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "vSwitchId", value)
@builtins.property
@jsii.member(jsii_name="zoneId")
def zone_id(self) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
zoneId: The zone ID of the instance, such as cn-hangzhou-d. You can call the DescribeRegions
operation to query the most recent zone list.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "zoneId"))
@zone_id.setter
def zone_id(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__8623cfccaf53796a6d75c78092cef0d666d35e814c8a70eb13efa75b4c258835)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "zoneId", value)
@builtins.property
@jsii.member(jsii_name="dbInstanceCategory")
def db_instance_category(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
dbInstanceCategory: DB instance category, valid values: Basic, HighAvailability.
This parameter must be passed in to create a storage reservation mode instance.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "dbInstanceCategory"))
@db_instance_category.setter
def db_instance_category(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__47a267c22b746bfa31008a52240fb91b683896c8ea0c6094bd6c35ca154b751f)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "dbInstanceCategory", value)
@builtins.property
@jsii.member(jsii_name="dbInstanceDescription")
def db_instance_description(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: dbInstanceDescription: The description of the instance. The description cannot exceed 256 characters in length.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "dbInstanceDescription"))
@db_instance_description.setter
def db_instance_description(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__950b1ce01b1a36695f6f39c2c585d7f2d6045bc350bcd0375652338a07eac41e)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "dbInstanceDescription", value)
@builtins.property
@jsii.member(jsii_name="dbInstanceMode")
def db_instance_mode(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: dbInstanceMode: The db instance mode. Valid values: StorageElastic, Serverless, Classic.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "dbInstanceMode"))
@db_instance_mode.setter
def db_instance_mode(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__ed0c99dccbf0fbd41851a69a0ef3bf0fe151efda5f629a326407f1c07c9da102)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "dbInstanceMode", value)
@builtins.property
@jsii.member(jsii_name="encryptionKey")
def encryption_key(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: encryptionKey: If the EncryptionType parameter is set to CloudDisk, you must specify this parameter to the encryption key that is in the same region with the disks that is specified by the EncryptionType parameter. Otherwise, leave this parameter empty.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "encryptionKey"))
@encryption_key.setter
def encryption_key(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__310b3630773edc96ac6b9024afe182b8d1ac1af210ed8cdffd51f251a0dea6ca)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "encryptionKey", value)
@builtins.property
@jsii.member(jsii_name="encryptionType")
def encryption_type(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
encryptionType: The type of the encryption. Default value: NULL. Valid values:
NULL: Encryption is disabled.
CloudDisk: Encryption is enabled on disks and the encryption key is specified by using the EncryptionKey parameter.
Note: Disk encryption cannot be disabled after it is enabled.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "encryptionType"))
@encryption_type.setter
def encryption_type(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__0f80ad582306607618031c89d0439be17a886521fbffe815f8a9ec5f83a9ac11)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "encryptionType", value)
@builtins.property
@jsii.member(jsii_name="masterNodeNum")
def master_node_num(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: masterNodeNum: The number of master nodes. Minimum is 1, max is 2.
'''
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "masterNodeNum"))
@master_node_num.setter
def master_node_num(
self,
value: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__a3e8e58aff6a052b8e2b3714a8bee52a496045b377f3eae99c71f60654599b40)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "masterNodeNum", value)
@builtins.property
@jsii.member(jsii_name="payType")
def pay_type(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
payType: The billing method of the instance. Default value: Postpaid. Valid values:
Postpaid: pay-as-you-go
Prepaid: subscription
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "payType"))
@pay_type.setter
def pay_type(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__43aba30bf680fed838bb422e5545c751b74676599cbb589a5b8ea50811dd406c)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "payType", value)
@builtins.property
@jsii.member(jsii_name="period")
def period(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: period: The subscription period. While choose by pay by month, it could be from 1 to 11. While choose pay by year, it could be from 1 to 3.
'''
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "period"))
@period.setter
def period(
self,
value: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__d57e4d182177e6047812ba9300106e4e448e3a3d3dc1c2441b6187da2e0f9de0)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "period", value)
@builtins.property
@jsii.member(jsii_name="periodUnit")
def period_unit(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: periodUnit: Unit of subscription period, it could be Month/Year. Default value is Month.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "periodUnit"))
@period_unit.setter
def period_unit(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__d6e15a58fd553875254acc185ace46762b5b3d72716260dd639b1978df6dcf12)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "periodUnit", value)
@builtins.property
@jsii.member(jsii_name="privateIpAddress")
def private_ip_address(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: privateIpAddress: Private IP address.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "privateIpAddress"))
@private_ip_address.setter
def private_ip_address(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__8a31c10c10daf16d59549dc46f7ca7bc3ef08b93e7a506e917ddb3866d01c14c)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "privateIpAddress", value)
@builtins.property
@jsii.member(jsii_name="securityIpList")
def security_ip_list(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
securityIpList: The whitelist of IP addresses that are allowed to access the instance. Default value:
127.0.0.1.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "securityIpList"))
@security_ip_list.setter
def security_ip_list(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__af80656e48bb08e8689717aa223478637f2f738b1c63c1ade0bd2f1d7a1a2e9d)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "securityIpList", value)
@builtins.property
@jsii.member(jsii_name="tags")
def tags(self) -> typing.Optional[typing.List["RosElasticDBInstance.TagsProperty"]]:
'''
:Property: tags: Tags to attach to instance. Max support 20 tags to add during create instance. Each tag with two properties Key and Value, and Key is required.
'''
return typing.cast(typing.Optional[typing.List["RosElasticDBInstance.TagsProperty"]], jsii.get(self, "tags"))
@tags.setter
def tags(
self,
value: typing.Optional[typing.List["RosElasticDBInstance.TagsProperty"]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__360b928c6fda2ec27ee1a719fbccad942a961d5bb9984d3b870e4fe7e3fb7e8a)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "tags", value)
@builtins.property
@jsii.member(jsii_name="vpcId")
def vpc_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
vpcId: The VPC ID of the instance. If you set the InstanceNetworkType parameter to VPC, you
must also specify the VPCId parameter. The specified region of the VPC must be the
same as the RegionId value.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "vpcId"))
@vpc_id.setter
def vpc_id(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__d6007f8297c4e20b3a55b15e1493d543ccdd7522b1113b81cd3054841acc1f7e)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "vpcId", value)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-gpdb.RosElasticDBInstance.TagsProperty",
jsii_struct_bases=[],
name_mapping={"key": "key", "value": "value"},
)
class TagsProperty:
def __init__(
self,
*,
key: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''
:param key:
:param value:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__4359d0b218a824b953b984fe52c61b8bf1c6987f32a9ed206eaa1f2c9c8c818b)
check_type(argname="argument key", value=key, expected_type=type_hints["key"])
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"key": key,
}
if value is not None:
self._values["value"] = value
@builtins.property
def key(self) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: key: undefined
'''
result = self._values.get("key")
assert result is not None, "Required property 'key' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def value(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: value: undefined
'''
result = self._values.get("value")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "TagsProperty(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-gpdb.RosElasticDBInstanceProps",
jsii_struct_bases=[],
name_mapping={
"engine_version": "engineVersion",
"instance_spec": "instanceSpec",
"seg_node_num": "segNodeNum",
"seg_storage_type": "segStorageType",
"storage_size": "storageSize",
"v_switch_id": "vSwitchId",
"zone_id": "zoneId",
"db_instance_category": "dbInstanceCategory",
"db_instance_description": "dbInstanceDescription",
"db_instance_mode": "dbInstanceMode",
"encryption_key": "encryptionKey",
"encryption_type": "encryptionType",
"master_node_num": "masterNodeNum",
"pay_type": "payType",
"period": "period",
"period_unit": "periodUnit",
"private_ip_address": "privateIpAddress",
"security_ip_list": "securityIpList",
"tags": "tags",
"vpc_id": "vpcId",
},
)
class RosElasticDBInstanceProps:
def __init__(
self,
*,
engine_version: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
instance_spec: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
seg_node_num: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
seg_storage_type: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
storage_size: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
v_switch_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
zone_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
db_instance_category: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
db_instance_description: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
db_instance_mode: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
encryption_key: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
encryption_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
master_node_num: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
pay_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
period: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
period_unit: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
private_ip_address: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
security_ip_list: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
tags: typing.Optional[typing.Sequence[typing.Union[RosElasticDBInstance.TagsProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
vpc_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::GPDB::ElasticDBInstance``.
:param engine_version:
:param instance_spec:
:param seg_node_num:
:param seg_storage_type:
:param storage_size:
:param v_switch_id:
:param zone_id:
:param db_instance_category:
:param db_instance_description:
:param db_instance_mode:
:param encryption_key:
:param encryption_type:
:param master_node_num:
:param pay_type:
:param period:
:param period_unit:
:param private_ip_address:
:param security_ip_list:
:param tags:
:param vpc_id:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__a0afafad2a21ec89df64c7cdb9a4a66a33d1b29a4b59f958823aa1060aabae4f)
check_type(argname="argument engine_version", value=engine_version, expected_type=type_hints["engine_version"])
check_type(argname="argument instance_spec", value=instance_spec, expected_type=type_hints["instance_spec"])
check_type(argname="argument seg_node_num", value=seg_node_num, expected_type=type_hints["seg_node_num"])
check_type(argname="argument seg_storage_type", value=seg_storage_type, expected_type=type_hints["seg_storage_type"])
check_type(argname="argument storage_size", value=storage_size, expected_type=type_hints["storage_size"])
check_type(argname="argument v_switch_id", value=v_switch_id, expected_type=type_hints["v_switch_id"])
check_type(argname="argument zone_id", value=zone_id, expected_type=type_hints["zone_id"])
check_type(argname="argument db_instance_category", value=db_instance_category, expected_type=type_hints["db_instance_category"])
check_type(argname="argument db_instance_description", value=db_instance_description, expected_type=type_hints["db_instance_description"])
check_type(argname="argument db_instance_mode", value=db_instance_mode, expected_type=type_hints["db_instance_mode"])
check_type(argname="argument encryption_key", value=encryption_key, expected_type=type_hints["encryption_key"])
check_type(argname="argument encryption_type", value=encryption_type, expected_type=type_hints["encryption_type"])
check_type(argname="argument master_node_num", value=master_node_num, expected_type=type_hints["master_node_num"])
check_type(argname="argument pay_type", value=pay_type, expected_type=type_hints["pay_type"])
check_type(argname="argument period", value=period, expected_type=type_hints["period"])
check_type(argname="argument period_unit", value=period_unit, expected_type=type_hints["period_unit"])
check_type(argname="argument private_ip_address", value=private_ip_address, expected_type=type_hints["private_ip_address"])
check_type(argname="argument security_ip_list", value=security_ip_list, expected_type=type_hints["security_ip_list"])
check_type(argname="argument tags", value=tags, expected_type=type_hints["tags"])
check_type(argname="argument vpc_id", value=vpc_id, expected_type=type_hints["vpc_id"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"engine_version": engine_version,
"instance_spec": instance_spec,
"seg_node_num": seg_node_num,
"seg_storage_type": seg_storage_type,
"storage_size": storage_size,
"v_switch_id": v_switch_id,
"zone_id": zone_id,
}
if db_instance_category is not None:
self._values["db_instance_category"] = db_instance_category
if db_instance_description is not None:
self._values["db_instance_description"] = db_instance_description
if db_instance_mode is not None:
self._values["db_instance_mode"] = db_instance_mode
if encryption_key is not None:
self._values["encryption_key"] = encryption_key
if encryption_type is not None:
self._values["encryption_type"] = encryption_type
if master_node_num is not None:
self._values["master_node_num"] = master_node_num
if pay_type is not None:
self._values["pay_type"] = pay_type
if period is not None:
self._values["period"] = period
if period_unit is not None:
self._values["period_unit"] = period_unit
if private_ip_address is not None:
self._values["private_ip_address"] = private_ip_address
if security_ip_list is not None:
self._values["security_ip_list"] = security_ip_list
if tags is not None:
self._values["tags"] = tags
if vpc_id is not None:
self._values["vpc_id"] = vpc_id
@builtins.property
def engine_version(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: engineVersion: The version of the database engine. For example: 6.0、7.0
'''
result = self._values.get("engine_version")
assert result is not None, "Required property 'engine_version' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def instance_spec(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: instanceSpec: The specification of segment nodes. For example: 2C16G, 4C32G, 16C128G.
'''
result = self._values.get("instance_spec")
assert result is not None, "Required property 'instance_spec' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def seg_node_num(
self,
) -> typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
segNodeNum: The number of segment nodes.
For the high availability version, the value ranges from 4 to 512.
The basic version ranges from 2 to 512.
'''
result = self._values.get("seg_node_num")
assert result is not None, "Required property 'seg_node_num' is missing"
return typing.cast(typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def seg_storage_type(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: segStorageType: The disk type of segment nodes. For example: cloud_essd, cloud_efficiency.
'''
result = self._values.get("seg_storage_type")
assert result is not None, "Required property 'seg_storage_type' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def storage_size(
self,
) -> typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: storageSize: The storage capacity of per segment node. Unit: GB. Minimum is 50, max is 4000, step is 50.
'''
result = self._values.get("storage_size")
assert result is not None, "Required property 'storage_size' is missing"
return typing.cast(typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def v_switch_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: vSwitchId: The vSwitch ID of the instance.
'''
result = self._values.get("v_switch_id")
assert result is not None, "Required property 'v_switch_id' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def zone_id(self) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
zoneId: The zone ID of the instance, such as cn-hangzhou-d. You can call the DescribeRegions
operation to query the most recent zone list.
'''
result = self._values.get("zone_id")
assert result is not None, "Required property 'zone_id' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def db_instance_category(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
dbInstanceCategory: DB instance category, valid values: Basic, HighAvailability.
This parameter must be passed in to create a storage reservation mode instance.
'''
result = self._values.get("db_instance_category")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def db_instance_description(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: dbInstanceDescription: The description of the instance. The description cannot exceed 256 characters in length.
'''
result = self._values.get("db_instance_description")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def db_instance_mode(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: dbInstanceMode: The db instance mode. Valid values: StorageElastic, Serverless, Classic.
'''
result = self._values.get("db_instance_mode")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def encryption_key(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: encryptionKey: If the EncryptionType parameter is set to CloudDisk, you must specify this parameter to the encryption key that is in the same region with the disks that is specified by the EncryptionType parameter. Otherwise, leave this parameter empty.
'''
result = self._values.get("encryption_key")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def encryption_type(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
encryptionType: The type of the encryption. Default value: NULL. Valid values:
NULL: Encryption is disabled.
CloudDisk: Encryption is enabled on disks and the encryption key is specified by using the EncryptionKey parameter.
Note: Disk encryption cannot be disabled after it is enabled.
'''
result = self._values.get("encryption_type")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def master_node_num(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: masterNodeNum: The number of master nodes. Minimum is 1, max is 2.
'''
result = self._values.get("master_node_num")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def pay_type(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
payType: The billing method of the instance. Default value: Postpaid. Valid values:
Postpaid: pay-as-you-go
Prepaid: subscription
'''
result = self._values.get("pay_type")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def period(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: period: The subscription period. While choose by pay by month, it could be from 1 to 11. While choose pay by year, it could be from 1 to 3.
'''
result = self._values.get("period")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def period_unit(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: periodUnit: Unit of subscription period, it could be Month/Year. Default value is Month.
'''
result = self._values.get("period_unit")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def private_ip_address(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: privateIpAddress: Private IP address.
'''
result = self._values.get("private_ip_address")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def security_ip_list(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
securityIpList: The whitelist of IP addresses that are allowed to access the instance. Default value:
127.0.0.1.
'''
result = self._values.get("security_ip_list")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def tags(self) -> typing.Optional[typing.List[RosElasticDBInstance.TagsProperty]]:
'''
:Property: tags: Tags to attach to instance. Max support 20 tags to add during create instance. Each tag with two properties Key and Value, and Key is required.
'''
result = self._values.get("tags")
return typing.cast(typing.Optional[typing.List[RosElasticDBInstance.TagsProperty]], result)
@builtins.property
def vpc_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
vpcId: The VPC ID of the instance. If you set the InstanceNetworkType parameter to VPC, you
must also specify the VPCId parameter. The specified region of the VPC must be the
same as the RegionId value.
'''
result = self._values.get("vpc_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "RosElasticDBInstanceProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class RosInstancePublicConnection(
_ros_cdk_core_7adfd82f.RosResource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-gpdb.RosInstancePublicConnection",
):
'''A ROS template type: ``ALIYUN::GPDB::InstancePublicConnection``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["RosInstancePublicConnectionProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
'''Create a new ``ALIYUN::GPDB::InstancePublicConnection``.
:param scope: - scope in which this resource is defined.
:param id: - scoped id of the resource.
:param props: - resource properties.
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__d8b3b81c34939efe9d78314664a2eeccdf6fc228139638e9d4f0b202bb0d25b2)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@jsii.member(jsii_name="renderProperties")
def _render_properties(
self,
props: typing.Mapping[builtins.str, typing.Any],
) -> typing.Mapping[builtins.str, typing.Any]:
'''
:param props: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__4a9767bb77e51c7b3ed6d48f280e37e2bbad92ceb53569209a655b82fe389857)
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))
@jsii.python.classproperty
@jsii.member(jsii_name="ROS_RESOURCE_TYPE_NAME")
def ROS_RESOURCE_TYPE_NAME(cls) -> builtins.str:
'''The resource type name for this resource class.'''
return typing.cast(builtins.str, jsii.sget(cls, "ROS_RESOURCE_TYPE_NAME"))
@builtins.property
@jsii.member(jsii_name="attrConnectionString")
def attr_connection_string(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: ConnectionString: The connection string of the instance.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrConnectionString"))
@builtins.property
@jsii.member(jsii_name="attrDbInstanceId")
def attr_db_instance_id(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: DBInstanceId: The ID of the instance.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrDbInstanceId"))
@builtins.property
@jsii.member(jsii_name="rosProperties")
def _ros_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "rosProperties"))
@builtins.property
@jsii.member(jsii_name="connectionStringPrefix")
def connection_string_prefix(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: connectionStringPrefix: The endpoint that is used to connect to the specified database.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "connectionStringPrefix"))
@connection_string_prefix.setter
def connection_string_prefix(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__7e0c76e0183cf7f848b7df9af05b08ccd2e0b16ccca4dea3a8287234190bb8d5)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "connectionStringPrefix", value)
@builtins.property
@jsii.member(jsii_name="dbInstanceId")
def db_instance_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: dbInstanceId: The ID of the instance.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "dbInstanceId"))
@db_instance_id.setter
def db_instance_id(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__e063fe00164d14c9efedb6793a6fd31cb97d0276b17a3f59d33a97a33431fb34)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "dbInstanceId", value)
@builtins.property
@jsii.member(jsii_name="enableResourcePropertyConstraint")
def enable_resource_property_constraint(self) -> builtins.bool:
return typing.cast(builtins.bool, jsii.get(self, "enableResourcePropertyConstraint"))
@enable_resource_property_constraint.setter
def enable_resource_property_constraint(self, value: builtins.bool) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__88dcab8f968673bb2972d3617c0b8382b04cd443a1a8d55bb093722a5b7c2a6c)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "enableResourcePropertyConstraint", value)
@builtins.property
@jsii.member(jsii_name="port")
def port(self) -> typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: port: The port number of the instance.
'''
return typing.cast(typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "port"))
@port.setter
def port(
self,
value: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__48996cfd06449b1b5a352bddf9b867de8323bcd93daabf22440ad247633dbb5b)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "port", value)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-gpdb.RosInstancePublicConnectionProps",
jsii_struct_bases=[],
name_mapping={
"connection_string_prefix": "connectionStringPrefix",
"db_instance_id": "dbInstanceId",
"port": "port",
},
)
class RosInstancePublicConnectionProps:
def __init__(
self,
*,
connection_string_prefix: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
db_instance_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
port: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
'''Properties for defining a ``ALIYUN::GPDB::InstancePublicConnection``.
:param connection_string_prefix:
:param db_instance_id:
:param port:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__f221b5354b5add6fc90e82f2074bfa127043100889621ee12aa4521347a66c8c)
check_type(argname="argument connection_string_prefix", value=connection_string_prefix, expected_type=type_hints["connection_string_prefix"])
check_type(argname="argument db_instance_id", value=db_instance_id, expected_type=type_hints["db_instance_id"])
check_type(argname="argument port", value=port, expected_type=type_hints["port"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"connection_string_prefix": connection_string_prefix,
"db_instance_id": db_instance_id,
"port": port,
}
@builtins.property
def connection_string_prefix(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: connectionStringPrefix: The endpoint that is used to connect to the specified database.
'''
result = self._values.get("connection_string_prefix")
assert result is not None, "Required property 'connection_string_prefix' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def db_instance_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: dbInstanceId: The ID of the instance.
'''
result = self._values.get("db_instance_id")
assert result is not None, "Required property 'db_instance_id' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def port(self) -> typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: port: The port number of the instance.
'''
result = self._values.get("port")
assert result is not None, "Required property 'port' is missing"
return typing.cast(typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "RosInstancePublicConnectionProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
__all__ = [
"Account",
"AccountProps",
"DBInstance",
"DBInstanceProps",
"ElasticDBInstance",
"ElasticDBInstanceProps",
"InstancePublicConnection",
"InstancePublicConnectionProps",
"RosAccount",
"RosAccountProps",
"RosDBInstance",
"RosDBInstanceProps",
"RosElasticDBInstance",
"RosElasticDBInstanceProps",
"RosInstancePublicConnection",
"RosInstancePublicConnectionProps",
]
publication.publish()
def _typecheckingstub__626fe14fa2d762e0dcc84a1a0b1aa4d97e6714972017d08eb58355a1dc21fa87(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[AccountProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__b896ba00b09a90fabeb323569de4d08bb539272ddca78c295a33f0782800bf96(
*,
account_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
account_password: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
db_instance_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
account_description: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__0ac5d3d197db2461e111c98b052eeee02d0fc03f17a683073e66a3d597f7a030(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[DBInstanceProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__777da448732a953451d42cdf65572b1b2e1df0fbb772a44ee39827922339ff39(
*,
engine_version: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
v_switch_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
zone_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
create_sample_data: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
db_instance_category: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
db_instance_class: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
db_instance_description: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
db_instance_group_count: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
db_instance_mode: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
encryption_key: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
encryption_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
idle_time: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
instance_spec: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
master_node_num: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
pay_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
period: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
period_unit: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
private_ip_address: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
security_ip_list: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
seg_disk_performance_level: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
seg_node_num: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
seg_storage_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
serverless_mode: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
serverless_resource: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
storage_size: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
tags: typing.Optional[typing.Sequence[typing.Union[RosDBInstance.TagsProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
vector_configuration_status: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
vpc_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__afb41ab807caa4ef994103ba46105f295d1116b7a47d1f04b83115ed59994f69(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[ElasticDBInstanceProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__b50bd0f1c53fcb1f2492c8e557bc5a1871227ec9e19eb918772302abd834fde8(
*,
engine_version: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
instance_spec: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
seg_node_num: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
seg_storage_type: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
storage_size: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
v_switch_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
zone_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
db_instance_category: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
db_instance_description: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
db_instance_mode: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
encryption_key: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
encryption_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
master_node_num: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
pay_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
period: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
period_unit: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
private_ip_address: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
security_ip_list: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
tags: typing.Optional[typing.Sequence[typing.Union[RosElasticDBInstance.TagsProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
vpc_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__aea14d34091cbdf41869d8355483911a5f080c68068fdefbfed38f85b972a571(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[InstancePublicConnectionProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__cee4236c08b63e7091ee29fd6b36fa1e107bdee356282b75ce12080220ff78e5(
*,
connection_string_prefix: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
db_instance_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
port: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__56c85415ad5c3a2e3fa6805fa8f045cbda34d54e214235afb4e03c69085b814f(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[RosAccountProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__bf297c10f14eeed3e89f98a84988016d65e3fc269af72f1a3d3fe0b5295b405c(
props: typing.Mapping[builtins.str, typing.Any],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__64b2b15304e8ed8a75fe6ec84d6ee1d069c05d764dc913deb233fcb9d7ba7fe4(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__db96de02923d764a6f7f5fbff83f18ad66a1135ba5cd21ba0837465a761370c8(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__edb7fa52bc478dfcd68abf8e4f9b72455171caac9a9f3dca5eb94c25479e3786(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__60f7e8657e3def39d0e384cc415b6de1f3b9d73f1a62ae3e3d3d3b4b06f7416d(
value: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__806ced7a73d7e8844f06c183a7add7244719a7f5c58cf75e2ede4bd44d54bb4e(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__dde61a3e29477468f8d60e9b12d581b8e8c20d15f25c8b5f24c4998dec7db5a1(
*,
account_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
account_password: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
db_instance_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
account_description: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__e1ac5871bdf5eda60758a3f56134d6bc536d3421427c8646056634dd28789b93(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[RosDBInstanceProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__b4da4a02ca6762649ce6d834482ce0cec1bd252e488ee806453ce13274969a99(
props: typing.Mapping[builtins.str, typing.Any],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__097e69af8a79977a70b892c24dc58d52a0ca7d25d25a7a0128cd7643b2f5ad71(
value: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__03aea9fd80f1bcd09f065453fee4935e1e938640d10a779957681841e21febf9(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__8d2018019c2d652687405116b0a267d95331ea4ac129fcaa6f42ffcfc3ea0811(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__b3c51d9ed5ee9683f1aa565eefd5604341299f1107fafad10f12a24199e71eaa(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__1f9d5e65e164f80bf0197e5a576d49253759a0ed9c3a1afb39b7bdb66a230964(
value: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__e5f01851b432982057eb6fa3bccf9fb9741a32f77e543624fde8e0241d7051cc(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__5770ba995a64bc46d7478a45b687eea2e3de524d8aa9d6314701b8ad10ab58b8(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__de2ea367343456b3819fece649d82be3622bda8ba238834af2e0a7c97e55cb32(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__7bdad23d1b60401833f10a183b23ed0f4938313167e7e46180a1a5a937fe87cf(
value: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__78488974967dd6df1f37bd9f6cf018ba8a9d83a2590c9204cb7f10a9c4a81e4f(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__41ddabcaa8a9058f28282ba1b3acbb8a9fe853c829fc9fe936f9ede218a03f97(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__102b536a47bfa185aab366f8fda7bc6c0de44967f96be577626d6321a7673b97(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__e3d5f75f23a3cb3acc7dcd4b18c0e00b4699e931aa40354b4af9565bbf829020(
value: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__855903d76f2238be44b32d350988a2219600c43f51719ad00b13e87c11a7707f(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__a7cf00876e4beb50e61c2f63b02445b537ffc2d44316f4d016df7276085228b6(
value: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__a1d771433f9bbebba21253100d385479413da746005cd80b3ca1494d46697520(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__4e9877d63ce7eb2ba0d47c72ab9d1b1352548afe3670db61f8b27e9bb9c3e497(
value: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__9ae419b93987a5b888a593ee77c7453f6e3ada09b43dc097006ecccfdf9ecd95(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__83379ba95901c4a4ededccc633d12d97e2f7d20ea9153bf99f76075ba0a3706a(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__fc6fb832af7389686cba9ec143f920189f9c1f68029961d804a3a40891e827fe(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__511db6d48b32b9e12af31b2f44ba94c0a56e5ffc0020d59e1a8f42d0de01f4c3(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__e986928180e4e4678640741471e6c349e5c5254ae5e590f27ea0b9637ca5cee7(
value: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__d03d862a7372f5bd7810819fdeda4cee6066f6d68dab3b3283fbd65ff9036146(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__18b1ba84740f2e0a74f8213f5d25dd03b2ee9c7462b52c6ab7248b34a26e29ea(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__83517dd393c6a5df9536a6714988bf4c5d3d1c35068ae0c87499f7cae6473a57(
value: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__727f55d1217544aa020d986509ea115734756524206fc5f8b42cf7af1bed1762(
value: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__00ad71ac7fe2c264ec20770b02fffd8b3af4ee4a02aeb9adc8a253fc98875a56(
value: typing.Optional[typing.List[RosDBInstance.TagsProperty]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__f66ea83fc66d39f0109972d07451d2d95c7f675ae9116c0171753ff715734c7a(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__e962829a5935162e80cde0cda7eb491fcca73ca46cb0d20639c137209f6c594a(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__591c06a9522e824d65cc9cd6355d23819469eee76d979c6bc80d228fc619632d(
*,
key: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__721a4ff50df01d40cf6cc5df6e22043bfc3fa7f595e6f2b217c2b691258d6d17(
*,
engine_version: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
v_switch_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
zone_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
create_sample_data: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
db_instance_category: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
db_instance_class: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
db_instance_description: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
db_instance_group_count: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
db_instance_mode: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
encryption_key: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
encryption_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
idle_time: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
instance_spec: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
master_node_num: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
pay_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
period: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
period_unit: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
private_ip_address: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
security_ip_list: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
seg_disk_performance_level: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
seg_node_num: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
seg_storage_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
serverless_mode: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
serverless_resource: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
storage_size: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
tags: typing.Optional[typing.Sequence[typing.Union[RosDBInstance.TagsProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
vector_configuration_status: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
vpc_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__89aad62043fc84e59bcce114e39f1f5fba3318425c1acece48c74056d4c1ca68(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[RosElasticDBInstanceProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__96d0fef3e1b16e30f97861f68a50b00f0477a22bf3d3d6a150ad4ec108b9fbdb(
props: typing.Mapping[builtins.str, typing.Any],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__50c15121cbf6399e2ada1d3597ac27d96b6437f8e0347fbffa6e6cc160a1ad38(
value: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__b799c1963b9eff6466440e4ac85f13235c4ece45cd3183faca5404e5c8d710c6(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__15376d6a87045e74fb702444b606698d53c4345e02ea16e3da7951f0ce847662(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__7eedd66b72c81a92aaeeb432556f363f974c62907cce508ad2779e49da9d6ca9(
value: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__cc128867dd5a4f68bbf675d380e093963847d79bc7234e714da71896b8ba1e67(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__4cb4bc51217bdf168b5b57a8f65efc60a09486a98396df706f29fb3026d609c6(
value: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__570ec1d9eabd46950d0d6f95eb32f1ee5e0a55c5c5e2e7c31fa8d3c1780f94b3(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__8623cfccaf53796a6d75c78092cef0d666d35e814c8a70eb13efa75b4c258835(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__47a267c22b746bfa31008a52240fb91b683896c8ea0c6094bd6c35ca154b751f(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__950b1ce01b1a36695f6f39c2c585d7f2d6045bc350bcd0375652338a07eac41e(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__ed0c99dccbf0fbd41851a69a0ef3bf0fe151efda5f629a326407f1c07c9da102(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__310b3630773edc96ac6b9024afe182b8d1ac1af210ed8cdffd51f251a0dea6ca(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__0f80ad582306607618031c89d0439be17a886521fbffe815f8a9ec5f83a9ac11(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__a3e8e58aff6a052b8e2b3714a8bee52a496045b377f3eae99c71f60654599b40(
value: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__43aba30bf680fed838bb422e5545c751b74676599cbb589a5b8ea50811dd406c(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__d57e4d182177e6047812ba9300106e4e448e3a3d3dc1c2441b6187da2e0f9de0(
value: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__d6e15a58fd553875254acc185ace46762b5b3d72716260dd639b1978df6dcf12(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__8a31c10c10daf16d59549dc46f7ca7bc3ef08b93e7a506e917ddb3866d01c14c(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__af80656e48bb08e8689717aa223478637f2f738b1c63c1ade0bd2f1d7a1a2e9d(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__360b928c6fda2ec27ee1a719fbccad942a961d5bb9984d3b870e4fe7e3fb7e8a(
value: typing.Optional[typing.List[RosElasticDBInstance.TagsProperty]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__d6007f8297c4e20b3a55b15e1493d543ccdd7522b1113b81cd3054841acc1f7e(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__4359d0b218a824b953b984fe52c61b8bf1c6987f32a9ed206eaa1f2c9c8c818b(
*,
key: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__a0afafad2a21ec89df64c7cdb9a4a66a33d1b29a4b59f958823aa1060aabae4f(
*,
engine_version: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
instance_spec: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
seg_node_num: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
seg_storage_type: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
storage_size: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
v_switch_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
zone_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
db_instance_category: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
db_instance_description: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
db_instance_mode: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
encryption_key: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
encryption_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
master_node_num: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
pay_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
period: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
period_unit: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
private_ip_address: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
security_ip_list: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
tags: typing.Optional[typing.Sequence[typing.Union[RosElasticDBInstance.TagsProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
vpc_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__d8b3b81c34939efe9d78314664a2eeccdf6fc228139638e9d4f0b202bb0d25b2(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[RosInstancePublicConnectionProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__4a9767bb77e51c7b3ed6d48f280e37e2bbad92ceb53569209a655b82fe389857(
props: typing.Mapping[builtins.str, typing.Any],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__7e0c76e0183cf7f848b7df9af05b08ccd2e0b16ccca4dea3a8287234190bb8d5(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__e063fe00164d14c9efedb6793a6fd31cb97d0276b17a3f59d33a97a33431fb34(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__88dcab8f968673bb2972d3617c0b8382b04cd443a1a8d55bb093722a5b7c2a6c(
value: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__48996cfd06449b1b5a352bddf9b867de8323bcd93daabf22440ad247633dbb5b(
value: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__f221b5354b5add6fc90e82f2074bfa127043100889621ee12aa4521347a66c8c(
*,
connection_string_prefix: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
db_instance_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
port: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass | /ros-cdk-gpdb-1.0.17.tar.gz/ros-cdk-gpdb-1.0.17/src/ros_cdk_gpdb/__init__.py | 0.661158 | 0.155335 | __init__.py | pypi |
import abc
import builtins
import datetime
import enum
import typing
import jsii
import publication
import typing_extensions
from typeguard import check_type
from ._jsii import *
import ros_cdk_core as _ros_cdk_core_7adfd82f
class Account(
_ros_cdk_core_7adfd82f.Resource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-graphdatabase.Account",
):
'''A ROS resource type: ``ALIYUN::GraphDatabase::Account``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["AccountProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
'''Create a new ``ALIYUN::GraphDatabase::Account``.
Param scope - scope in which this resource is defined
Param id - scoped id of the resource
Param props - resource properties
:param scope: -
:param id: -
:param props: -
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__a135a8d3a0f6066401c76b7378f8e67e4c6e3b6c4d99e3f0485587bea536a5e0)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@builtins.property
@jsii.member(jsii_name="attrAccountDescription")
def attr_account_description(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute AccountDescription: Account description.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrAccountDescription"))
@builtins.property
@jsii.member(jsii_name="attrAccountName")
def attr_account_name(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute AccountName: Account name.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrAccountName"))
@builtins.property
@jsii.member(jsii_name="attrAccountType")
def attr_account_type(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute AccountType: Account Type.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrAccountType"))
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-graphdatabase.AccountProps",
jsii_struct_bases=[],
name_mapping={
"account_name": "accountName",
"account_password": "accountPassword",
"db_instance_id": "dbInstanceId",
"account_description": "accountDescription",
},
)
class AccountProps:
def __init__(
self,
*,
account_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
account_password: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
db_instance_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
account_description: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::GraphDatabase::Account``.
:param account_name: Property accountName: Account name.
:param account_password: Property accountPassword: Account password.
:param db_instance_id: Property dbInstanceId: Instance Id.
:param account_description: Property accountDescription: Account description.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__60ed371ca48c9e3691df69180033348018130caf10856478e69f42fb1aa84fe9)
check_type(argname="argument account_name", value=account_name, expected_type=type_hints["account_name"])
check_type(argname="argument account_password", value=account_password, expected_type=type_hints["account_password"])
check_type(argname="argument db_instance_id", value=db_instance_id, expected_type=type_hints["db_instance_id"])
check_type(argname="argument account_description", value=account_description, expected_type=type_hints["account_description"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"account_name": account_name,
"account_password": account_password,
"db_instance_id": db_instance_id,
}
if account_description is not None:
self._values["account_description"] = account_description
@builtins.property
def account_name(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property accountName: Account name.'''
result = self._values.get("account_name")
assert result is not None, "Required property 'account_name' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def account_password(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property accountPassword: Account password.'''
result = self._values.get("account_password")
assert result is not None, "Required property 'account_password' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def db_instance_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property dbInstanceId: Instance Id.'''
result = self._values.get("db_instance_id")
assert result is not None, "Required property 'db_instance_id' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def account_description(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property accountDescription: Account description.'''
result = self._values.get("account_description")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "AccountProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class DbInstance(
_ros_cdk_core_7adfd82f.Resource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-graphdatabase.DbInstance",
):
'''A ROS resource type: ``ALIYUN::GraphDatabase::DbInstance``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["DbInstanceProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
'''Create a new ``ALIYUN::GraphDatabase::DbInstance``.
Param scope - scope in which this resource is defined
Param id - scoped id of the resource
Param props - resource properties
:param scope: -
:param id: -
:param props: -
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__bda358cf6c6b98d797dee2c8b8a8f8d56ceba9906ed06cd33aeef5ffa0befa3d)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@builtins.property
@jsii.member(jsii_name="attrConnectionString")
def attr_connection_string(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute ConnectionString: Virtual Private Cloud (vpc connection such as a VPN connection or leased line domain name.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrConnectionString"))
@builtins.property
@jsii.member(jsii_name="attrCreateTime")
def attr_create_time(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute CreateTime: Creation time, which follows the format of YYYY-MM-DD 'T'hh:mm:ssZ, such as 2011-05-30 T12:11:4Z.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrCreateTime"))
@builtins.property
@jsii.member(jsii_name="attrCurrentMinorVersion")
def attr_current_minor_version(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute CurrentMinorVersion: The current kernel image version.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrCurrentMinorVersion"))
@builtins.property
@jsii.member(jsii_name="attrDbInstanceCategory")
def attr_db_instance_category(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute DbInstanceCategory: The category of the db instance.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrDbInstanceCategory"))
@builtins.property
@jsii.member(jsii_name="attrDbInstanceCpu")
def attr_db_instance_cpu(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute DbInstanceCpu: For example, instances can be grouped according to Cpu core count.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrDbInstanceCpu"))
@builtins.property
@jsii.member(jsii_name="attrDbInstanceDescription")
def attr_db_instance_description(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute DbInstanceDescription: According to the practical example or notes.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrDbInstanceDescription"))
@builtins.property
@jsii.member(jsii_name="attrDbInstanceId")
def attr_db_instance_id(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute DbInstanceId: The first ID of the resource.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrDbInstanceId"))
@builtins.property
@jsii.member(jsii_name="attrDbInstanceIpArray")
def attr_db_instance_ip_array(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute DBInstanceIPArray: IP ADDRESS whitelist for the instance group list.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrDbInstanceIpArray"))
@builtins.property
@jsii.member(jsii_name="attrDbInstanceMemory")
def attr_db_instance_memory(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute DbInstanceMemory: Instance memory, which is measured in MB.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrDbInstanceMemory"))
@builtins.property
@jsii.member(jsii_name="attrDbInstanceNetworkType")
def attr_db_instance_network_type(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute DbInstanceNetworkType: The network type of the db instance.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrDbInstanceNetworkType"))
@builtins.property
@jsii.member(jsii_name="attrDbInstanceStorageType")
def attr_db_instance_storage_type(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute DbInstanceStorageType: Cloud Disk.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrDbInstanceStorageType"))
@builtins.property
@jsii.member(jsii_name="attrDbInstanceType")
def attr_db_instance_type(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute DbInstanceType: The type of the db instance.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrDbInstanceType"))
@builtins.property
@jsii.member(jsii_name="attrDbNodeClass")
def attr_db_node_class(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute DbNodeClass: The class of the db node.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrDbNodeClass"))
@builtins.property
@jsii.member(jsii_name="attrDbNodeCount")
def attr_db_node_count(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute DbNodeCount: The count of the db node.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrDbNodeCount"))
@builtins.property
@jsii.member(jsii_name="attrDbNodeStorage")
def attr_db_node_storage(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute DbNodeStorage: Instance storage space, which is measured in GB.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrDbNodeStorage"))
@builtins.property
@jsii.member(jsii_name="attrDbVersion")
def attr_db_version(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute DbVersion: Kernel Version 1.0 is represented as gremlin,1.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrDbVersion"))
@builtins.property
@jsii.member(jsii_name="attrEcsSecurityGroupRelations")
def attr_ecs_security_group_relations(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute EcsSecurityGroupRelations: Security group information array.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrEcsSecurityGroupRelations"))
@builtins.property
@jsii.member(jsii_name="attrExpired")
def attr_expired(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute Expired: The expire status of the db instance.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrExpired"))
@builtins.property
@jsii.member(jsii_name="attrExpireTime")
def attr_expire_time(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute ExpireTime: The instance after it expires time for subscription instance.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrExpireTime"))
@builtins.property
@jsii.member(jsii_name="attrLatestMinorVersion")
def attr_latest_minor_version(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute LatestMinorVersion: The latest kernel image version.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrLatestMinorVersion"))
@builtins.property
@jsii.member(jsii_name="attrLockMode")
def attr_lock_mode(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute LockMode: Instance lock state.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrLockMode"))
@builtins.property
@jsii.member(jsii_name="attrLockReason")
def attr_lock_reason(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute LockReason: An instance is locked the reason.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrLockReason"))
@builtins.property
@jsii.member(jsii_name="attrMaintainTime")
def attr_maintain_time(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute MaintainTime: Instance maintenance time such as 00:00Z-02:00Z, 0 to 2 points to carry out routine maintenance.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrMaintainTime"))
@builtins.property
@jsii.member(jsii_name="attrPaymentType")
def attr_payment_type(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute PaymentType: The resource attribute field representing the paid type is desirable:.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrPaymentType"))
@builtins.property
@jsii.member(jsii_name="attrPort")
def attr_port(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute Port: Application Port.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrPort"))
@builtins.property
@jsii.member(jsii_name="attrPublicConnectionString")
def attr_public_connection_string(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute PublicConnectionString: The public connection string ID of the resource.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrPublicConnectionString"))
@builtins.property
@jsii.member(jsii_name="attrPublicPort")
def attr_public_port(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute PublicPort: The public port ID of the resource.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrPublicPort"))
@builtins.property
@jsii.member(jsii_name="attrReadOnlyDbInstanceIds")
def attr_read_only_db_instance_ids(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute ReadOnlyDbInstanceIds: The array of the readonly db instances.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrReadOnlyDbInstanceIds"))
@builtins.property
@jsii.member(jsii_name="attrResourceGroupId")
def attr_resource_group_id(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute ResourceGroupId: Resource Group ID.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrResourceGroupId"))
@builtins.property
@jsii.member(jsii_name="attrTags")
def attr_tags(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute Tags: resource Tag group.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrTags"))
@builtins.property
@jsii.member(jsii_name="attrVpcId")
def attr_vpc_id(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute VpcId: The vpc id of the db instance.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrVpcId"))
@builtins.property
@jsii.member(jsii_name="attrVSwitchId")
def attr_v_switch_id(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute VSwitchId: The vpc switch id of the resource.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrVSwitchId"))
@builtins.property
@jsii.member(jsii_name="attrZoneId")
def attr_zone_id(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute ZoneId: ZoneId.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrZoneId"))
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-graphdatabase.DbInstanceProps",
jsii_struct_bases=[],
name_mapping={
"db_instance_category": "dbInstanceCategory",
"db_instance_network_type": "dbInstanceNetworkType",
"db_instance_storage_type": "dbInstanceStorageType",
"db_node_class": "dbNodeClass",
"db_node_storage": "dbNodeStorage",
"db_version": "dbVersion",
"backup_set_id": "backupSetId",
"create_type": "createType",
"db_instance_description": "dbInstanceDescription",
"db_instance_ip_array": "dbInstanceIpArray",
"ecs_security_group_relations": "ecsSecurityGroupRelations",
"maintain_time": "maintainTime",
"payment_type": "paymentType",
"resource_group_id": "resourceGroupId",
"restore_type": "restoreType",
"source_db_instance_id": "sourceDbInstanceId",
"tags": "tags",
"vpc_id": "vpcId",
"v_switch_id": "vSwitchId",
"zone_id": "zoneId",
},
)
class DbInstanceProps:
def __init__(
self,
*,
db_instance_category: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
db_instance_network_type: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
db_instance_storage_type: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
db_node_class: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
db_node_storage: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
db_version: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
backup_set_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
create_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
db_instance_description: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
db_instance_ip_array: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union["RosDbInstance.DBInstanceIPArrayProperty", typing.Dict[builtins.str, typing.Any]]]]]] = None,
ecs_security_group_relations: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union["RosDbInstance.EcsSecurityGroupRelationsProperty", typing.Dict[builtins.str, typing.Any]]]]]] = None,
maintain_time: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
payment_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
resource_group_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
restore_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
source_db_instance_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
tags: typing.Optional[typing.Sequence[typing.Union["RosDbInstance.TagsProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
vpc_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
v_switch_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
zone_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::GraphDatabase::DbInstance``.
:param db_instance_category: Property dbInstanceCategory: The category of the db instance.
:param db_instance_network_type: Property dbInstanceNetworkType: The network type of the db instance.
:param db_instance_storage_type: Property dbInstanceStorageType: Instance storage type, Valid values: - cloud_essd.
:param db_node_class: Property dbNodeClass: The class of the db node. Valid values: gdb.r.xlarge, gdb.r.2xlarge, gdb.r.4xlarge, gdb.r.8xlarge,gdb.r.16xlarge, gdb.re.13xlarge, gdb.re.26xlarge, gdb.re.52xlarge
:param db_node_storage: Property dbNodeStorage: Instance storage space, which is measured in GB. The minimum storage space is 20 GB and the step size is 10GB.
:param db_version: Property dbVersion: Kernel version 1.0 is represented as gremlin,1.0-OpenCypher said opencypher.
:param backup_set_id: Property backupSetId: Backup set id.
:param create_type: Property createType: The creation method. Valid values: - CreateDBInstance: Create instance - CloneDBInstance: Clone instance - CreateReadDBInstance: Create a read-only instance
:param db_instance_description: Property dbInstanceDescription: According to the practical example or notes.
:param db_instance_ip_array: Property dbInstanceIpArray: IP address whitelist for the instance group list.
:param ecs_security_group_relations: Property ecsSecurityGroupRelations: Security group information array.
:param maintain_time: Property maintainTime: Instance maintenance time such as 00:00Z-02:00Z, 0 to 2 points to carry out routine maintenance.
:param payment_type: Property paymentType: The resource attribute field representing the paid type is desirable: - PayAsYouGo: Postpaid.
:param resource_group_id: Property resourceGroupId: Resource group id.
:param restore_type: Property restoreType: Restore type.
:param source_db_instance_id: Property sourceDbInstanceId: Source Instance Id.
:param tags: Property tags: Tags of db instance.
:param vpc_id: Property vpcId: The vpc id of the db instance.
:param v_switch_id: Property vSwitchId: The vpc switch id of the resource.
:param zone_id: Property zoneId: ZoneId.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__2d309c92c57341817343c2c6c43e8c8bf98157ef7846c26aba78a53f658140ed)
check_type(argname="argument db_instance_category", value=db_instance_category, expected_type=type_hints["db_instance_category"])
check_type(argname="argument db_instance_network_type", value=db_instance_network_type, expected_type=type_hints["db_instance_network_type"])
check_type(argname="argument db_instance_storage_type", value=db_instance_storage_type, expected_type=type_hints["db_instance_storage_type"])
check_type(argname="argument db_node_class", value=db_node_class, expected_type=type_hints["db_node_class"])
check_type(argname="argument db_node_storage", value=db_node_storage, expected_type=type_hints["db_node_storage"])
check_type(argname="argument db_version", value=db_version, expected_type=type_hints["db_version"])
check_type(argname="argument backup_set_id", value=backup_set_id, expected_type=type_hints["backup_set_id"])
check_type(argname="argument create_type", value=create_type, expected_type=type_hints["create_type"])
check_type(argname="argument db_instance_description", value=db_instance_description, expected_type=type_hints["db_instance_description"])
check_type(argname="argument db_instance_ip_array", value=db_instance_ip_array, expected_type=type_hints["db_instance_ip_array"])
check_type(argname="argument ecs_security_group_relations", value=ecs_security_group_relations, expected_type=type_hints["ecs_security_group_relations"])
check_type(argname="argument maintain_time", value=maintain_time, expected_type=type_hints["maintain_time"])
check_type(argname="argument payment_type", value=payment_type, expected_type=type_hints["payment_type"])
check_type(argname="argument resource_group_id", value=resource_group_id, expected_type=type_hints["resource_group_id"])
check_type(argname="argument restore_type", value=restore_type, expected_type=type_hints["restore_type"])
check_type(argname="argument source_db_instance_id", value=source_db_instance_id, expected_type=type_hints["source_db_instance_id"])
check_type(argname="argument tags", value=tags, expected_type=type_hints["tags"])
check_type(argname="argument vpc_id", value=vpc_id, expected_type=type_hints["vpc_id"])
check_type(argname="argument v_switch_id", value=v_switch_id, expected_type=type_hints["v_switch_id"])
check_type(argname="argument zone_id", value=zone_id, expected_type=type_hints["zone_id"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"db_instance_category": db_instance_category,
"db_instance_network_type": db_instance_network_type,
"db_instance_storage_type": db_instance_storage_type,
"db_node_class": db_node_class,
"db_node_storage": db_node_storage,
"db_version": db_version,
}
if backup_set_id is not None:
self._values["backup_set_id"] = backup_set_id
if create_type is not None:
self._values["create_type"] = create_type
if db_instance_description is not None:
self._values["db_instance_description"] = db_instance_description
if db_instance_ip_array is not None:
self._values["db_instance_ip_array"] = db_instance_ip_array
if ecs_security_group_relations is not None:
self._values["ecs_security_group_relations"] = ecs_security_group_relations
if maintain_time is not None:
self._values["maintain_time"] = maintain_time
if payment_type is not None:
self._values["payment_type"] = payment_type
if resource_group_id is not None:
self._values["resource_group_id"] = resource_group_id
if restore_type is not None:
self._values["restore_type"] = restore_type
if source_db_instance_id is not None:
self._values["source_db_instance_id"] = source_db_instance_id
if tags is not None:
self._values["tags"] = tags
if vpc_id is not None:
self._values["vpc_id"] = vpc_id
if v_switch_id is not None:
self._values["v_switch_id"] = v_switch_id
if zone_id is not None:
self._values["zone_id"] = zone_id
@builtins.property
def db_instance_category(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property dbInstanceCategory: The category of the db instance.'''
result = self._values.get("db_instance_category")
assert result is not None, "Required property 'db_instance_category' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def db_instance_network_type(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property dbInstanceNetworkType: The network type of the db instance.'''
result = self._values.get("db_instance_network_type")
assert result is not None, "Required property 'db_instance_network_type' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def db_instance_storage_type(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property dbInstanceStorageType: Instance storage type, Valid values: - cloud_essd.'''
result = self._values.get("db_instance_storage_type")
assert result is not None, "Required property 'db_instance_storage_type' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def db_node_class(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property dbNodeClass: The class of the db node.
Valid values:
gdb.r.xlarge, gdb.r.2xlarge, gdb.r.4xlarge, gdb.r.8xlarge,gdb.r.16xlarge, gdb.re.13xlarge, gdb.re.26xlarge, gdb.re.52xlarge
'''
result = self._values.get("db_node_class")
assert result is not None, "Required property 'db_node_class' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def db_node_storage(
self,
) -> typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property dbNodeStorage: Instance storage space, which is measured in GB.
The minimum storage space is 20 GB and the step size is 10GB.
'''
result = self._values.get("db_node_storage")
assert result is not None, "Required property 'db_node_storage' is missing"
return typing.cast(typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def db_version(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property dbVersion: Kernel version 1.0 is represented as gremlin,1.0-OpenCypher said opencypher.'''
result = self._values.get("db_version")
assert result is not None, "Required property 'db_version' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def backup_set_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property backupSetId: Backup set id.'''
result = self._values.get("backup_set_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def create_type(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property createType: The creation method.
Valid values:
- CreateDBInstance: Create instance
- CloneDBInstance: Clone instance
- CreateReadDBInstance: Create a read-only instance
'''
result = self._values.get("create_type")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def db_instance_description(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property dbInstanceDescription: According to the practical example or notes.'''
result = self._values.get("db_instance_description")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def db_instance_ip_array(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosDbInstance.DBInstanceIPArrayProperty"]]]]:
'''Property dbInstanceIpArray: IP address whitelist for the instance group list.'''
result = self._values.get("db_instance_ip_array")
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosDbInstance.DBInstanceIPArrayProperty"]]]], result)
@builtins.property
def ecs_security_group_relations(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosDbInstance.EcsSecurityGroupRelationsProperty"]]]]:
'''Property ecsSecurityGroupRelations: Security group information array.'''
result = self._values.get("ecs_security_group_relations")
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosDbInstance.EcsSecurityGroupRelationsProperty"]]]], result)
@builtins.property
def maintain_time(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property maintainTime: Instance maintenance time such as 00:00Z-02:00Z, 0 to 2 points to carry out routine maintenance.'''
result = self._values.get("maintain_time")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def payment_type(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property paymentType: The resource attribute field representing the paid type is desirable: - PayAsYouGo: Postpaid.'''
result = self._values.get("payment_type")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def resource_group_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property resourceGroupId: Resource group id.'''
result = self._values.get("resource_group_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def restore_type(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property restoreType: Restore type.'''
result = self._values.get("restore_type")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def source_db_instance_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property sourceDbInstanceId: Source Instance Id.'''
result = self._values.get("source_db_instance_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def tags(self) -> typing.Optional[typing.List["RosDbInstance.TagsProperty"]]:
'''Property tags: Tags of db instance.'''
result = self._values.get("tags")
return typing.cast(typing.Optional[typing.List["RosDbInstance.TagsProperty"]], result)
@builtins.property
def vpc_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property vpcId: The vpc id of the db instance.'''
result = self._values.get("vpc_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def v_switch_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property vSwitchId: The vpc switch id of the resource.'''
result = self._values.get("v_switch_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def zone_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property zoneId: ZoneId.'''
result = self._values.get("zone_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "DbInstanceProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class RosAccount(
_ros_cdk_core_7adfd82f.RosResource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-graphdatabase.RosAccount",
):
'''A ROS template type: ``ALIYUN::GraphDatabase::Account``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["RosAccountProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
'''Create a new ``ALIYUN::GraphDatabase::Account``.
:param scope: - scope in which this resource is defined.
:param id: - scoped id of the resource.
:param props: - resource properties.
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__0132e2ad0b13f6342831a91ee7e9b712307729f4a06c827de9c37e2d6e9d52cf)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@jsii.member(jsii_name="renderProperties")
def _render_properties(
self,
props: typing.Mapping[builtins.str, typing.Any],
) -> typing.Mapping[builtins.str, typing.Any]:
'''
:param props: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__22764b228d858babd05414e1118436140c1b0e2f8a514d9becd0299808fe6dda)
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))
@jsii.python.classproperty
@jsii.member(jsii_name="ROS_RESOURCE_TYPE_NAME")
def ROS_RESOURCE_TYPE_NAME(cls) -> builtins.str:
'''The resource type name for this resource class.'''
return typing.cast(builtins.str, jsii.sget(cls, "ROS_RESOURCE_TYPE_NAME"))
@builtins.property
@jsii.member(jsii_name="attrAccountDescription")
def attr_account_description(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: AccountDescription: Account description.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrAccountDescription"))
@builtins.property
@jsii.member(jsii_name="attrAccountName")
def attr_account_name(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: AccountName: Account name.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrAccountName"))
@builtins.property
@jsii.member(jsii_name="attrAccountType")
def attr_account_type(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: AccountType: Account Type.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrAccountType"))
@builtins.property
@jsii.member(jsii_name="rosProperties")
def _ros_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "rosProperties"))
@builtins.property
@jsii.member(jsii_name="accountName")
def account_name(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: accountName: Account name.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "accountName"))
@account_name.setter
def account_name(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__86d34997b886040eab8e93ff36acc6bec9ce163b23e98c9407f08b023c8444f7)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "accountName", value)
@builtins.property
@jsii.member(jsii_name="accountPassword")
def account_password(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: accountPassword: Account password.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "accountPassword"))
@account_password.setter
def account_password(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__c938ce51afd74fec5615d462fad0d52932c6dd9be971d19bd3e0c734ba57b28f)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "accountPassword", value)
@builtins.property
@jsii.member(jsii_name="dbInstanceId")
def db_instance_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: dbInstanceId: Instance Id.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "dbInstanceId"))
@db_instance_id.setter
def db_instance_id(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__6d7a8a49de63eba2379a43f3c7db67ec337c30c0a1d514ca561a18e970ae0644)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "dbInstanceId", value)
@builtins.property
@jsii.member(jsii_name="enableResourcePropertyConstraint")
def enable_resource_property_constraint(self) -> builtins.bool:
return typing.cast(builtins.bool, jsii.get(self, "enableResourcePropertyConstraint"))
@enable_resource_property_constraint.setter
def enable_resource_property_constraint(self, value: builtins.bool) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__e9bea5271ea28f8edf6fc611037c958097785f09b1cd0f26341b0917a198c939)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "enableResourcePropertyConstraint", value)
@builtins.property
@jsii.member(jsii_name="accountDescription")
def account_description(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: accountDescription: Account description.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "accountDescription"))
@account_description.setter
def account_description(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__ee82b03c16c7a4060c1f0b6f406da5ffc28bdecb484420582179013586c44619)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "accountDescription", value)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-graphdatabase.RosAccountProps",
jsii_struct_bases=[],
name_mapping={
"account_name": "accountName",
"account_password": "accountPassword",
"db_instance_id": "dbInstanceId",
"account_description": "accountDescription",
},
)
class RosAccountProps:
def __init__(
self,
*,
account_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
account_password: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
db_instance_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
account_description: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::GraphDatabase::Account``.
:param account_name:
:param account_password:
:param db_instance_id:
:param account_description:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__90cdc7f9cb2f5a4ae545fba95fc668c7675ef26da45fbf61d1cab408de24deff)
check_type(argname="argument account_name", value=account_name, expected_type=type_hints["account_name"])
check_type(argname="argument account_password", value=account_password, expected_type=type_hints["account_password"])
check_type(argname="argument db_instance_id", value=db_instance_id, expected_type=type_hints["db_instance_id"])
check_type(argname="argument account_description", value=account_description, expected_type=type_hints["account_description"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"account_name": account_name,
"account_password": account_password,
"db_instance_id": db_instance_id,
}
if account_description is not None:
self._values["account_description"] = account_description
@builtins.property
def account_name(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: accountName: Account name.
'''
result = self._values.get("account_name")
assert result is not None, "Required property 'account_name' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def account_password(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: accountPassword: Account password.
'''
result = self._values.get("account_password")
assert result is not None, "Required property 'account_password' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def db_instance_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: dbInstanceId: Instance Id.
'''
result = self._values.get("db_instance_id")
assert result is not None, "Required property 'db_instance_id' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def account_description(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: accountDescription: Account description.
'''
result = self._values.get("account_description")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "RosAccountProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class RosDbInstance(
_ros_cdk_core_7adfd82f.RosResource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-graphdatabase.RosDbInstance",
):
'''A ROS template type: ``ALIYUN::GraphDatabase::DbInstance``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["RosDbInstanceProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
'''Create a new ``ALIYUN::GraphDatabase::DbInstance``.
:param scope: - scope in which this resource is defined.
:param id: - scoped id of the resource.
:param props: - resource properties.
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__0f042c4e001940d34b78ef3327f24b9c1de1b80249e7f2f841b564037f04ca6c)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@jsii.member(jsii_name="renderProperties")
def _render_properties(
self,
props: typing.Mapping[builtins.str, typing.Any],
) -> typing.Mapping[builtins.str, typing.Any]:
'''
:param props: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__7bf3553ef6a4645d093533d9c4bc84efc4acd7f9c725a83e991c12d30d0a41a8)
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))
@jsii.python.classproperty
@jsii.member(jsii_name="ROS_RESOURCE_TYPE_NAME")
def ROS_RESOURCE_TYPE_NAME(cls) -> builtins.str:
'''The resource type name for this resource class.'''
return typing.cast(builtins.str, jsii.sget(cls, "ROS_RESOURCE_TYPE_NAME"))
@builtins.property
@jsii.member(jsii_name="attrConnectionString")
def attr_connection_string(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: ConnectionString: Virtual Private Cloud (vpc connection such as a VPN connection or leased line domain name.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrConnectionString"))
@builtins.property
@jsii.member(jsii_name="attrCreateTime")
def attr_create_time(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: CreateTime: Creation time, which follows the format of YYYY-MM-DD 'T'hh:mm:ssZ, such as 2011-05-30 T12:11:4Z.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrCreateTime"))
@builtins.property
@jsii.member(jsii_name="attrCurrentMinorVersion")
def attr_current_minor_version(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: CurrentMinorVersion: The current kernel image version.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrCurrentMinorVersion"))
@builtins.property
@jsii.member(jsii_name="attrDbInstanceCategory")
def attr_db_instance_category(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: DbInstanceCategory: The category of the db instance.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrDbInstanceCategory"))
@builtins.property
@jsii.member(jsii_name="attrDbInstanceCpu")
def attr_db_instance_cpu(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: DbInstanceCpu: For example, instances can be grouped according to Cpu core count.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrDbInstanceCpu"))
@builtins.property
@jsii.member(jsii_name="attrDbInstanceDescription")
def attr_db_instance_description(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: DbInstanceDescription: According to the practical example or notes.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrDbInstanceDescription"))
@builtins.property
@jsii.member(jsii_name="attrDbInstanceId")
def attr_db_instance_id(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: DbInstanceId: The first ID of the resource.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrDbInstanceId"))
@builtins.property
@jsii.member(jsii_name="attrDbInstanceIpArray")
def attr_db_instance_ip_array(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: DBInstanceIPArray: IP ADDRESS whitelist for the instance group list.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrDbInstanceIpArray"))
@builtins.property
@jsii.member(jsii_name="attrDbInstanceMemory")
def attr_db_instance_memory(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: DbInstanceMemory: Instance memory, which is measured in MB.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrDbInstanceMemory"))
@builtins.property
@jsii.member(jsii_name="attrDbInstanceNetworkType")
def attr_db_instance_network_type(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: DbInstanceNetworkType: The network type of the db instance.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrDbInstanceNetworkType"))
@builtins.property
@jsii.member(jsii_name="attrDbInstanceStorageType")
def attr_db_instance_storage_type(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: DbInstanceStorageType: Cloud Disk.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrDbInstanceStorageType"))
@builtins.property
@jsii.member(jsii_name="attrDbInstanceType")
def attr_db_instance_type(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: DbInstanceType: The type of the db instance.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrDbInstanceType"))
@builtins.property
@jsii.member(jsii_name="attrDbNodeClass")
def attr_db_node_class(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: DbNodeClass: The class of the db node.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrDbNodeClass"))
@builtins.property
@jsii.member(jsii_name="attrDbNodeCount")
def attr_db_node_count(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: DbNodeCount: The count of the db node.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrDbNodeCount"))
@builtins.property
@jsii.member(jsii_name="attrDbNodeStorage")
def attr_db_node_storage(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: DbNodeStorage: Instance storage space, which is measured in GB.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrDbNodeStorage"))
@builtins.property
@jsii.member(jsii_name="attrDbVersion")
def attr_db_version(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: DbVersion: Kernel Version 1.0 is represented as gremlin,1.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrDbVersion"))
@builtins.property
@jsii.member(jsii_name="attrEcsSecurityGroupRelations")
def attr_ecs_security_group_relations(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: EcsSecurityGroupRelations: Security group information array.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrEcsSecurityGroupRelations"))
@builtins.property
@jsii.member(jsii_name="attrExpired")
def attr_expired(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: Expired: The expire status of the db instance.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrExpired"))
@builtins.property
@jsii.member(jsii_name="attrExpireTime")
def attr_expire_time(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: ExpireTime: The instance after it expires time for subscription instance.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrExpireTime"))
@builtins.property
@jsii.member(jsii_name="attrLatestMinorVersion")
def attr_latest_minor_version(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: LatestMinorVersion: The latest kernel image version.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrLatestMinorVersion"))
@builtins.property
@jsii.member(jsii_name="attrLockMode")
def attr_lock_mode(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: LockMode: Instance lock state.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrLockMode"))
@builtins.property
@jsii.member(jsii_name="attrLockReason")
def attr_lock_reason(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: LockReason: An instance is locked the reason.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrLockReason"))
@builtins.property
@jsii.member(jsii_name="attrMaintainTime")
def attr_maintain_time(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: MaintainTime: Instance maintenance time such as 00:00Z-02:00Z, 0 to 2 points to carry out routine maintenance.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrMaintainTime"))
@builtins.property
@jsii.member(jsii_name="attrPaymentType")
def attr_payment_type(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: PaymentType: The resource attribute field representing the paid type is desirable:.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrPaymentType"))
@builtins.property
@jsii.member(jsii_name="attrPort")
def attr_port(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: Port: Application Port.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrPort"))
@builtins.property
@jsii.member(jsii_name="attrPublicConnectionString")
def attr_public_connection_string(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: PublicConnectionString: The public connection string ID of the resource.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrPublicConnectionString"))
@builtins.property
@jsii.member(jsii_name="attrPublicPort")
def attr_public_port(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: PublicPort: The public port ID of the resource.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrPublicPort"))
@builtins.property
@jsii.member(jsii_name="attrReadOnlyDbInstanceIds")
def attr_read_only_db_instance_ids(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: ReadOnlyDbInstanceIds: The array of the readonly db instances.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrReadOnlyDbInstanceIds"))
@builtins.property
@jsii.member(jsii_name="attrResourceGroupId")
def attr_resource_group_id(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: ResourceGroupId: Resource Group ID.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrResourceGroupId"))
@builtins.property
@jsii.member(jsii_name="attrTags")
def attr_tags(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: Tags: resource Tag group.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrTags"))
@builtins.property
@jsii.member(jsii_name="attrVpcId")
def attr_vpc_id(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: VpcId: The vpc id of the db instance.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrVpcId"))
@builtins.property
@jsii.member(jsii_name="attrVSwitchId")
def attr_v_switch_id(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: VSwitchId: The vpc switch id of the resource.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrVSwitchId"))
@builtins.property
@jsii.member(jsii_name="attrZoneId")
def attr_zone_id(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: ZoneId: ZoneId.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrZoneId"))
@builtins.property
@jsii.member(jsii_name="rosProperties")
def _ros_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "rosProperties"))
@builtins.property
@jsii.member(jsii_name="dbInstanceCategory")
def db_instance_category(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: dbInstanceCategory: The category of the db instance.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "dbInstanceCategory"))
@db_instance_category.setter
def db_instance_category(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__237d999b2a605e091689504958e5479047d7118bc0e0a794241468fcf396599b)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "dbInstanceCategory", value)
@builtins.property
@jsii.member(jsii_name="dbInstanceNetworkType")
def db_instance_network_type(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: dbInstanceNetworkType: The network type of the db instance.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "dbInstanceNetworkType"))
@db_instance_network_type.setter
def db_instance_network_type(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__4bc793240b8c66c83b0df828c9f94b298e491728311a2693d59f23efd9190d65)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "dbInstanceNetworkType", value)
@builtins.property
@jsii.member(jsii_name="dbInstanceStorageType")
def db_instance_storage_type(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
dbInstanceStorageType: Instance storage type, Valid values:
- cloud_essd.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "dbInstanceStorageType"))
@db_instance_storage_type.setter
def db_instance_storage_type(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__1e5f1788945e92673eaa77292bcea26f99fb0f76cf70afe0ff1558a408d71a13)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "dbInstanceStorageType", value)
@builtins.property
@jsii.member(jsii_name="dbNodeClass")
def db_node_class(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
dbNodeClass: The class of the db node. Valid values:
gdb.r.xlarge, gdb.r.2xlarge, gdb.r.4xlarge, gdb.r.8xlarge,gdb.r.16xlarge, gdb.re.13xlarge, gdb.re.26xlarge, gdb.re.52xlarge
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "dbNodeClass"))
@db_node_class.setter
def db_node_class(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__1395c5258a6c5a43fed490d10c8f5bf2a45ba9afded2e87190160ecd86b5e49f)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "dbNodeClass", value)
@builtins.property
@jsii.member(jsii_name="dbNodeStorage")
def db_node_storage(
self,
) -> typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: dbNodeStorage: Instance storage space, which is measured in GB. The minimum storage space is 20 GB and the step size is 10GB.
'''
return typing.cast(typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "dbNodeStorage"))
@db_node_storage.setter
def db_node_storage(
self,
value: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__521c18b3a58e97e95ad760ac9eb64f363de71cb1741f6814f5afd34193c43d2e)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "dbNodeStorage", value)
@builtins.property
@jsii.member(jsii_name="dbVersion")
def db_version(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: dbVersion: Kernel version 1.0 is represented as gremlin,1.0-OpenCypher said opencypher.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "dbVersion"))
@db_version.setter
def db_version(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__16abe490b54e94f09fd1e94eb32acc15daf11c0923554b98cf0c04b0629db5cf)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "dbVersion", value)
@builtins.property
@jsii.member(jsii_name="enableResourcePropertyConstraint")
def enable_resource_property_constraint(self) -> builtins.bool:
return typing.cast(builtins.bool, jsii.get(self, "enableResourcePropertyConstraint"))
@enable_resource_property_constraint.setter
def enable_resource_property_constraint(self, value: builtins.bool) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__0b60de0dc4caa810a116464048cacad79c80619159e8724c860df18d286b458f)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "enableResourcePropertyConstraint", value)
@builtins.property
@jsii.member(jsii_name="backupSetId")
def backup_set_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: backupSetId: Backup set id.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "backupSetId"))
@backup_set_id.setter
def backup_set_id(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__a966be15bb81a5c036144e5351f03b43241646ff8c70ed1e1bbb46d9f25db137)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "backupSetId", value)
@builtins.property
@jsii.member(jsii_name="createType")
def create_type(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
createType: The creation method. Valid values:
- CreateDBInstance: Create instance
- CloneDBInstance: Clone instance
- CreateReadDBInstance: Create a read-only instance
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "createType"))
@create_type.setter
def create_type(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__a9bdd735a3cf1cdcb73deb60d73e847877daf5394fac5015e025ac67d5cea534)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "createType", value)
@builtins.property
@jsii.member(jsii_name="dbInstanceDescription")
def db_instance_description(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: dbInstanceDescription: According to the practical example or notes.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "dbInstanceDescription"))
@db_instance_description.setter
def db_instance_description(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__5964543c62fe26b84ade170f4daf241b63588940a07544729ce2bf0f4ced877d)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "dbInstanceDescription", value)
@builtins.property
@jsii.member(jsii_name="dbInstanceIpArray")
def db_instance_ip_array(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosDbInstance.DBInstanceIPArrayProperty"]]]]:
'''
:Property: dbInstanceIpArray: IP address whitelist for the instance group list.
'''
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosDbInstance.DBInstanceIPArrayProperty"]]]], jsii.get(self, "dbInstanceIpArray"))
@db_instance_ip_array.setter
def db_instance_ip_array(
self,
value: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosDbInstance.DBInstanceIPArrayProperty"]]]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__0b7a09aa343b3d1eeb2bc14be3ad0b6e5e13f4128193d6e1ca489d73b04d4f4a)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "dbInstanceIpArray", value)
@builtins.property
@jsii.member(jsii_name="ecsSecurityGroupRelations")
def ecs_security_group_relations(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosDbInstance.EcsSecurityGroupRelationsProperty"]]]]:
'''
:Property: ecsSecurityGroupRelations: Security group information array.
'''
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosDbInstance.EcsSecurityGroupRelationsProperty"]]]], jsii.get(self, "ecsSecurityGroupRelations"))
@ecs_security_group_relations.setter
def ecs_security_group_relations(
self,
value: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosDbInstance.EcsSecurityGroupRelationsProperty"]]]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__1b61c6036b75185ee969810276271911fdb0bd216b9d3383650619d4358653cf)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "ecsSecurityGroupRelations", value)
@builtins.property
@jsii.member(jsii_name="maintainTime")
def maintain_time(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: maintainTime: Instance maintenance time such as 00:00Z-02:00Z, 0 to 2 points to carry out routine maintenance.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "maintainTime"))
@maintain_time.setter
def maintain_time(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__6bcba6c1dbedabca61dc1b75ed8cbcc62cc66c26edc889e7db653461b38b817f)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "maintainTime", value)
@builtins.property
@jsii.member(jsii_name="paymentType")
def payment_type(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
paymentType: The resource attribute field representing the paid type is desirable:
- PayAsYouGo: Postpaid.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "paymentType"))
@payment_type.setter
def payment_type(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__fc1298eaf19393f1b2cc67f426607ce6d8aab2c3e29c89667a55673111998524)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "paymentType", value)
@builtins.property
@jsii.member(jsii_name="resourceGroupId")
def resource_group_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: resourceGroupId: Resource group id.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "resourceGroupId"))
@resource_group_id.setter
def resource_group_id(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__af834a82815482d86348f76a2160c603fd92b70d83c0e2f8a18fe4e7b25d7b65)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "resourceGroupId", value)
@builtins.property
@jsii.member(jsii_name="restoreType")
def restore_type(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: restoreType: Restore type.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "restoreType"))
@restore_type.setter
def restore_type(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__29e8af6bb4477a2442ffd36b5d1f641034ca24e56c91adb3a21c8e354b5dbf29)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "restoreType", value)
@builtins.property
@jsii.member(jsii_name="sourceDbInstanceId")
def source_db_instance_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: sourceDbInstanceId: Source Instance Id.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "sourceDbInstanceId"))
@source_db_instance_id.setter
def source_db_instance_id(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__116f09bf51575ead4f177b068f1762b7dfbb512a76f24b74192421951c9280ee)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "sourceDbInstanceId", value)
@builtins.property
@jsii.member(jsii_name="tags")
def tags(self) -> typing.Optional[typing.List["RosDbInstance.TagsProperty"]]:
'''
:Property: tags: Tags of db instance.
'''
return typing.cast(typing.Optional[typing.List["RosDbInstance.TagsProperty"]], jsii.get(self, "tags"))
@tags.setter
def tags(
self,
value: typing.Optional[typing.List["RosDbInstance.TagsProperty"]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__d6fa70a74ed814662c73f45e67a803173f4639e1e296fb5b3df4bbb350d137c2)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "tags", value)
@builtins.property
@jsii.member(jsii_name="vpcId")
def vpc_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: vpcId: The vpc id of the db instance.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "vpcId"))
@vpc_id.setter
def vpc_id(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__2c8cc0543d1a2e5daf6fc89a09a6044765d95cd957bc29fd9bb3f9e522a61c26)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "vpcId", value)
@builtins.property
@jsii.member(jsii_name="vSwitchId")
def v_switch_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: vSwitchId: The vpc switch id of the resource.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "vSwitchId"))
@v_switch_id.setter
def v_switch_id(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__260418c71d9e868079197f27db1d1dc06939cb4172cb80d081283022bd55d58f)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "vSwitchId", value)
@builtins.property
@jsii.member(jsii_name="zoneId")
def zone_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: zoneId: ZoneId.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "zoneId"))
@zone_id.setter
def zone_id(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__2884909ce1005a4af52d8cb5a62c115a31b0d7783a4eb6f7b593e418ec8e9abd)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "zoneId", value)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-graphdatabase.RosDbInstance.DBInstanceIPArrayProperty",
jsii_struct_bases=[],
name_mapping={
"security_ips": "securityIps",
"db_instance_ip_array_name": "dbInstanceIpArrayName",
},
)
class DBInstanceIPArrayProperty:
def __init__(
self,
*,
security_ips: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
db_instance_ip_array_name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''
:param security_ips:
:param db_instance_ip_array_name:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__e8a27fe3934cd390007a553e9ec510d3b43e057b515e0e03d1e7bd2d785e28bb)
check_type(argname="argument security_ips", value=security_ips, expected_type=type_hints["security_ips"])
check_type(argname="argument db_instance_ip_array_name", value=db_instance_ip_array_name, expected_type=type_hints["db_instance_ip_array_name"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"security_ips": security_ips,
}
if db_instance_ip_array_name is not None:
self._values["db_instance_ip_array_name"] = db_instance_ip_array_name
@builtins.property
def security_ips(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: securityIps: IP address whitelist addresses in the IP address list, and a maximum of 1000 comma-separated format is as follows: 0.0.0.0/0 and 10.23.12.24(IP) or 10.23.12.24/24(CIDR mode, CIDR (Classless Inter-Domain Routing)/24 represents the address prefixes in the length of the range [1,32]).
'''
result = self._values.get("security_ips")
assert result is not None, "Required property 'security_ips' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def db_instance_ip_array_name(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: dbInstanceIpArrayName: IP address whitelist group name.
'''
result = self._values.get("db_instance_ip_array_name")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "DBInstanceIPArrayProperty(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-graphdatabase.RosDbInstance.EcsSecurityGroupRelationsProperty",
jsii_struct_bases=[],
name_mapping={
"security_group_id": "securityGroupId",
"network_type": "networkType",
"region_id": "regionId",
},
)
class EcsSecurityGroupRelationsProperty:
def __init__(
self,
*,
security_group_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
network_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
region_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''
:param security_group_id:
:param network_type:
:param region_id:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__63cc1056c8bb37fbb07409e31875492f1611e049633f6e6221fafdb4c28c0e6f)
check_type(argname="argument security_group_id", value=security_group_id, expected_type=type_hints["security_group_id"])
check_type(argname="argument network_type", value=network_type, expected_type=type_hints["network_type"])
check_type(argname="argument region_id", value=region_id, expected_type=type_hints["region_id"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"security_group_id": security_group_id,
}
if network_type is not None:
self._values["network_type"] = network_type
if region_id is not None:
self._values["region_id"] = region_id
@builtins.property
def security_group_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: securityGroupId: Security group Id.
'''
result = self._values.get("security_group_id")
assert result is not None, "Required property 'security_group_id' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def network_type(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: networkType: Network type.
'''
result = self._values.get("network_type")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def region_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: regionId: Region.
'''
result = self._values.get("region_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "EcsSecurityGroupRelationsProperty(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-graphdatabase.RosDbInstance.TagsProperty",
jsii_struct_bases=[],
name_mapping={"key": "key", "value": "value"},
)
class TagsProperty:
def __init__(
self,
*,
key: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''
:param key:
:param value:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__2b3f8b59b2a00f1c7e76c801f21bc0ad16836bf18aa95f95e1cb02fa5b5f3bcd)
check_type(argname="argument key", value=key, expected_type=type_hints["key"])
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"key": key,
}
if value is not None:
self._values["value"] = value
@builtins.property
def key(self) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: key: undefined
'''
result = self._values.get("key")
assert result is not None, "Required property 'key' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def value(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: value: undefined
'''
result = self._values.get("value")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "TagsProperty(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-graphdatabase.RosDbInstanceProps",
jsii_struct_bases=[],
name_mapping={
"db_instance_category": "dbInstanceCategory",
"db_instance_network_type": "dbInstanceNetworkType",
"db_instance_storage_type": "dbInstanceStorageType",
"db_node_class": "dbNodeClass",
"db_node_storage": "dbNodeStorage",
"db_version": "dbVersion",
"backup_set_id": "backupSetId",
"create_type": "createType",
"db_instance_description": "dbInstanceDescription",
"db_instance_ip_array": "dbInstanceIpArray",
"ecs_security_group_relations": "ecsSecurityGroupRelations",
"maintain_time": "maintainTime",
"payment_type": "paymentType",
"resource_group_id": "resourceGroupId",
"restore_type": "restoreType",
"source_db_instance_id": "sourceDbInstanceId",
"tags": "tags",
"vpc_id": "vpcId",
"v_switch_id": "vSwitchId",
"zone_id": "zoneId",
},
)
class RosDbInstanceProps:
def __init__(
self,
*,
db_instance_category: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
db_instance_network_type: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
db_instance_storage_type: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
db_node_class: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
db_node_storage: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
db_version: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
backup_set_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
create_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
db_instance_description: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
db_instance_ip_array: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union[RosDbInstance.DBInstanceIPArrayProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
ecs_security_group_relations: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union[RosDbInstance.EcsSecurityGroupRelationsProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
maintain_time: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
payment_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
resource_group_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
restore_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
source_db_instance_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
tags: typing.Optional[typing.Sequence[typing.Union[RosDbInstance.TagsProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
vpc_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
v_switch_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
zone_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::GraphDatabase::DbInstance``.
:param db_instance_category:
:param db_instance_network_type:
:param db_instance_storage_type:
:param db_node_class:
:param db_node_storage:
:param db_version:
:param backup_set_id:
:param create_type:
:param db_instance_description:
:param db_instance_ip_array:
:param ecs_security_group_relations:
:param maintain_time:
:param payment_type:
:param resource_group_id:
:param restore_type:
:param source_db_instance_id:
:param tags:
:param vpc_id:
:param v_switch_id:
:param zone_id:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__633f4d728a4b1f60f3a59d9e81b84af92da44ad5de6857494b7b8c272f2f1caf)
check_type(argname="argument db_instance_category", value=db_instance_category, expected_type=type_hints["db_instance_category"])
check_type(argname="argument db_instance_network_type", value=db_instance_network_type, expected_type=type_hints["db_instance_network_type"])
check_type(argname="argument db_instance_storage_type", value=db_instance_storage_type, expected_type=type_hints["db_instance_storage_type"])
check_type(argname="argument db_node_class", value=db_node_class, expected_type=type_hints["db_node_class"])
check_type(argname="argument db_node_storage", value=db_node_storage, expected_type=type_hints["db_node_storage"])
check_type(argname="argument db_version", value=db_version, expected_type=type_hints["db_version"])
check_type(argname="argument backup_set_id", value=backup_set_id, expected_type=type_hints["backup_set_id"])
check_type(argname="argument create_type", value=create_type, expected_type=type_hints["create_type"])
check_type(argname="argument db_instance_description", value=db_instance_description, expected_type=type_hints["db_instance_description"])
check_type(argname="argument db_instance_ip_array", value=db_instance_ip_array, expected_type=type_hints["db_instance_ip_array"])
check_type(argname="argument ecs_security_group_relations", value=ecs_security_group_relations, expected_type=type_hints["ecs_security_group_relations"])
check_type(argname="argument maintain_time", value=maintain_time, expected_type=type_hints["maintain_time"])
check_type(argname="argument payment_type", value=payment_type, expected_type=type_hints["payment_type"])
check_type(argname="argument resource_group_id", value=resource_group_id, expected_type=type_hints["resource_group_id"])
check_type(argname="argument restore_type", value=restore_type, expected_type=type_hints["restore_type"])
check_type(argname="argument source_db_instance_id", value=source_db_instance_id, expected_type=type_hints["source_db_instance_id"])
check_type(argname="argument tags", value=tags, expected_type=type_hints["tags"])
check_type(argname="argument vpc_id", value=vpc_id, expected_type=type_hints["vpc_id"])
check_type(argname="argument v_switch_id", value=v_switch_id, expected_type=type_hints["v_switch_id"])
check_type(argname="argument zone_id", value=zone_id, expected_type=type_hints["zone_id"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"db_instance_category": db_instance_category,
"db_instance_network_type": db_instance_network_type,
"db_instance_storage_type": db_instance_storage_type,
"db_node_class": db_node_class,
"db_node_storage": db_node_storage,
"db_version": db_version,
}
if backup_set_id is not None:
self._values["backup_set_id"] = backup_set_id
if create_type is not None:
self._values["create_type"] = create_type
if db_instance_description is not None:
self._values["db_instance_description"] = db_instance_description
if db_instance_ip_array is not None:
self._values["db_instance_ip_array"] = db_instance_ip_array
if ecs_security_group_relations is not None:
self._values["ecs_security_group_relations"] = ecs_security_group_relations
if maintain_time is not None:
self._values["maintain_time"] = maintain_time
if payment_type is not None:
self._values["payment_type"] = payment_type
if resource_group_id is not None:
self._values["resource_group_id"] = resource_group_id
if restore_type is not None:
self._values["restore_type"] = restore_type
if source_db_instance_id is not None:
self._values["source_db_instance_id"] = source_db_instance_id
if tags is not None:
self._values["tags"] = tags
if vpc_id is not None:
self._values["vpc_id"] = vpc_id
if v_switch_id is not None:
self._values["v_switch_id"] = v_switch_id
if zone_id is not None:
self._values["zone_id"] = zone_id
@builtins.property
def db_instance_category(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: dbInstanceCategory: The category of the db instance.
'''
result = self._values.get("db_instance_category")
assert result is not None, "Required property 'db_instance_category' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def db_instance_network_type(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: dbInstanceNetworkType: The network type of the db instance.
'''
result = self._values.get("db_instance_network_type")
assert result is not None, "Required property 'db_instance_network_type' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def db_instance_storage_type(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
dbInstanceStorageType: Instance storage type, Valid values:
- cloud_essd.
'''
result = self._values.get("db_instance_storage_type")
assert result is not None, "Required property 'db_instance_storage_type' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def db_node_class(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
dbNodeClass: The class of the db node. Valid values:
gdb.r.xlarge, gdb.r.2xlarge, gdb.r.4xlarge, gdb.r.8xlarge,gdb.r.16xlarge, gdb.re.13xlarge, gdb.re.26xlarge, gdb.re.52xlarge
'''
result = self._values.get("db_node_class")
assert result is not None, "Required property 'db_node_class' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def db_node_storage(
self,
) -> typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: dbNodeStorage: Instance storage space, which is measured in GB. The minimum storage space is 20 GB and the step size is 10GB.
'''
result = self._values.get("db_node_storage")
assert result is not None, "Required property 'db_node_storage' is missing"
return typing.cast(typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def db_version(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: dbVersion: Kernel version 1.0 is represented as gremlin,1.0-OpenCypher said opencypher.
'''
result = self._values.get("db_version")
assert result is not None, "Required property 'db_version' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def backup_set_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: backupSetId: Backup set id.
'''
result = self._values.get("backup_set_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def create_type(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
createType: The creation method. Valid values:
- CreateDBInstance: Create instance
- CloneDBInstance: Clone instance
- CreateReadDBInstance: Create a read-only instance
'''
result = self._values.get("create_type")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def db_instance_description(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: dbInstanceDescription: According to the practical example or notes.
'''
result = self._values.get("db_instance_description")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def db_instance_ip_array(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, RosDbInstance.DBInstanceIPArrayProperty]]]]:
'''
:Property: dbInstanceIpArray: IP address whitelist for the instance group list.
'''
result = self._values.get("db_instance_ip_array")
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, RosDbInstance.DBInstanceIPArrayProperty]]]], result)
@builtins.property
def ecs_security_group_relations(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, RosDbInstance.EcsSecurityGroupRelationsProperty]]]]:
'''
:Property: ecsSecurityGroupRelations: Security group information array.
'''
result = self._values.get("ecs_security_group_relations")
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, RosDbInstance.EcsSecurityGroupRelationsProperty]]]], result)
@builtins.property
def maintain_time(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: maintainTime: Instance maintenance time such as 00:00Z-02:00Z, 0 to 2 points to carry out routine maintenance.
'''
result = self._values.get("maintain_time")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def payment_type(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
paymentType: The resource attribute field representing the paid type is desirable:
- PayAsYouGo: Postpaid.
'''
result = self._values.get("payment_type")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def resource_group_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: resourceGroupId: Resource group id.
'''
result = self._values.get("resource_group_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def restore_type(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: restoreType: Restore type.
'''
result = self._values.get("restore_type")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def source_db_instance_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: sourceDbInstanceId: Source Instance Id.
'''
result = self._values.get("source_db_instance_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def tags(self) -> typing.Optional[typing.List[RosDbInstance.TagsProperty]]:
'''
:Property: tags: Tags of db instance.
'''
result = self._values.get("tags")
return typing.cast(typing.Optional[typing.List[RosDbInstance.TagsProperty]], result)
@builtins.property
def vpc_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: vpcId: The vpc id of the db instance.
'''
result = self._values.get("vpc_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def v_switch_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: vSwitchId: The vpc switch id of the resource.
'''
result = self._values.get("v_switch_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def zone_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: zoneId: ZoneId.
'''
result = self._values.get("zone_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "RosDbInstanceProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
__all__ = [
"Account",
"AccountProps",
"DbInstance",
"DbInstanceProps",
"RosAccount",
"RosAccountProps",
"RosDbInstance",
"RosDbInstanceProps",
"datasource",
]
publication.publish()
# Loading modules to ensure their types are registered with the jsii runtime library
from . import datasource
def _typecheckingstub__a135a8d3a0f6066401c76b7378f8e67e4c6e3b6c4d99e3f0485587bea536a5e0(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[AccountProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__60ed371ca48c9e3691df69180033348018130caf10856478e69f42fb1aa84fe9(
*,
account_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
account_password: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
db_instance_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
account_description: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__bda358cf6c6b98d797dee2c8b8a8f8d56ceba9906ed06cd33aeef5ffa0befa3d(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[DbInstanceProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__2d309c92c57341817343c2c6c43e8c8bf98157ef7846c26aba78a53f658140ed(
*,
db_instance_category: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
db_instance_network_type: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
db_instance_storage_type: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
db_node_class: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
db_node_storage: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
db_version: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
backup_set_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
create_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
db_instance_description: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
db_instance_ip_array: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union[RosDbInstance.DBInstanceIPArrayProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
ecs_security_group_relations: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union[RosDbInstance.EcsSecurityGroupRelationsProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
maintain_time: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
payment_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
resource_group_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
restore_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
source_db_instance_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
tags: typing.Optional[typing.Sequence[typing.Union[RosDbInstance.TagsProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
vpc_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
v_switch_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
zone_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__0132e2ad0b13f6342831a91ee7e9b712307729f4a06c827de9c37e2d6e9d52cf(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[RosAccountProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__22764b228d858babd05414e1118436140c1b0e2f8a514d9becd0299808fe6dda(
props: typing.Mapping[builtins.str, typing.Any],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__86d34997b886040eab8e93ff36acc6bec9ce163b23e98c9407f08b023c8444f7(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__c938ce51afd74fec5615d462fad0d52932c6dd9be971d19bd3e0c734ba57b28f(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__6d7a8a49de63eba2379a43f3c7db67ec337c30c0a1d514ca561a18e970ae0644(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__e9bea5271ea28f8edf6fc611037c958097785f09b1cd0f26341b0917a198c939(
value: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__ee82b03c16c7a4060c1f0b6f406da5ffc28bdecb484420582179013586c44619(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__90cdc7f9cb2f5a4ae545fba95fc668c7675ef26da45fbf61d1cab408de24deff(
*,
account_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
account_password: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
db_instance_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
account_description: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__0f042c4e001940d34b78ef3327f24b9c1de1b80249e7f2f841b564037f04ca6c(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[RosDbInstanceProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__7bf3553ef6a4645d093533d9c4bc84efc4acd7f9c725a83e991c12d30d0a41a8(
props: typing.Mapping[builtins.str, typing.Any],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__237d999b2a605e091689504958e5479047d7118bc0e0a794241468fcf396599b(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__4bc793240b8c66c83b0df828c9f94b298e491728311a2693d59f23efd9190d65(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__1e5f1788945e92673eaa77292bcea26f99fb0f76cf70afe0ff1558a408d71a13(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__1395c5258a6c5a43fed490d10c8f5bf2a45ba9afded2e87190160ecd86b5e49f(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__521c18b3a58e97e95ad760ac9eb64f363de71cb1741f6814f5afd34193c43d2e(
value: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__16abe490b54e94f09fd1e94eb32acc15daf11c0923554b98cf0c04b0629db5cf(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__0b60de0dc4caa810a116464048cacad79c80619159e8724c860df18d286b458f(
value: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__a966be15bb81a5c036144e5351f03b43241646ff8c70ed1e1bbb46d9f25db137(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__a9bdd735a3cf1cdcb73deb60d73e847877daf5394fac5015e025ac67d5cea534(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__5964543c62fe26b84ade170f4daf241b63588940a07544729ce2bf0f4ced877d(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__0b7a09aa343b3d1eeb2bc14be3ad0b6e5e13f4128193d6e1ca489d73b04d4f4a(
value: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, RosDbInstance.DBInstanceIPArrayProperty]]]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__1b61c6036b75185ee969810276271911fdb0bd216b9d3383650619d4358653cf(
value: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, RosDbInstance.EcsSecurityGroupRelationsProperty]]]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__6bcba6c1dbedabca61dc1b75ed8cbcc62cc66c26edc889e7db653461b38b817f(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__fc1298eaf19393f1b2cc67f426607ce6d8aab2c3e29c89667a55673111998524(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__af834a82815482d86348f76a2160c603fd92b70d83c0e2f8a18fe4e7b25d7b65(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__29e8af6bb4477a2442ffd36b5d1f641034ca24e56c91adb3a21c8e354b5dbf29(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__116f09bf51575ead4f177b068f1762b7dfbb512a76f24b74192421951c9280ee(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__d6fa70a74ed814662c73f45e67a803173f4639e1e296fb5b3df4bbb350d137c2(
value: typing.Optional[typing.List[RosDbInstance.TagsProperty]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__2c8cc0543d1a2e5daf6fc89a09a6044765d95cd957bc29fd9bb3f9e522a61c26(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__260418c71d9e868079197f27db1d1dc06939cb4172cb80d081283022bd55d58f(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__2884909ce1005a4af52d8cb5a62c115a31b0d7783a4eb6f7b593e418ec8e9abd(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__e8a27fe3934cd390007a553e9ec510d3b43e057b515e0e03d1e7bd2d785e28bb(
*,
security_ips: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
db_instance_ip_array_name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__63cc1056c8bb37fbb07409e31875492f1611e049633f6e6221fafdb4c28c0e6f(
*,
security_group_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
network_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
region_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__2b3f8b59b2a00f1c7e76c801f21bc0ad16836bf18aa95f95e1cb02fa5b5f3bcd(
*,
key: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__633f4d728a4b1f60f3a59d9e81b84af92da44ad5de6857494b7b8c272f2f1caf(
*,
db_instance_category: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
db_instance_network_type: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
db_instance_storage_type: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
db_node_class: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
db_node_storage: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
db_version: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
backup_set_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
create_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
db_instance_description: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
db_instance_ip_array: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union[RosDbInstance.DBInstanceIPArrayProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
ecs_security_group_relations: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union[RosDbInstance.EcsSecurityGroupRelationsProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
maintain_time: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
payment_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
resource_group_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
restore_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
source_db_instance_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
tags: typing.Optional[typing.Sequence[typing.Union[RosDbInstance.TagsProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
vpc_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
v_switch_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
zone_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass | /ros-cdk-graphdatabase-1.0.17.tar.gz/ros-cdk-graphdatabase-1.0.17/src/ros_cdk_graphdatabase/__init__.py | 0.571767 | 0.151216 | __init__.py | pypi |
import abc
import builtins
import datetime
import enum
import typing
import jsii
import publication
import typing_extensions
from typeguard import check_type
from ._jsii import *
import ros_cdk_core
class Cluster(
ros_cdk_core.Resource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-gws.Cluster",
):
'''A ROS resource type: ``ALIYUN::GWS::Cluster``.'''
def __init__(
self,
scope: ros_cdk_core.Construct,
id: builtins.str,
props: typing.Union["ClusterProps", typing.Dict[str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
'''Create a new ``ALIYUN::GWS::Cluster``.
Param scope - scope in which this resource is defined
Param id - scoped id of the resource
Param props - resource properties
:param scope: -
:param id: -
:param props: -
:param enable_resource_property_constraint: -
'''
if __debug__:
def stub(
scope: ros_cdk_core.Construct,
id: builtins.str,
props: typing.Union[ClusterProps, typing.Dict[str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
...
type_hints = typing.get_type_hints(stub)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@builtins.property
@jsii.member(jsii_name="attrClusterId")
def attr_cluster_id(self) -> ros_cdk_core.IResolvable:
'''Attribute ClusterId: Cluster id.'''
return typing.cast(ros_cdk_core.IResolvable, jsii.get(self, "attrClusterId"))
@builtins.property
@jsii.member(jsii_name="attrName")
def attr_name(self) -> ros_cdk_core.IResolvable:
'''Attribute Name: Cluster name.'''
return typing.cast(ros_cdk_core.IResolvable, jsii.get(self, "attrName"))
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-gws.ClusterProps",
jsii_struct_bases=[],
name_mapping={
"cluster_type": "clusterType",
"vpc_id": "vpcId",
"name": "name",
"policy": "policy",
"v_switch_id": "vSwitchId",
},
)
class ClusterProps:
def __init__(
self,
*,
cluster_type: typing.Union[builtins.str, ros_cdk_core.IResolvable],
vpc_id: typing.Union[builtins.str, ros_cdk_core.IResolvable],
name: typing.Optional[typing.Union[builtins.str, ros_cdk_core.IResolvable]] = None,
policy: typing.Optional[typing.Union[ros_cdk_core.IResolvable, typing.Union["RosCluster.PolicyProperty", typing.Dict[str, typing.Any]]]] = None,
v_switch_id: typing.Optional[typing.Union[builtins.str, ros_cdk_core.IResolvable]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::GWS::Cluster``.
:param cluster_type: Property clusterType: Cluster Type: gws.s1.standard.
:param vpc_id: Property vpcId: VPC id.
:param name: Property name: Cluster name.
:param policy: Property policy: Cluster policy.
:param v_switch_id: Property vSwitchId: VSwitch id.
'''
if __debug__:
def stub(
*,
cluster_type: typing.Union[builtins.str, ros_cdk_core.IResolvable],
vpc_id: typing.Union[builtins.str, ros_cdk_core.IResolvable],
name: typing.Optional[typing.Union[builtins.str, ros_cdk_core.IResolvable]] = None,
policy: typing.Optional[typing.Union[ros_cdk_core.IResolvable, typing.Union[RosCluster.PolicyProperty, typing.Dict[str, typing.Any]]]] = None,
v_switch_id: typing.Optional[typing.Union[builtins.str, ros_cdk_core.IResolvable]] = None,
) -> None:
...
type_hints = typing.get_type_hints(stub)
check_type(argname="argument cluster_type", value=cluster_type, expected_type=type_hints["cluster_type"])
check_type(argname="argument vpc_id", value=vpc_id, expected_type=type_hints["vpc_id"])
check_type(argname="argument name", value=name, expected_type=type_hints["name"])
check_type(argname="argument policy", value=policy, expected_type=type_hints["policy"])
check_type(argname="argument v_switch_id", value=v_switch_id, expected_type=type_hints["v_switch_id"])
self._values: typing.Dict[str, typing.Any] = {
"cluster_type": cluster_type,
"vpc_id": vpc_id,
}
if name is not None:
self._values["name"] = name
if policy is not None:
self._values["policy"] = policy
if v_switch_id is not None:
self._values["v_switch_id"] = v_switch_id
@builtins.property
def cluster_type(self) -> typing.Union[builtins.str, ros_cdk_core.IResolvable]:
'''Property clusterType: Cluster Type: gws.s1.standard.'''
result = self._values.get("cluster_type")
assert result is not None, "Required property 'cluster_type' is missing"
return typing.cast(typing.Union[builtins.str, ros_cdk_core.IResolvable], result)
@builtins.property
def vpc_id(self) -> typing.Union[builtins.str, ros_cdk_core.IResolvable]:
'''Property vpcId: VPC id.'''
result = self._values.get("vpc_id")
assert result is not None, "Required property 'vpc_id' is missing"
return typing.cast(typing.Union[builtins.str, ros_cdk_core.IResolvable], result)
@builtins.property
def name(
self,
) -> typing.Optional[typing.Union[builtins.str, ros_cdk_core.IResolvable]]:
'''Property name: Cluster name.'''
result = self._values.get("name")
return typing.cast(typing.Optional[typing.Union[builtins.str, ros_cdk_core.IResolvable]], result)
@builtins.property
def policy(
self,
) -> typing.Optional[typing.Union[ros_cdk_core.IResolvable, "RosCluster.PolicyProperty"]]:
'''Property policy: Cluster policy.'''
result = self._values.get("policy")
return typing.cast(typing.Optional[typing.Union[ros_cdk_core.IResolvable, "RosCluster.PolicyProperty"]], result)
@builtins.property
def v_switch_id(
self,
) -> typing.Optional[typing.Union[builtins.str, ros_cdk_core.IResolvable]]:
'''Property vSwitchId: VSwitch id.'''
result = self._values.get("v_switch_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, ros_cdk_core.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "ClusterProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class Instance(
ros_cdk_core.Resource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-gws.Instance",
):
'''A ROS resource type: ``ALIYUN::GWS::Instance``.'''
def __init__(
self,
scope: ros_cdk_core.Construct,
id: builtins.str,
props: typing.Union["InstanceProps", typing.Dict[str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
'''Create a new ``ALIYUN::GWS::Instance``.
Param scope - scope in which this resource is defined
Param id - scoped id of the resource
Param props - resource properties
:param scope: -
:param id: -
:param props: -
:param enable_resource_property_constraint: -
'''
if __debug__:
def stub(
scope: ros_cdk_core.Construct,
id: builtins.str,
props: typing.Union[InstanceProps, typing.Dict[str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
...
type_hints = typing.get_type_hints(stub)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@builtins.property
@jsii.member(jsii_name="attrClusterId")
def attr_cluster_id(self) -> ros_cdk_core.IResolvable:
'''Attribute ClusterId: Cluster id.'''
return typing.cast(ros_cdk_core.IResolvable, jsii.get(self, "attrClusterId"))
@builtins.property
@jsii.member(jsii_name="attrInstanceChargeType")
def attr_instance_charge_type(self) -> ros_cdk_core.IResolvable:
'''Attribute InstanceChargeType: Instance charge type.'''
return typing.cast(ros_cdk_core.IResolvable, jsii.get(self, "attrInstanceChargeType"))
@builtins.property
@jsii.member(jsii_name="attrInstanceId")
def attr_instance_id(self) -> ros_cdk_core.IResolvable:
'''Attribute InstanceId: Instance id.'''
return typing.cast(ros_cdk_core.IResolvable, jsii.get(self, "attrInstanceId"))
@builtins.property
@jsii.member(jsii_name="attrMaxBandwidthIn")
def attr_max_bandwidth_in(self) -> ros_cdk_core.IResolvable:
'''Attribute MaxBandwidthIn: Maximum inbound bandwidth of the public network (in Mbps).'''
return typing.cast(ros_cdk_core.IResolvable, jsii.get(self, "attrMaxBandwidthIn"))
@builtins.property
@jsii.member(jsii_name="attrMaxBandwidthOut")
def attr_max_bandwidth_out(self) -> ros_cdk_core.IResolvable:
'''Attribute MaxBandwidthOut: Maximum outbound bandwidth of the public network (in Mbps).'''
return typing.cast(ros_cdk_core.IResolvable, jsii.get(self, "attrMaxBandwidthOut"))
@builtins.property
@jsii.member(jsii_name="attrName")
def attr_name(self) -> ros_cdk_core.IResolvable:
'''Attribute Name: Instance name.'''
return typing.cast(ros_cdk_core.IResolvable, jsii.get(self, "attrName"))
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-gws.InstanceProps",
jsii_struct_bases=[],
name_mapping={
"cluster_id": "clusterId",
"image_id": "imageId",
"instance_type": "instanceType",
"system_disk_category": "systemDiskCategory",
"system_disk_size": "systemDiskSize",
"work_mode": "workMode",
"allocate_public_address": "allocatePublicAddress",
"app_list": "appList",
"auto_renew": "autoRenew",
"instance_charge_type": "instanceChargeType",
"internet_charge_type": "internetChargeType",
"internet_max_bandwidth_out": "internetMaxBandwidthOut",
"name": "name",
"period": "period",
"period_unit": "periodUnit",
"v_switch_id": "vSwitchId",
},
)
class InstanceProps:
def __init__(
self,
*,
cluster_id: typing.Union[builtins.str, ros_cdk_core.IResolvable],
image_id: typing.Union[builtins.str, ros_cdk_core.IResolvable],
instance_type: typing.Union[builtins.str, ros_cdk_core.IResolvable],
system_disk_category: typing.Union[builtins.str, ros_cdk_core.IResolvable],
system_disk_size: typing.Union[jsii.Number, ros_cdk_core.IResolvable],
work_mode: typing.Union[builtins.str, ros_cdk_core.IResolvable],
allocate_public_address: typing.Optional[typing.Union[builtins.bool, ros_cdk_core.IResolvable]] = None,
app_list: typing.Optional[typing.Union[ros_cdk_core.IResolvable, typing.Sequence[typing.Union[ros_cdk_core.IResolvable, typing.Union["RosInstance.AppListProperty", typing.Dict[str, typing.Any]]]]]] = None,
auto_renew: typing.Optional[typing.Union[builtins.bool, ros_cdk_core.IResolvable]] = None,
instance_charge_type: typing.Optional[typing.Union[builtins.str, ros_cdk_core.IResolvable]] = None,
internet_charge_type: typing.Optional[typing.Union[builtins.str, ros_cdk_core.IResolvable]] = None,
internet_max_bandwidth_out: typing.Optional[typing.Union[jsii.Number, ros_cdk_core.IResolvable]] = None,
name: typing.Optional[typing.Union[builtins.str, ros_cdk_core.IResolvable]] = None,
period: typing.Optional[typing.Union[jsii.Number, ros_cdk_core.IResolvable]] = None,
period_unit: typing.Optional[typing.Union[builtins.str, ros_cdk_core.IResolvable]] = None,
v_switch_id: typing.Optional[typing.Union[builtins.str, ros_cdk_core.IResolvable]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::GWS::Instance``.
:param cluster_id: Property clusterId: Cluster id.
:param image_id: Property imageId: Mirror id.
:param instance_type: Property instanceType: Examples of specifications, see examples of racial or specifications call DescribeInstanceTypes get specification sheet.
:param system_disk_category: Property systemDiskCategory: System disk categories: cloud_ssd, cloud_essd, cloud, cloud and so on.
:param system_disk_size: Property systemDiskSize: System disk size.
:param work_mode: Property workMode: Work mode: Desktop Application.
:param allocate_public_address: Property allocatePublicAddress: Whether to allocate a public network address.
:param app_list: Property appList: App list. This value is only valid when WorkMode is Application.
:param auto_renew: Property autoRenew: Whether auto renew.
:param instance_charge_type: Property instanceChargeType: Instance charge type: PostPaid (default): Pay-As-You-Go PrePaid: Subscription.
:param internet_charge_type: Property internetChargeType: Network charge type: PayByTraffic (default): Flow-per-use billing PayByBandwidth: fixed-bandwidth billing This value is only valid when AllocatePublicAddress is true.
:param internet_max_bandwidth_out: Property internetMaxBandwidthOut: Maximum outbound bandwidth of the public network (in Mbps). Value range: 1-200 Default: 200 This value is only valid when AllocatePublicAddress is true.
:param name: Property name: Instance name.
:param period: Property period: Period of subscription. When PeriodUnit is Week, the value range is 1-4 When PeriodUnit is Month, the value range is 1-9, 12, 24, 36, 48, 60 This value is only valid when InstanceChargeType is PrePaid.
:param period_unit: Property periodUnit: Unit of period. Week or Month. This value is only valid when InstanceChargeType is PrePaid.
:param v_switch_id: Property vSwitchId: VSwitch id.
'''
if __debug__:
def stub(
*,
cluster_id: typing.Union[builtins.str, ros_cdk_core.IResolvable],
image_id: typing.Union[builtins.str, ros_cdk_core.IResolvable],
instance_type: typing.Union[builtins.str, ros_cdk_core.IResolvable],
system_disk_category: typing.Union[builtins.str, ros_cdk_core.IResolvable],
system_disk_size: typing.Union[jsii.Number, ros_cdk_core.IResolvable],
work_mode: typing.Union[builtins.str, ros_cdk_core.IResolvable],
allocate_public_address: typing.Optional[typing.Union[builtins.bool, ros_cdk_core.IResolvable]] = None,
app_list: typing.Optional[typing.Union[ros_cdk_core.IResolvable, typing.Sequence[typing.Union[ros_cdk_core.IResolvable, typing.Union[RosInstance.AppListProperty, typing.Dict[str, typing.Any]]]]]] = None,
auto_renew: typing.Optional[typing.Union[builtins.bool, ros_cdk_core.IResolvable]] = None,
instance_charge_type: typing.Optional[typing.Union[builtins.str, ros_cdk_core.IResolvable]] = None,
internet_charge_type: typing.Optional[typing.Union[builtins.str, ros_cdk_core.IResolvable]] = None,
internet_max_bandwidth_out: typing.Optional[typing.Union[jsii.Number, ros_cdk_core.IResolvable]] = None,
name: typing.Optional[typing.Union[builtins.str, ros_cdk_core.IResolvable]] = None,
period: typing.Optional[typing.Union[jsii.Number, ros_cdk_core.IResolvable]] = None,
period_unit: typing.Optional[typing.Union[builtins.str, ros_cdk_core.IResolvable]] = None,
v_switch_id: typing.Optional[typing.Union[builtins.str, ros_cdk_core.IResolvable]] = None,
) -> None:
...
type_hints = typing.get_type_hints(stub)
check_type(argname="argument cluster_id", value=cluster_id, expected_type=type_hints["cluster_id"])
check_type(argname="argument image_id", value=image_id, expected_type=type_hints["image_id"])
check_type(argname="argument instance_type", value=instance_type, expected_type=type_hints["instance_type"])
check_type(argname="argument system_disk_category", value=system_disk_category, expected_type=type_hints["system_disk_category"])
check_type(argname="argument system_disk_size", value=system_disk_size, expected_type=type_hints["system_disk_size"])
check_type(argname="argument work_mode", value=work_mode, expected_type=type_hints["work_mode"])
check_type(argname="argument allocate_public_address", value=allocate_public_address, expected_type=type_hints["allocate_public_address"])
check_type(argname="argument app_list", value=app_list, expected_type=type_hints["app_list"])
check_type(argname="argument auto_renew", value=auto_renew, expected_type=type_hints["auto_renew"])
check_type(argname="argument instance_charge_type", value=instance_charge_type, expected_type=type_hints["instance_charge_type"])
check_type(argname="argument internet_charge_type", value=internet_charge_type, expected_type=type_hints["internet_charge_type"])
check_type(argname="argument internet_max_bandwidth_out", value=internet_max_bandwidth_out, expected_type=type_hints["internet_max_bandwidth_out"])
check_type(argname="argument name", value=name, expected_type=type_hints["name"])
check_type(argname="argument period", value=period, expected_type=type_hints["period"])
check_type(argname="argument period_unit", value=period_unit, expected_type=type_hints["period_unit"])
check_type(argname="argument v_switch_id", value=v_switch_id, expected_type=type_hints["v_switch_id"])
self._values: typing.Dict[str, typing.Any] = {
"cluster_id": cluster_id,
"image_id": image_id,
"instance_type": instance_type,
"system_disk_category": system_disk_category,
"system_disk_size": system_disk_size,
"work_mode": work_mode,
}
if allocate_public_address is not None:
self._values["allocate_public_address"] = allocate_public_address
if app_list is not None:
self._values["app_list"] = app_list
if auto_renew is not None:
self._values["auto_renew"] = auto_renew
if instance_charge_type is not None:
self._values["instance_charge_type"] = instance_charge_type
if internet_charge_type is not None:
self._values["internet_charge_type"] = internet_charge_type
if internet_max_bandwidth_out is not None:
self._values["internet_max_bandwidth_out"] = internet_max_bandwidth_out
if name is not None:
self._values["name"] = name
if period is not None:
self._values["period"] = period
if period_unit is not None:
self._values["period_unit"] = period_unit
if v_switch_id is not None:
self._values["v_switch_id"] = v_switch_id
@builtins.property
def cluster_id(self) -> typing.Union[builtins.str, ros_cdk_core.IResolvable]:
'''Property clusterId: Cluster id.'''
result = self._values.get("cluster_id")
assert result is not None, "Required property 'cluster_id' is missing"
return typing.cast(typing.Union[builtins.str, ros_cdk_core.IResolvable], result)
@builtins.property
def image_id(self) -> typing.Union[builtins.str, ros_cdk_core.IResolvable]:
'''Property imageId: Mirror id.'''
result = self._values.get("image_id")
assert result is not None, "Required property 'image_id' is missing"
return typing.cast(typing.Union[builtins.str, ros_cdk_core.IResolvable], result)
@builtins.property
def instance_type(self) -> typing.Union[builtins.str, ros_cdk_core.IResolvable]:
'''Property instanceType: Examples of specifications, see examples of racial or specifications call DescribeInstanceTypes get specification sheet.'''
result = self._values.get("instance_type")
assert result is not None, "Required property 'instance_type' is missing"
return typing.cast(typing.Union[builtins.str, ros_cdk_core.IResolvable], result)
@builtins.property
def system_disk_category(
self,
) -> typing.Union[builtins.str, ros_cdk_core.IResolvable]:
'''Property systemDiskCategory: System disk categories: cloud_ssd, cloud_essd, cloud, cloud and so on.'''
result = self._values.get("system_disk_category")
assert result is not None, "Required property 'system_disk_category' is missing"
return typing.cast(typing.Union[builtins.str, ros_cdk_core.IResolvable], result)
@builtins.property
def system_disk_size(self) -> typing.Union[jsii.Number, ros_cdk_core.IResolvable]:
'''Property systemDiskSize: System disk size.'''
result = self._values.get("system_disk_size")
assert result is not None, "Required property 'system_disk_size' is missing"
return typing.cast(typing.Union[jsii.Number, ros_cdk_core.IResolvable], result)
@builtins.property
def work_mode(self) -> typing.Union[builtins.str, ros_cdk_core.IResolvable]:
'''Property workMode: Work mode: Desktop Application.'''
result = self._values.get("work_mode")
assert result is not None, "Required property 'work_mode' is missing"
return typing.cast(typing.Union[builtins.str, ros_cdk_core.IResolvable], result)
@builtins.property
def allocate_public_address(
self,
) -> typing.Optional[typing.Union[builtins.bool, ros_cdk_core.IResolvable]]:
'''Property allocatePublicAddress: Whether to allocate a public network address.'''
result = self._values.get("allocate_public_address")
return typing.cast(typing.Optional[typing.Union[builtins.bool, ros_cdk_core.IResolvable]], result)
@builtins.property
def app_list(
self,
) -> typing.Optional[typing.Union[ros_cdk_core.IResolvable, typing.List[typing.Union[ros_cdk_core.IResolvable, "RosInstance.AppListProperty"]]]]:
'''Property appList: App list.
This value is only valid when WorkMode is Application.
'''
result = self._values.get("app_list")
return typing.cast(typing.Optional[typing.Union[ros_cdk_core.IResolvable, typing.List[typing.Union[ros_cdk_core.IResolvable, "RosInstance.AppListProperty"]]]], result)
@builtins.property
def auto_renew(
self,
) -> typing.Optional[typing.Union[builtins.bool, ros_cdk_core.IResolvable]]:
'''Property autoRenew: Whether auto renew.'''
result = self._values.get("auto_renew")
return typing.cast(typing.Optional[typing.Union[builtins.bool, ros_cdk_core.IResolvable]], result)
@builtins.property
def instance_charge_type(
self,
) -> typing.Optional[typing.Union[builtins.str, ros_cdk_core.IResolvable]]:
'''Property instanceChargeType: Instance charge type: PostPaid (default): Pay-As-You-Go PrePaid: Subscription.'''
result = self._values.get("instance_charge_type")
return typing.cast(typing.Optional[typing.Union[builtins.str, ros_cdk_core.IResolvable]], result)
@builtins.property
def internet_charge_type(
self,
) -> typing.Optional[typing.Union[builtins.str, ros_cdk_core.IResolvable]]:
'''Property internetChargeType: Network charge type: PayByTraffic (default): Flow-per-use billing PayByBandwidth: fixed-bandwidth billing This value is only valid when AllocatePublicAddress is true.'''
result = self._values.get("internet_charge_type")
return typing.cast(typing.Optional[typing.Union[builtins.str, ros_cdk_core.IResolvable]], result)
@builtins.property
def internet_max_bandwidth_out(
self,
) -> typing.Optional[typing.Union[jsii.Number, ros_cdk_core.IResolvable]]:
'''Property internetMaxBandwidthOut: Maximum outbound bandwidth of the public network (in Mbps).
Value range: 1-200
Default: 200
This value is only valid when AllocatePublicAddress is true.
'''
result = self._values.get("internet_max_bandwidth_out")
return typing.cast(typing.Optional[typing.Union[jsii.Number, ros_cdk_core.IResolvable]], result)
@builtins.property
def name(
self,
) -> typing.Optional[typing.Union[builtins.str, ros_cdk_core.IResolvable]]:
'''Property name: Instance name.'''
result = self._values.get("name")
return typing.cast(typing.Optional[typing.Union[builtins.str, ros_cdk_core.IResolvable]], result)
@builtins.property
def period(
self,
) -> typing.Optional[typing.Union[jsii.Number, ros_cdk_core.IResolvable]]:
'''Property period: Period of subscription.
When PeriodUnit is Week, the value range is 1-4
When PeriodUnit is Month, the value range is 1-9, 12, 24, 36, 48, 60
This value is only valid when InstanceChargeType is PrePaid.
'''
result = self._values.get("period")
return typing.cast(typing.Optional[typing.Union[jsii.Number, ros_cdk_core.IResolvable]], result)
@builtins.property
def period_unit(
self,
) -> typing.Optional[typing.Union[builtins.str, ros_cdk_core.IResolvable]]:
'''Property periodUnit: Unit of period.
Week or Month.
This value is only valid when InstanceChargeType is PrePaid.
'''
result = self._values.get("period_unit")
return typing.cast(typing.Optional[typing.Union[builtins.str, ros_cdk_core.IResolvable]], result)
@builtins.property
def v_switch_id(
self,
) -> typing.Optional[typing.Union[builtins.str, ros_cdk_core.IResolvable]]:
'''Property vSwitchId: VSwitch id.'''
result = self._values.get("v_switch_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, ros_cdk_core.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "InstanceProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class RosCluster(
ros_cdk_core.RosResource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-gws.RosCluster",
):
'''A ROS template type: ``ALIYUN::GWS::Cluster``.'''
def __init__(
self,
scope: ros_cdk_core.Construct,
id: builtins.str,
props: typing.Union["RosClusterProps", typing.Dict[str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
'''Create a new ``ALIYUN::GWS::Cluster``.
:param scope: - scope in which this resource is defined.
:param id: - scoped id of the resource.
:param props: - resource properties.
:param enable_resource_property_constraint: -
'''
if __debug__:
def stub(
scope: ros_cdk_core.Construct,
id: builtins.str,
props: typing.Union[RosClusterProps, typing.Dict[str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
...
type_hints = typing.get_type_hints(stub)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@jsii.member(jsii_name="renderProperties")
def _render_properties(
self,
props: typing.Mapping[builtins.str, typing.Any],
) -> typing.Mapping[builtins.str, typing.Any]:
'''
:param props: -
'''
if __debug__:
def stub(props: typing.Mapping[builtins.str, typing.Any]) -> None:
...
type_hints = typing.get_type_hints(stub)
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))
@jsii.python.classproperty
@jsii.member(jsii_name="ROS_RESOURCE_TYPE_NAME")
def ROS_RESOURCE_TYPE_NAME(cls) -> builtins.str:
'''The resource type name for this resource class.'''
return typing.cast(builtins.str, jsii.sget(cls, "ROS_RESOURCE_TYPE_NAME"))
@builtins.property
@jsii.member(jsii_name="attrClusterId")
def attr_cluster_id(self) -> ros_cdk_core.IResolvable:
'''
:Attribute: ClusterId: Cluster id
'''
return typing.cast(ros_cdk_core.IResolvable, jsii.get(self, "attrClusterId"))
@builtins.property
@jsii.member(jsii_name="attrName")
def attr_name(self) -> ros_cdk_core.IResolvable:
'''
:Attribute: Name: Cluster name
'''
return typing.cast(ros_cdk_core.IResolvable, jsii.get(self, "attrName"))
@builtins.property
@jsii.member(jsii_name="rosProperties")
def _ros_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "rosProperties"))
@builtins.property
@jsii.member(jsii_name="clusterType")
def cluster_type(self) -> typing.Union[builtins.str, ros_cdk_core.IResolvable]:
'''
:Property:
clusterType: Cluster Type:
gws.s1.standard
'''
return typing.cast(typing.Union[builtins.str, ros_cdk_core.IResolvable], jsii.get(self, "clusterType"))
@cluster_type.setter
def cluster_type(
self,
value: typing.Union[builtins.str, ros_cdk_core.IResolvable],
) -> None:
if __debug__:
def stub(
value: typing.Union[builtins.str, ros_cdk_core.IResolvable],
) -> None:
...
type_hints = typing.get_type_hints(stub)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "clusterType", value)
@builtins.property
@jsii.member(jsii_name="enableResourcePropertyConstraint")
def enable_resource_property_constraint(self) -> builtins.bool:
return typing.cast(builtins.bool, jsii.get(self, "enableResourcePropertyConstraint"))
@enable_resource_property_constraint.setter
def enable_resource_property_constraint(self, value: builtins.bool) -> None:
if __debug__:
def stub(value: builtins.bool) -> None:
...
type_hints = typing.get_type_hints(stub)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "enableResourcePropertyConstraint", value)
@builtins.property
@jsii.member(jsii_name="vpcId")
def vpc_id(self) -> typing.Union[builtins.str, ros_cdk_core.IResolvable]:
'''
:Property: vpcId: VPC id
'''
return typing.cast(typing.Union[builtins.str, ros_cdk_core.IResolvable], jsii.get(self, "vpcId"))
@vpc_id.setter
def vpc_id(
self,
value: typing.Union[builtins.str, ros_cdk_core.IResolvable],
) -> None:
if __debug__:
def stub(
value: typing.Union[builtins.str, ros_cdk_core.IResolvable],
) -> None:
...
type_hints = typing.get_type_hints(stub)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "vpcId", value)
@builtins.property
@jsii.member(jsii_name="name")
def name(
self,
) -> typing.Optional[typing.Union[builtins.str, ros_cdk_core.IResolvable]]:
'''
:Property: name: Cluster name
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, ros_cdk_core.IResolvable]], jsii.get(self, "name"))
@name.setter
def name(
self,
value: typing.Optional[typing.Union[builtins.str, ros_cdk_core.IResolvable]],
) -> None:
if __debug__:
def stub(
value: typing.Optional[typing.Union[builtins.str, ros_cdk_core.IResolvable]],
) -> None:
...
type_hints = typing.get_type_hints(stub)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "name", value)
@builtins.property
@jsii.member(jsii_name="policy")
def policy(
self,
) -> typing.Optional[typing.Union[ros_cdk_core.IResolvable, "RosCluster.PolicyProperty"]]:
'''
:Property: policy: Cluster policy
'''
return typing.cast(typing.Optional[typing.Union[ros_cdk_core.IResolvable, "RosCluster.PolicyProperty"]], jsii.get(self, "policy"))
@policy.setter
def policy(
self,
value: typing.Optional[typing.Union[ros_cdk_core.IResolvable, "RosCluster.PolicyProperty"]],
) -> None:
if __debug__:
def stub(
value: typing.Optional[typing.Union[ros_cdk_core.IResolvable, RosCluster.PolicyProperty]],
) -> None:
...
type_hints = typing.get_type_hints(stub)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "policy", value)
@builtins.property
@jsii.member(jsii_name="vSwitchId")
def v_switch_id(
self,
) -> typing.Optional[typing.Union[builtins.str, ros_cdk_core.IResolvable]]:
'''
:Property: vSwitchId: VSwitch id
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, ros_cdk_core.IResolvable]], jsii.get(self, "vSwitchId"))
@v_switch_id.setter
def v_switch_id(
self,
value: typing.Optional[typing.Union[builtins.str, ros_cdk_core.IResolvable]],
) -> None:
if __debug__:
def stub(
value: typing.Optional[typing.Union[builtins.str, ros_cdk_core.IResolvable]],
) -> None:
...
type_hints = typing.get_type_hints(stub)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "vSwitchId", value)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-gws.RosCluster.PolicyProperty",
jsii_struct_bases=[],
name_mapping={
"clipboard": "clipboard",
"local_drive": "localDrive",
"usb_redirect": "usbRedirect",
"watermark": "watermark",
},
)
class PolicyProperty:
def __init__(
self,
*,
clipboard: typing.Union[builtins.str, ros_cdk_core.IResolvable],
local_drive: typing.Union[builtins.str, ros_cdk_core.IResolvable],
usb_redirect: typing.Union[builtins.str, ros_cdk_core.IResolvable],
watermark: typing.Union[builtins.str, ros_cdk_core.IResolvable],
) -> None:
'''
:param clipboard:
:param local_drive:
:param usb_redirect:
:param watermark:
'''
if __debug__:
def stub(
*,
clipboard: typing.Union[builtins.str, ros_cdk_core.IResolvable],
local_drive: typing.Union[builtins.str, ros_cdk_core.IResolvable],
usb_redirect: typing.Union[builtins.str, ros_cdk_core.IResolvable],
watermark: typing.Union[builtins.str, ros_cdk_core.IResolvable],
) -> None:
...
type_hints = typing.get_type_hints(stub)
check_type(argname="argument clipboard", value=clipboard, expected_type=type_hints["clipboard"])
check_type(argname="argument local_drive", value=local_drive, expected_type=type_hints["local_drive"])
check_type(argname="argument usb_redirect", value=usb_redirect, expected_type=type_hints["usb_redirect"])
check_type(argname="argument watermark", value=watermark, expected_type=type_hints["watermark"])
self._values: typing.Dict[str, typing.Any] = {
"clipboard": clipboard,
"local_drive": local_drive,
"usb_redirect": usb_redirect,
"watermark": watermark,
}
@builtins.property
def clipboard(self) -> typing.Union[builtins.str, ros_cdk_core.IResolvable]:
'''
:Property: clipboard: Clipboard
'''
result = self._values.get("clipboard")
assert result is not None, "Required property 'clipboard' is missing"
return typing.cast(typing.Union[builtins.str, ros_cdk_core.IResolvable], result)
@builtins.property
def local_drive(self) -> typing.Union[builtins.str, ros_cdk_core.IResolvable]:
'''
:Property: localDrive: Local drive
'''
result = self._values.get("local_drive")
assert result is not None, "Required property 'local_drive' is missing"
return typing.cast(typing.Union[builtins.str, ros_cdk_core.IResolvable], result)
@builtins.property
def usb_redirect(self) -> typing.Union[builtins.str, ros_cdk_core.IResolvable]:
'''
:Property: usbRedirect: USB redirect
'''
result = self._values.get("usb_redirect")
assert result is not None, "Required property 'usb_redirect' is missing"
return typing.cast(typing.Union[builtins.str, ros_cdk_core.IResolvable], result)
@builtins.property
def watermark(self) -> typing.Union[builtins.str, ros_cdk_core.IResolvable]:
'''
:Property: watermark: Watermark
'''
result = self._values.get("watermark")
assert result is not None, "Required property 'watermark' is missing"
return typing.cast(typing.Union[builtins.str, ros_cdk_core.IResolvable], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "PolicyProperty(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-gws.RosClusterProps",
jsii_struct_bases=[],
name_mapping={
"cluster_type": "clusterType",
"vpc_id": "vpcId",
"name": "name",
"policy": "policy",
"v_switch_id": "vSwitchId",
},
)
class RosClusterProps:
def __init__(
self,
*,
cluster_type: typing.Union[builtins.str, ros_cdk_core.IResolvable],
vpc_id: typing.Union[builtins.str, ros_cdk_core.IResolvable],
name: typing.Optional[typing.Union[builtins.str, ros_cdk_core.IResolvable]] = None,
policy: typing.Optional[typing.Union[ros_cdk_core.IResolvable, typing.Union[RosCluster.PolicyProperty, typing.Dict[str, typing.Any]]]] = None,
v_switch_id: typing.Optional[typing.Union[builtins.str, ros_cdk_core.IResolvable]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::GWS::Cluster``.
:param cluster_type:
:param vpc_id:
:param name:
:param policy:
:param v_switch_id:
'''
if __debug__:
def stub(
*,
cluster_type: typing.Union[builtins.str, ros_cdk_core.IResolvable],
vpc_id: typing.Union[builtins.str, ros_cdk_core.IResolvable],
name: typing.Optional[typing.Union[builtins.str, ros_cdk_core.IResolvable]] = None,
policy: typing.Optional[typing.Union[ros_cdk_core.IResolvable, typing.Union[RosCluster.PolicyProperty, typing.Dict[str, typing.Any]]]] = None,
v_switch_id: typing.Optional[typing.Union[builtins.str, ros_cdk_core.IResolvable]] = None,
) -> None:
...
type_hints = typing.get_type_hints(stub)
check_type(argname="argument cluster_type", value=cluster_type, expected_type=type_hints["cluster_type"])
check_type(argname="argument vpc_id", value=vpc_id, expected_type=type_hints["vpc_id"])
check_type(argname="argument name", value=name, expected_type=type_hints["name"])
check_type(argname="argument policy", value=policy, expected_type=type_hints["policy"])
check_type(argname="argument v_switch_id", value=v_switch_id, expected_type=type_hints["v_switch_id"])
self._values: typing.Dict[str, typing.Any] = {
"cluster_type": cluster_type,
"vpc_id": vpc_id,
}
if name is not None:
self._values["name"] = name
if policy is not None:
self._values["policy"] = policy
if v_switch_id is not None:
self._values["v_switch_id"] = v_switch_id
@builtins.property
def cluster_type(self) -> typing.Union[builtins.str, ros_cdk_core.IResolvable]:
'''
:Property:
clusterType: Cluster Type:
gws.s1.standard
'''
result = self._values.get("cluster_type")
assert result is not None, "Required property 'cluster_type' is missing"
return typing.cast(typing.Union[builtins.str, ros_cdk_core.IResolvable], result)
@builtins.property
def vpc_id(self) -> typing.Union[builtins.str, ros_cdk_core.IResolvable]:
'''
:Property: vpcId: VPC id
'''
result = self._values.get("vpc_id")
assert result is not None, "Required property 'vpc_id' is missing"
return typing.cast(typing.Union[builtins.str, ros_cdk_core.IResolvable], result)
@builtins.property
def name(
self,
) -> typing.Optional[typing.Union[builtins.str, ros_cdk_core.IResolvable]]:
'''
:Property: name: Cluster name
'''
result = self._values.get("name")
return typing.cast(typing.Optional[typing.Union[builtins.str, ros_cdk_core.IResolvable]], result)
@builtins.property
def policy(
self,
) -> typing.Optional[typing.Union[ros_cdk_core.IResolvable, RosCluster.PolicyProperty]]:
'''
:Property: policy: Cluster policy
'''
result = self._values.get("policy")
return typing.cast(typing.Optional[typing.Union[ros_cdk_core.IResolvable, RosCluster.PolicyProperty]], result)
@builtins.property
def v_switch_id(
self,
) -> typing.Optional[typing.Union[builtins.str, ros_cdk_core.IResolvable]]:
'''
:Property: vSwitchId: VSwitch id
'''
result = self._values.get("v_switch_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, ros_cdk_core.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "RosClusterProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class RosInstance(
ros_cdk_core.RosResource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-gws.RosInstance",
):
'''A ROS template type: ``ALIYUN::GWS::Instance``.'''
def __init__(
self,
scope: ros_cdk_core.Construct,
id: builtins.str,
props: typing.Union["RosInstanceProps", typing.Dict[str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
'''Create a new ``ALIYUN::GWS::Instance``.
:param scope: - scope in which this resource is defined.
:param id: - scoped id of the resource.
:param props: - resource properties.
:param enable_resource_property_constraint: -
'''
if __debug__:
def stub(
scope: ros_cdk_core.Construct,
id: builtins.str,
props: typing.Union[RosInstanceProps, typing.Dict[str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
...
type_hints = typing.get_type_hints(stub)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@jsii.member(jsii_name="renderProperties")
def _render_properties(
self,
props: typing.Mapping[builtins.str, typing.Any],
) -> typing.Mapping[builtins.str, typing.Any]:
'''
:param props: -
'''
if __debug__:
def stub(props: typing.Mapping[builtins.str, typing.Any]) -> None:
...
type_hints = typing.get_type_hints(stub)
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))
@jsii.python.classproperty
@jsii.member(jsii_name="ROS_RESOURCE_TYPE_NAME")
def ROS_RESOURCE_TYPE_NAME(cls) -> builtins.str:
'''The resource type name for this resource class.'''
return typing.cast(builtins.str, jsii.sget(cls, "ROS_RESOURCE_TYPE_NAME"))
@builtins.property
@jsii.member(jsii_name="attrClusterId")
def attr_cluster_id(self) -> ros_cdk_core.IResolvable:
'''
:Attribute: ClusterId: Cluster id
'''
return typing.cast(ros_cdk_core.IResolvable, jsii.get(self, "attrClusterId"))
@builtins.property
@jsii.member(jsii_name="attrInstanceChargeType")
def attr_instance_charge_type(self) -> ros_cdk_core.IResolvable:
'''
:Attribute: InstanceChargeType: Instance charge type
'''
return typing.cast(ros_cdk_core.IResolvable, jsii.get(self, "attrInstanceChargeType"))
@builtins.property
@jsii.member(jsii_name="attrInstanceId")
def attr_instance_id(self) -> ros_cdk_core.IResolvable:
'''
:Attribute: InstanceId: Instance id
'''
return typing.cast(ros_cdk_core.IResolvable, jsii.get(self, "attrInstanceId"))
@builtins.property
@jsii.member(jsii_name="attrMaxBandwidthIn")
def attr_max_bandwidth_in(self) -> ros_cdk_core.IResolvable:
'''
:Attribute: MaxBandwidthIn: Maximum inbound bandwidth of the public network (in Mbps)
'''
return typing.cast(ros_cdk_core.IResolvable, jsii.get(self, "attrMaxBandwidthIn"))
@builtins.property
@jsii.member(jsii_name="attrMaxBandwidthOut")
def attr_max_bandwidth_out(self) -> ros_cdk_core.IResolvable:
'''
:Attribute: MaxBandwidthOut: Maximum outbound bandwidth of the public network (in Mbps)
'''
return typing.cast(ros_cdk_core.IResolvable, jsii.get(self, "attrMaxBandwidthOut"))
@builtins.property
@jsii.member(jsii_name="attrName")
def attr_name(self) -> ros_cdk_core.IResolvable:
'''
:Attribute: Name: Instance name
'''
return typing.cast(ros_cdk_core.IResolvable, jsii.get(self, "attrName"))
@builtins.property
@jsii.member(jsii_name="rosProperties")
def _ros_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "rosProperties"))
@builtins.property
@jsii.member(jsii_name="clusterId")
def cluster_id(self) -> typing.Union[builtins.str, ros_cdk_core.IResolvable]:
'''
:Property: clusterId: Cluster id
'''
return typing.cast(typing.Union[builtins.str, ros_cdk_core.IResolvable], jsii.get(self, "clusterId"))
@cluster_id.setter
def cluster_id(
self,
value: typing.Union[builtins.str, ros_cdk_core.IResolvable],
) -> None:
if __debug__:
def stub(
value: typing.Union[builtins.str, ros_cdk_core.IResolvable],
) -> None:
...
type_hints = typing.get_type_hints(stub)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "clusterId", value)
@builtins.property
@jsii.member(jsii_name="enableResourcePropertyConstraint")
def enable_resource_property_constraint(self) -> builtins.bool:
return typing.cast(builtins.bool, jsii.get(self, "enableResourcePropertyConstraint"))
@enable_resource_property_constraint.setter
def enable_resource_property_constraint(self, value: builtins.bool) -> None:
if __debug__:
def stub(value: builtins.bool) -> None:
...
type_hints = typing.get_type_hints(stub)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "enableResourcePropertyConstraint", value)
@builtins.property
@jsii.member(jsii_name="imageId")
def image_id(self) -> typing.Union[builtins.str, ros_cdk_core.IResolvable]:
'''
:Property: imageId: Mirror id
'''
return typing.cast(typing.Union[builtins.str, ros_cdk_core.IResolvable], jsii.get(self, "imageId"))
@image_id.setter
def image_id(
self,
value: typing.Union[builtins.str, ros_cdk_core.IResolvable],
) -> None:
if __debug__:
def stub(
value: typing.Union[builtins.str, ros_cdk_core.IResolvable],
) -> None:
...
type_hints = typing.get_type_hints(stub)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "imageId", value)
@builtins.property
@jsii.member(jsii_name="instanceType")
def instance_type(self) -> typing.Union[builtins.str, ros_cdk_core.IResolvable]:
'''
:Property: instanceType: Examples of specifications, see examples of racial or specifications call DescribeInstanceTypes get specification sheet.
'''
return typing.cast(typing.Union[builtins.str, ros_cdk_core.IResolvable], jsii.get(self, "instanceType"))
@instance_type.setter
def instance_type(
self,
value: typing.Union[builtins.str, ros_cdk_core.IResolvable],
) -> None:
if __debug__:
def stub(
value: typing.Union[builtins.str, ros_cdk_core.IResolvable],
) -> None:
...
type_hints = typing.get_type_hints(stub)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "instanceType", value)
@builtins.property
@jsii.member(jsii_name="systemDiskCategory")
def system_disk_category(
self,
) -> typing.Union[builtins.str, ros_cdk_core.IResolvable]:
'''
:Property: systemDiskCategory: System disk categories: cloud_ssd, cloud_essd, cloud, cloud and so on.
'''
return typing.cast(typing.Union[builtins.str, ros_cdk_core.IResolvable], jsii.get(self, "systemDiskCategory"))
@system_disk_category.setter
def system_disk_category(
self,
value: typing.Union[builtins.str, ros_cdk_core.IResolvable],
) -> None:
if __debug__:
def stub(
value: typing.Union[builtins.str, ros_cdk_core.IResolvable],
) -> None:
...
type_hints = typing.get_type_hints(stub)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "systemDiskCategory", value)
@builtins.property
@jsii.member(jsii_name="systemDiskSize")
def system_disk_size(self) -> typing.Union[jsii.Number, ros_cdk_core.IResolvable]:
'''
:Property: systemDiskSize: System disk size
'''
return typing.cast(typing.Union[jsii.Number, ros_cdk_core.IResolvable], jsii.get(self, "systemDiskSize"))
@system_disk_size.setter
def system_disk_size(
self,
value: typing.Union[jsii.Number, ros_cdk_core.IResolvable],
) -> None:
if __debug__:
def stub(
value: typing.Union[jsii.Number, ros_cdk_core.IResolvable],
) -> None:
...
type_hints = typing.get_type_hints(stub)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "systemDiskSize", value)
@builtins.property
@jsii.member(jsii_name="workMode")
def work_mode(self) -> typing.Union[builtins.str, ros_cdk_core.IResolvable]:
'''
:Property:
workMode: Work mode:
Desktop
Application
'''
return typing.cast(typing.Union[builtins.str, ros_cdk_core.IResolvable], jsii.get(self, "workMode"))
@work_mode.setter
def work_mode(
self,
value: typing.Union[builtins.str, ros_cdk_core.IResolvable],
) -> None:
if __debug__:
def stub(
value: typing.Union[builtins.str, ros_cdk_core.IResolvable],
) -> None:
...
type_hints = typing.get_type_hints(stub)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "workMode", value)
@builtins.property
@jsii.member(jsii_name="allocatePublicAddress")
def allocate_public_address(
self,
) -> typing.Optional[typing.Union[builtins.bool, ros_cdk_core.IResolvable]]:
'''
:Property: allocatePublicAddress: Whether to allocate a public network address
'''
return typing.cast(typing.Optional[typing.Union[builtins.bool, ros_cdk_core.IResolvable]], jsii.get(self, "allocatePublicAddress"))
@allocate_public_address.setter
def allocate_public_address(
self,
value: typing.Optional[typing.Union[builtins.bool, ros_cdk_core.IResolvable]],
) -> None:
if __debug__:
def stub(
value: typing.Optional[typing.Union[builtins.bool, ros_cdk_core.IResolvable]],
) -> None:
...
type_hints = typing.get_type_hints(stub)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "allocatePublicAddress", value)
@builtins.property
@jsii.member(jsii_name="appList")
def app_list(
self,
) -> typing.Optional[typing.Union[ros_cdk_core.IResolvable, typing.List[typing.Union[ros_cdk_core.IResolvable, "RosInstance.AppListProperty"]]]]:
'''
:Property: appList: App list. This value is only valid when WorkMode is Application.
'''
return typing.cast(typing.Optional[typing.Union[ros_cdk_core.IResolvable, typing.List[typing.Union[ros_cdk_core.IResolvable, "RosInstance.AppListProperty"]]]], jsii.get(self, "appList"))
@app_list.setter
def app_list(
self,
value: typing.Optional[typing.Union[ros_cdk_core.IResolvable, typing.List[typing.Union[ros_cdk_core.IResolvable, "RosInstance.AppListProperty"]]]],
) -> None:
if __debug__:
def stub(
value: typing.Optional[typing.Union[ros_cdk_core.IResolvable, typing.List[typing.Union[ros_cdk_core.IResolvable, RosInstance.AppListProperty]]]],
) -> None:
...
type_hints = typing.get_type_hints(stub)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "appList", value)
@builtins.property
@jsii.member(jsii_name="autoRenew")
def auto_renew(
self,
) -> typing.Optional[typing.Union[builtins.bool, ros_cdk_core.IResolvable]]:
'''
:Property: autoRenew: Whether auto renew
'''
return typing.cast(typing.Optional[typing.Union[builtins.bool, ros_cdk_core.IResolvable]], jsii.get(self, "autoRenew"))
@auto_renew.setter
def auto_renew(
self,
value: typing.Optional[typing.Union[builtins.bool, ros_cdk_core.IResolvable]],
) -> None:
if __debug__:
def stub(
value: typing.Optional[typing.Union[builtins.bool, ros_cdk_core.IResolvable]],
) -> None:
...
type_hints = typing.get_type_hints(stub)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "autoRenew", value)
@builtins.property
@jsii.member(jsii_name="instanceChargeType")
def instance_charge_type(
self,
) -> typing.Optional[typing.Union[builtins.str, ros_cdk_core.IResolvable]]:
'''
:Property:
instanceChargeType: Instance charge type:
PostPaid (default): Pay-As-You-Go
PrePaid: Subscription
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, ros_cdk_core.IResolvable]], jsii.get(self, "instanceChargeType"))
@instance_charge_type.setter
def instance_charge_type(
self,
value: typing.Optional[typing.Union[builtins.str, ros_cdk_core.IResolvable]],
) -> None:
if __debug__:
def stub(
value: typing.Optional[typing.Union[builtins.str, ros_cdk_core.IResolvable]],
) -> None:
...
type_hints = typing.get_type_hints(stub)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "instanceChargeType", value)
@builtins.property
@jsii.member(jsii_name="internetChargeType")
def internet_charge_type(
self,
) -> typing.Optional[typing.Union[builtins.str, ros_cdk_core.IResolvable]]:
'''
:Property:
internetChargeType: Network charge type:
PayByTraffic (default): Flow-per-use billing
PayByBandwidth: fixed-bandwidth billing
This value is only valid when AllocatePublicAddress is true.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, ros_cdk_core.IResolvable]], jsii.get(self, "internetChargeType"))
@internet_charge_type.setter
def internet_charge_type(
self,
value: typing.Optional[typing.Union[builtins.str, ros_cdk_core.IResolvable]],
) -> None:
if __debug__:
def stub(
value: typing.Optional[typing.Union[builtins.str, ros_cdk_core.IResolvable]],
) -> None:
...
type_hints = typing.get_type_hints(stub)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "internetChargeType", value)
@builtins.property
@jsii.member(jsii_name="internetMaxBandwidthOut")
def internet_max_bandwidth_out(
self,
) -> typing.Optional[typing.Union[jsii.Number, ros_cdk_core.IResolvable]]:
'''
:Property:
internetMaxBandwidthOut: Maximum outbound bandwidth of the public network (in Mbps).
Value range: 1-200
Default: 200
This value is only valid when AllocatePublicAddress is true.
'''
return typing.cast(typing.Optional[typing.Union[jsii.Number, ros_cdk_core.IResolvable]], jsii.get(self, "internetMaxBandwidthOut"))
@internet_max_bandwidth_out.setter
def internet_max_bandwidth_out(
self,
value: typing.Optional[typing.Union[jsii.Number, ros_cdk_core.IResolvable]],
) -> None:
if __debug__:
def stub(
value: typing.Optional[typing.Union[jsii.Number, ros_cdk_core.IResolvable]],
) -> None:
...
type_hints = typing.get_type_hints(stub)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "internetMaxBandwidthOut", value)
@builtins.property
@jsii.member(jsii_name="name")
def name(
self,
) -> typing.Optional[typing.Union[builtins.str, ros_cdk_core.IResolvable]]:
'''
:Property: name: Instance name
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, ros_cdk_core.IResolvable]], jsii.get(self, "name"))
@name.setter
def name(
self,
value: typing.Optional[typing.Union[builtins.str, ros_cdk_core.IResolvable]],
) -> None:
if __debug__:
def stub(
value: typing.Optional[typing.Union[builtins.str, ros_cdk_core.IResolvable]],
) -> None:
...
type_hints = typing.get_type_hints(stub)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "name", value)
@builtins.property
@jsii.member(jsii_name="period")
def period(
self,
) -> typing.Optional[typing.Union[jsii.Number, ros_cdk_core.IResolvable]]:
'''
:Property:
period: Period of subscription.
When PeriodUnit is Week, the value range is 1-4
When PeriodUnit is Month, the value range is 1-9, 12, 24, 36, 48, 60
This value is only valid when InstanceChargeType is PrePaid.
'''
return typing.cast(typing.Optional[typing.Union[jsii.Number, ros_cdk_core.IResolvable]], jsii.get(self, "period"))
@period.setter
def period(
self,
value: typing.Optional[typing.Union[jsii.Number, ros_cdk_core.IResolvable]],
) -> None:
if __debug__:
def stub(
value: typing.Optional[typing.Union[jsii.Number, ros_cdk_core.IResolvable]],
) -> None:
...
type_hints = typing.get_type_hints(stub)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "period", value)
@builtins.property
@jsii.member(jsii_name="periodUnit")
def period_unit(
self,
) -> typing.Optional[typing.Union[builtins.str, ros_cdk_core.IResolvable]]:
'''
:Property:
periodUnit: Unit of period. Week or Month.
This value is only valid when InstanceChargeType is PrePaid.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, ros_cdk_core.IResolvable]], jsii.get(self, "periodUnit"))
@period_unit.setter
def period_unit(
self,
value: typing.Optional[typing.Union[builtins.str, ros_cdk_core.IResolvable]],
) -> None:
if __debug__:
def stub(
value: typing.Optional[typing.Union[builtins.str, ros_cdk_core.IResolvable]],
) -> None:
...
type_hints = typing.get_type_hints(stub)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "periodUnit", value)
@builtins.property
@jsii.member(jsii_name="vSwitchId")
def v_switch_id(
self,
) -> typing.Optional[typing.Union[builtins.str, ros_cdk_core.IResolvable]]:
'''
:Property: vSwitchId: VSwitch id
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, ros_cdk_core.IResolvable]], jsii.get(self, "vSwitchId"))
@v_switch_id.setter
def v_switch_id(
self,
value: typing.Optional[typing.Union[builtins.str, ros_cdk_core.IResolvable]],
) -> None:
if __debug__:
def stub(
value: typing.Optional[typing.Union[builtins.str, ros_cdk_core.IResolvable]],
) -> None:
...
type_hints = typing.get_type_hints(stub)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "vSwitchId", value)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-gws.RosInstance.AppListProperty",
jsii_struct_bases=[],
name_mapping={
"app_args": "appArgs",
"app_name": "appName",
"app_path": "appPath",
},
)
class AppListProperty:
def __init__(
self,
*,
app_args: typing.Optional[typing.Union[builtins.str, ros_cdk_core.IResolvable]] = None,
app_name: typing.Optional[typing.Union[builtins.str, ros_cdk_core.IResolvable]] = None,
app_path: typing.Optional[typing.Union[builtins.str, ros_cdk_core.IResolvable]] = None,
) -> None:
'''
:param app_args:
:param app_name:
:param app_path:
'''
if __debug__:
def stub(
*,
app_args: typing.Optional[typing.Union[builtins.str, ros_cdk_core.IResolvable]] = None,
app_name: typing.Optional[typing.Union[builtins.str, ros_cdk_core.IResolvable]] = None,
app_path: typing.Optional[typing.Union[builtins.str, ros_cdk_core.IResolvable]] = None,
) -> None:
...
type_hints = typing.get_type_hints(stub)
check_type(argname="argument app_args", value=app_args, expected_type=type_hints["app_args"])
check_type(argname="argument app_name", value=app_name, expected_type=type_hints["app_name"])
check_type(argname="argument app_path", value=app_path, expected_type=type_hints["app_path"])
self._values: typing.Dict[str, typing.Any] = {}
if app_args is not None:
self._values["app_args"] = app_args
if app_name is not None:
self._values["app_name"] = app_name
if app_path is not None:
self._values["app_path"] = app_path
@builtins.property
def app_args(
self,
) -> typing.Optional[typing.Union[builtins.str, ros_cdk_core.IResolvable]]:
'''
:Property: appArgs: The running parameters of the application.
'''
result = self._values.get("app_args")
return typing.cast(typing.Optional[typing.Union[builtins.str, ros_cdk_core.IResolvable]], result)
@builtins.property
def app_name(
self,
) -> typing.Optional[typing.Union[builtins.str, ros_cdk_core.IResolvable]]:
'''
:Property: appName: The name of the application.
'''
result = self._values.get("app_name")
return typing.cast(typing.Optional[typing.Union[builtins.str, ros_cdk_core.IResolvable]], result)
@builtins.property
def app_path(
self,
) -> typing.Optional[typing.Union[builtins.str, ros_cdk_core.IResolvable]]:
'''
:Property: appPath: The running path of the application.
'''
result = self._values.get("app_path")
return typing.cast(typing.Optional[typing.Union[builtins.str, ros_cdk_core.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "AppListProperty(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-gws.RosInstanceProps",
jsii_struct_bases=[],
name_mapping={
"cluster_id": "clusterId",
"image_id": "imageId",
"instance_type": "instanceType",
"system_disk_category": "systemDiskCategory",
"system_disk_size": "systemDiskSize",
"work_mode": "workMode",
"allocate_public_address": "allocatePublicAddress",
"app_list": "appList",
"auto_renew": "autoRenew",
"instance_charge_type": "instanceChargeType",
"internet_charge_type": "internetChargeType",
"internet_max_bandwidth_out": "internetMaxBandwidthOut",
"name": "name",
"period": "period",
"period_unit": "periodUnit",
"v_switch_id": "vSwitchId",
},
)
class RosInstanceProps:
def __init__(
self,
*,
cluster_id: typing.Union[builtins.str, ros_cdk_core.IResolvable],
image_id: typing.Union[builtins.str, ros_cdk_core.IResolvable],
instance_type: typing.Union[builtins.str, ros_cdk_core.IResolvable],
system_disk_category: typing.Union[builtins.str, ros_cdk_core.IResolvable],
system_disk_size: typing.Union[jsii.Number, ros_cdk_core.IResolvable],
work_mode: typing.Union[builtins.str, ros_cdk_core.IResolvable],
allocate_public_address: typing.Optional[typing.Union[builtins.bool, ros_cdk_core.IResolvable]] = None,
app_list: typing.Optional[typing.Union[ros_cdk_core.IResolvable, typing.Sequence[typing.Union[ros_cdk_core.IResolvable, typing.Union[RosInstance.AppListProperty, typing.Dict[str, typing.Any]]]]]] = None,
auto_renew: typing.Optional[typing.Union[builtins.bool, ros_cdk_core.IResolvable]] = None,
instance_charge_type: typing.Optional[typing.Union[builtins.str, ros_cdk_core.IResolvable]] = None,
internet_charge_type: typing.Optional[typing.Union[builtins.str, ros_cdk_core.IResolvable]] = None,
internet_max_bandwidth_out: typing.Optional[typing.Union[jsii.Number, ros_cdk_core.IResolvable]] = None,
name: typing.Optional[typing.Union[builtins.str, ros_cdk_core.IResolvable]] = None,
period: typing.Optional[typing.Union[jsii.Number, ros_cdk_core.IResolvable]] = None,
period_unit: typing.Optional[typing.Union[builtins.str, ros_cdk_core.IResolvable]] = None,
v_switch_id: typing.Optional[typing.Union[builtins.str, ros_cdk_core.IResolvable]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::GWS::Instance``.
:param cluster_id:
:param image_id:
:param instance_type:
:param system_disk_category:
:param system_disk_size:
:param work_mode:
:param allocate_public_address:
:param app_list:
:param auto_renew:
:param instance_charge_type:
:param internet_charge_type:
:param internet_max_bandwidth_out:
:param name:
:param period:
:param period_unit:
:param v_switch_id:
'''
if __debug__:
def stub(
*,
cluster_id: typing.Union[builtins.str, ros_cdk_core.IResolvable],
image_id: typing.Union[builtins.str, ros_cdk_core.IResolvable],
instance_type: typing.Union[builtins.str, ros_cdk_core.IResolvable],
system_disk_category: typing.Union[builtins.str, ros_cdk_core.IResolvable],
system_disk_size: typing.Union[jsii.Number, ros_cdk_core.IResolvable],
work_mode: typing.Union[builtins.str, ros_cdk_core.IResolvable],
allocate_public_address: typing.Optional[typing.Union[builtins.bool, ros_cdk_core.IResolvable]] = None,
app_list: typing.Optional[typing.Union[ros_cdk_core.IResolvable, typing.Sequence[typing.Union[ros_cdk_core.IResolvable, typing.Union[RosInstance.AppListProperty, typing.Dict[str, typing.Any]]]]]] = None,
auto_renew: typing.Optional[typing.Union[builtins.bool, ros_cdk_core.IResolvable]] = None,
instance_charge_type: typing.Optional[typing.Union[builtins.str, ros_cdk_core.IResolvable]] = None,
internet_charge_type: typing.Optional[typing.Union[builtins.str, ros_cdk_core.IResolvable]] = None,
internet_max_bandwidth_out: typing.Optional[typing.Union[jsii.Number, ros_cdk_core.IResolvable]] = None,
name: typing.Optional[typing.Union[builtins.str, ros_cdk_core.IResolvable]] = None,
period: typing.Optional[typing.Union[jsii.Number, ros_cdk_core.IResolvable]] = None,
period_unit: typing.Optional[typing.Union[builtins.str, ros_cdk_core.IResolvable]] = None,
v_switch_id: typing.Optional[typing.Union[builtins.str, ros_cdk_core.IResolvable]] = None,
) -> None:
...
type_hints = typing.get_type_hints(stub)
check_type(argname="argument cluster_id", value=cluster_id, expected_type=type_hints["cluster_id"])
check_type(argname="argument image_id", value=image_id, expected_type=type_hints["image_id"])
check_type(argname="argument instance_type", value=instance_type, expected_type=type_hints["instance_type"])
check_type(argname="argument system_disk_category", value=system_disk_category, expected_type=type_hints["system_disk_category"])
check_type(argname="argument system_disk_size", value=system_disk_size, expected_type=type_hints["system_disk_size"])
check_type(argname="argument work_mode", value=work_mode, expected_type=type_hints["work_mode"])
check_type(argname="argument allocate_public_address", value=allocate_public_address, expected_type=type_hints["allocate_public_address"])
check_type(argname="argument app_list", value=app_list, expected_type=type_hints["app_list"])
check_type(argname="argument auto_renew", value=auto_renew, expected_type=type_hints["auto_renew"])
check_type(argname="argument instance_charge_type", value=instance_charge_type, expected_type=type_hints["instance_charge_type"])
check_type(argname="argument internet_charge_type", value=internet_charge_type, expected_type=type_hints["internet_charge_type"])
check_type(argname="argument internet_max_bandwidth_out", value=internet_max_bandwidth_out, expected_type=type_hints["internet_max_bandwidth_out"])
check_type(argname="argument name", value=name, expected_type=type_hints["name"])
check_type(argname="argument period", value=period, expected_type=type_hints["period"])
check_type(argname="argument period_unit", value=period_unit, expected_type=type_hints["period_unit"])
check_type(argname="argument v_switch_id", value=v_switch_id, expected_type=type_hints["v_switch_id"])
self._values: typing.Dict[str, typing.Any] = {
"cluster_id": cluster_id,
"image_id": image_id,
"instance_type": instance_type,
"system_disk_category": system_disk_category,
"system_disk_size": system_disk_size,
"work_mode": work_mode,
}
if allocate_public_address is not None:
self._values["allocate_public_address"] = allocate_public_address
if app_list is not None:
self._values["app_list"] = app_list
if auto_renew is not None:
self._values["auto_renew"] = auto_renew
if instance_charge_type is not None:
self._values["instance_charge_type"] = instance_charge_type
if internet_charge_type is not None:
self._values["internet_charge_type"] = internet_charge_type
if internet_max_bandwidth_out is not None:
self._values["internet_max_bandwidth_out"] = internet_max_bandwidth_out
if name is not None:
self._values["name"] = name
if period is not None:
self._values["period"] = period
if period_unit is not None:
self._values["period_unit"] = period_unit
if v_switch_id is not None:
self._values["v_switch_id"] = v_switch_id
@builtins.property
def cluster_id(self) -> typing.Union[builtins.str, ros_cdk_core.IResolvable]:
'''
:Property: clusterId: Cluster id
'''
result = self._values.get("cluster_id")
assert result is not None, "Required property 'cluster_id' is missing"
return typing.cast(typing.Union[builtins.str, ros_cdk_core.IResolvable], result)
@builtins.property
def image_id(self) -> typing.Union[builtins.str, ros_cdk_core.IResolvable]:
'''
:Property: imageId: Mirror id
'''
result = self._values.get("image_id")
assert result is not None, "Required property 'image_id' is missing"
return typing.cast(typing.Union[builtins.str, ros_cdk_core.IResolvable], result)
@builtins.property
def instance_type(self) -> typing.Union[builtins.str, ros_cdk_core.IResolvable]:
'''
:Property: instanceType: Examples of specifications, see examples of racial or specifications call DescribeInstanceTypes get specification sheet.
'''
result = self._values.get("instance_type")
assert result is not None, "Required property 'instance_type' is missing"
return typing.cast(typing.Union[builtins.str, ros_cdk_core.IResolvable], result)
@builtins.property
def system_disk_category(
self,
) -> typing.Union[builtins.str, ros_cdk_core.IResolvable]:
'''
:Property: systemDiskCategory: System disk categories: cloud_ssd, cloud_essd, cloud, cloud and so on.
'''
result = self._values.get("system_disk_category")
assert result is not None, "Required property 'system_disk_category' is missing"
return typing.cast(typing.Union[builtins.str, ros_cdk_core.IResolvable], result)
@builtins.property
def system_disk_size(self) -> typing.Union[jsii.Number, ros_cdk_core.IResolvable]:
'''
:Property: systemDiskSize: System disk size
'''
result = self._values.get("system_disk_size")
assert result is not None, "Required property 'system_disk_size' is missing"
return typing.cast(typing.Union[jsii.Number, ros_cdk_core.IResolvable], result)
@builtins.property
def work_mode(self) -> typing.Union[builtins.str, ros_cdk_core.IResolvable]:
'''
:Property:
workMode: Work mode:
Desktop
Application
'''
result = self._values.get("work_mode")
assert result is not None, "Required property 'work_mode' is missing"
return typing.cast(typing.Union[builtins.str, ros_cdk_core.IResolvable], result)
@builtins.property
def allocate_public_address(
self,
) -> typing.Optional[typing.Union[builtins.bool, ros_cdk_core.IResolvable]]:
'''
:Property: allocatePublicAddress: Whether to allocate a public network address
'''
result = self._values.get("allocate_public_address")
return typing.cast(typing.Optional[typing.Union[builtins.bool, ros_cdk_core.IResolvable]], result)
@builtins.property
def app_list(
self,
) -> typing.Optional[typing.Union[ros_cdk_core.IResolvable, typing.List[typing.Union[ros_cdk_core.IResolvable, RosInstance.AppListProperty]]]]:
'''
:Property: appList: App list. This value is only valid when WorkMode is Application.
'''
result = self._values.get("app_list")
return typing.cast(typing.Optional[typing.Union[ros_cdk_core.IResolvable, typing.List[typing.Union[ros_cdk_core.IResolvable, RosInstance.AppListProperty]]]], result)
@builtins.property
def auto_renew(
self,
) -> typing.Optional[typing.Union[builtins.bool, ros_cdk_core.IResolvable]]:
'''
:Property: autoRenew: Whether auto renew
'''
result = self._values.get("auto_renew")
return typing.cast(typing.Optional[typing.Union[builtins.bool, ros_cdk_core.IResolvable]], result)
@builtins.property
def instance_charge_type(
self,
) -> typing.Optional[typing.Union[builtins.str, ros_cdk_core.IResolvable]]:
'''
:Property:
instanceChargeType: Instance charge type:
PostPaid (default): Pay-As-You-Go
PrePaid: Subscription
'''
result = self._values.get("instance_charge_type")
return typing.cast(typing.Optional[typing.Union[builtins.str, ros_cdk_core.IResolvable]], result)
@builtins.property
def internet_charge_type(
self,
) -> typing.Optional[typing.Union[builtins.str, ros_cdk_core.IResolvable]]:
'''
:Property:
internetChargeType: Network charge type:
PayByTraffic (default): Flow-per-use billing
PayByBandwidth: fixed-bandwidth billing
This value is only valid when AllocatePublicAddress is true.
'''
result = self._values.get("internet_charge_type")
return typing.cast(typing.Optional[typing.Union[builtins.str, ros_cdk_core.IResolvable]], result)
@builtins.property
def internet_max_bandwidth_out(
self,
) -> typing.Optional[typing.Union[jsii.Number, ros_cdk_core.IResolvable]]:
'''
:Property:
internetMaxBandwidthOut: Maximum outbound bandwidth of the public network (in Mbps).
Value range: 1-200
Default: 200
This value is only valid when AllocatePublicAddress is true.
'''
result = self._values.get("internet_max_bandwidth_out")
return typing.cast(typing.Optional[typing.Union[jsii.Number, ros_cdk_core.IResolvable]], result)
@builtins.property
def name(
self,
) -> typing.Optional[typing.Union[builtins.str, ros_cdk_core.IResolvable]]:
'''
:Property: name: Instance name
'''
result = self._values.get("name")
return typing.cast(typing.Optional[typing.Union[builtins.str, ros_cdk_core.IResolvable]], result)
@builtins.property
def period(
self,
) -> typing.Optional[typing.Union[jsii.Number, ros_cdk_core.IResolvable]]:
'''
:Property:
period: Period of subscription.
When PeriodUnit is Week, the value range is 1-4
When PeriodUnit is Month, the value range is 1-9, 12, 24, 36, 48, 60
This value is only valid when InstanceChargeType is PrePaid.
'''
result = self._values.get("period")
return typing.cast(typing.Optional[typing.Union[jsii.Number, ros_cdk_core.IResolvable]], result)
@builtins.property
def period_unit(
self,
) -> typing.Optional[typing.Union[builtins.str, ros_cdk_core.IResolvable]]:
'''
:Property:
periodUnit: Unit of period. Week or Month.
This value is only valid when InstanceChargeType is PrePaid.
'''
result = self._values.get("period_unit")
return typing.cast(typing.Optional[typing.Union[builtins.str, ros_cdk_core.IResolvable]], result)
@builtins.property
def v_switch_id(
self,
) -> typing.Optional[typing.Union[builtins.str, ros_cdk_core.IResolvable]]:
'''
:Property: vSwitchId: VSwitch id
'''
result = self._values.get("v_switch_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, ros_cdk_core.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "RosInstanceProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
__all__ = [
"Cluster",
"ClusterProps",
"Instance",
"InstanceProps",
"RosCluster",
"RosClusterProps",
"RosInstance",
"RosInstanceProps",
]
publication.publish() | /ros-cdk-gws-1.0.11.tar.gz/ros-cdk-gws-1.0.11/src/ros_cdk_gws/__init__.py | 0.638497 | 0.156362 | __init__.py | pypi |
import abc
import builtins
import datetime
import enum
import typing
import jsii
import publication
import typing_extensions
from typeguard import check_type
from .._jsii import *
import ros_cdk_core as _ros_cdk_core_7adfd82f
class RosVaults(
_ros_cdk_core_7adfd82f.RosResource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-hbr.datasource.RosVaults",
):
'''A ROS template type: ``DATASOURCE::HBR::Vaults``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["RosVaultsProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
'''Create a new ``DATASOURCE::HBR::Vaults``.
:param scope: - scope in which this resource is defined.
:param id: - scoped id of the resource.
:param props: - resource properties.
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__36fd3d8f5a1cb8ef2cf1f73b7bcf903a8040c80c9c4f07bf984be7bfb6d7b2a9)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@jsii.member(jsii_name="renderProperties")
def _render_properties(
self,
props: typing.Mapping[builtins.str, typing.Any],
) -> typing.Mapping[builtins.str, typing.Any]:
'''
:param props: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__74d1502b5b837412dfe3115a8aff4d9c165636f0c6daa1b25bd2d3aeb4588bab)
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))
@jsii.python.classproperty
@jsii.member(jsii_name="ROS_RESOURCE_TYPE_NAME")
def ROS_RESOURCE_TYPE_NAME(cls) -> builtins.str:
'''The resource type name for this resource class.'''
return typing.cast(builtins.str, jsii.sget(cls, "ROS_RESOURCE_TYPE_NAME"))
@builtins.property
@jsii.member(jsii_name="attrVaultIds")
def attr_vault_ids(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: VaultIds: The list of vault IDs.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrVaultIds"))
@builtins.property
@jsii.member(jsii_name="attrVaults")
def attr_vaults(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: Vaults: The list of vaults.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrVaults"))
@builtins.property
@jsii.member(jsii_name="rosProperties")
def _ros_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "rosProperties"))
@builtins.property
@jsii.member(jsii_name="enableResourcePropertyConstraint")
def enable_resource_property_constraint(self) -> builtins.bool:
return typing.cast(builtins.bool, jsii.get(self, "enableResourcePropertyConstraint"))
@enable_resource_property_constraint.setter
def enable_resource_property_constraint(self, value: builtins.bool) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__ed313cc6219ac7beb1fb18959826bf18496775806bdb4bb9c3c93165dfb5a103)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "enableResourcePropertyConstraint", value)
@builtins.property
@jsii.member(jsii_name="vaultId")
def vault_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: vaultId: VaultId.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "vaultId"))
@vault_id.setter
def vault_id(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__d09633ca823dbcda2d5e9702bdda6f2091ca246d9a743c7e712e17b87974b807)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "vaultId", value)
@builtins.property
@jsii.member(jsii_name="vaultType")
def vault_type(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
vaultType: Vault type. Value
- **STANDARD**, which indicates a common backup vault.
- **OTS_BACKUP**, indicating OTS backup vault.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "vaultType"))
@vault_type.setter
def vault_type(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__420e826dfbac833b7333aa2a95b33643cd0bbac7a688f39f344c9a96eecb6823)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "vaultType", value)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-hbr.datasource.RosVaultsProps",
jsii_struct_bases=[],
name_mapping={"vault_id": "vaultId", "vault_type": "vaultType"},
)
class RosVaultsProps:
def __init__(
self,
*,
vault_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
vault_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``DATASOURCE::HBR::Vaults``.
:param vault_id:
:param vault_type:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__d713cd7d2e7d3553124bc02a9bbccb2e21512c91d7da8472f00cdb5e424aafab)
check_type(argname="argument vault_id", value=vault_id, expected_type=type_hints["vault_id"])
check_type(argname="argument vault_type", value=vault_type, expected_type=type_hints["vault_type"])
self._values: typing.Dict[builtins.str, typing.Any] = {}
if vault_id is not None:
self._values["vault_id"] = vault_id
if vault_type is not None:
self._values["vault_type"] = vault_type
@builtins.property
def vault_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: vaultId: VaultId.
'''
result = self._values.get("vault_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def vault_type(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
vaultType: Vault type. Value
- **STANDARD**, which indicates a common backup vault.
- **OTS_BACKUP**, indicating OTS backup vault.
'''
result = self._values.get("vault_type")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "RosVaultsProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class Vaults(
_ros_cdk_core_7adfd82f.Resource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-hbr.datasource.Vaults",
):
'''A ROS resource type: ``DATASOURCE::HBR::Vaults``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Optional[typing.Union["VaultsProps", typing.Dict[builtins.str, typing.Any]]] = None,
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
'''Create a new ``DATASOURCE::HBR::Vaults``.
Param scope - scope in which this resource is defined
Param id - scoped id of the resource
Param props - resource properties
:param scope: -
:param id: -
:param props: -
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__b4a5b0d9ebb21c59802115a8130a4d124184ff0747cf8de60866c6409904583c)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@builtins.property
@jsii.member(jsii_name="attrVaultIds")
def attr_vault_ids(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute VaultIds: The list of vault IDs.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrVaultIds"))
@builtins.property
@jsii.member(jsii_name="attrVaults")
def attr_vaults(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute Vaults: The list of vaults.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrVaults"))
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-hbr.datasource.VaultsProps",
jsii_struct_bases=[],
name_mapping={"vault_id": "vaultId", "vault_type": "vaultType"},
)
class VaultsProps:
def __init__(
self,
*,
vault_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
vault_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``DATASOURCE::HBR::Vaults``.
:param vault_id: Property vaultId: VaultId.
:param vault_type: Property vaultType: Vault type. Value - **STANDARD**, which indicates a common backup vault. - **OTS_BACKUP**, indicating OTS backup vault.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__f72cccc6308e682825f0211b1b7869b05210124bbf2de7087eb5887118dae5c4)
check_type(argname="argument vault_id", value=vault_id, expected_type=type_hints["vault_id"])
check_type(argname="argument vault_type", value=vault_type, expected_type=type_hints["vault_type"])
self._values: typing.Dict[builtins.str, typing.Any] = {}
if vault_id is not None:
self._values["vault_id"] = vault_id
if vault_type is not None:
self._values["vault_type"] = vault_type
@builtins.property
def vault_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property vaultId: VaultId.'''
result = self._values.get("vault_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def vault_type(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property vaultType: Vault type.
Value
- **STANDARD**, which indicates a common backup vault.
- **OTS_BACKUP**, indicating OTS backup vault.
'''
result = self._values.get("vault_type")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "VaultsProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
__all__ = [
"RosVaults",
"RosVaultsProps",
"Vaults",
"VaultsProps",
]
publication.publish()
def _typecheckingstub__36fd3d8f5a1cb8ef2cf1f73b7bcf903a8040c80c9c4f07bf984be7bfb6d7b2a9(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[RosVaultsProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__74d1502b5b837412dfe3115a8aff4d9c165636f0c6daa1b25bd2d3aeb4588bab(
props: typing.Mapping[builtins.str, typing.Any],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__ed313cc6219ac7beb1fb18959826bf18496775806bdb4bb9c3c93165dfb5a103(
value: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__d09633ca823dbcda2d5e9702bdda6f2091ca246d9a743c7e712e17b87974b807(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__420e826dfbac833b7333aa2a95b33643cd0bbac7a688f39f344c9a96eecb6823(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__d713cd7d2e7d3553124bc02a9bbccb2e21512c91d7da8472f00cdb5e424aafab(
*,
vault_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
vault_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__b4a5b0d9ebb21c59802115a8130a4d124184ff0747cf8de60866c6409904583c(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Optional[typing.Union[VaultsProps, typing.Dict[builtins.str, typing.Any]]] = None,
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__f72cccc6308e682825f0211b1b7869b05210124bbf2de7087eb5887118dae5c4(
*,
vault_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
vault_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass | /ros-cdk-hbr-1.0.17.tar.gz/ros-cdk-hbr-1.0.17/src/ros_cdk_hbr/datasource/__init__.py | 0.574514 | 0.169286 | __init__.py | pypi |
import abc
import builtins
import datetime
import enum
import typing
import jsii
import publication
import typing_extensions
from typeguard import check_type
from ._jsii import *
import ros_cdk_core as _ros_cdk_core_7adfd82f
class Project(
_ros_cdk_core_7adfd82f.Resource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-imm.Project",
):
'''A ROS resource type: ``ALIYUN::IMM::Project``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["ProjectProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
'''Create a new ``ALIYUN::IMM::Project``.
Param scope - scope in which this resource is defined
Param id - scoped id of the resource
Param props - resource properties
:param scope: -
:param id: -
:param props: -
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__1612fcb4340c3df6967a5118ca68582deffa442daf656533fecc4c03eef526c8)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@builtins.property
@jsii.member(jsii_name="attrProject")
def attr_project(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute Project: The name of project.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrProject"))
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-imm.ProjectProps",
jsii_struct_bases=[],
name_mapping={"project": "project", "service_role": "serviceRole"},
)
class ProjectProps:
def __init__(
self,
*,
project: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
service_role: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::IMM::Project``.
:param project: Property project: The name of project.
:param service_role: Property serviceRole: Service role, which grants the IMM service the right to access other cloud resources (such as OSS). The default value is AliyunIMMDefaultRole.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__582adcbabc3da69faf06d5aab97566ae1132b2de9f1c19e77c53f45c60123731)
check_type(argname="argument project", value=project, expected_type=type_hints["project"])
check_type(argname="argument service_role", value=service_role, expected_type=type_hints["service_role"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"project": project,
}
if service_role is not None:
self._values["service_role"] = service_role
@builtins.property
def project(self) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property project: The name of project.'''
result = self._values.get("project")
assert result is not None, "Required property 'project' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def service_role(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property serviceRole: Service role, which grants the IMM service the right to access other cloud resources (such as OSS).
The default value is AliyunIMMDefaultRole.
'''
result = self._values.get("service_role")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "ProjectProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class RosProject(
_ros_cdk_core_7adfd82f.RosResource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-imm.RosProject",
):
'''A ROS template type: ``ALIYUN::IMM::Project``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["RosProjectProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
'''Create a new ``ALIYUN::IMM::Project``.
:param scope: - scope in which this resource is defined.
:param id: - scoped id of the resource.
:param props: - resource properties.
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__0990b8684700f1e05bd22bca5a51b3dd218da4962218817c7772f8c37ce5ff00)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@jsii.member(jsii_name="renderProperties")
def _render_properties(
self,
props: typing.Mapping[builtins.str, typing.Any],
) -> typing.Mapping[builtins.str, typing.Any]:
'''
:param props: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__c4c327f202a214a1a37513268a6a70b7bf02e9c2b37486d8a124e94facc2f072)
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))
@jsii.python.classproperty
@jsii.member(jsii_name="ROS_RESOURCE_TYPE_NAME")
def ROS_RESOURCE_TYPE_NAME(cls) -> builtins.str:
'''The resource type name for this resource class.'''
return typing.cast(builtins.str, jsii.sget(cls, "ROS_RESOURCE_TYPE_NAME"))
@builtins.property
@jsii.member(jsii_name="attrProject")
def attr_project(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: Project: The name of project.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrProject"))
@builtins.property
@jsii.member(jsii_name="rosProperties")
def _ros_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "rosProperties"))
@builtins.property
@jsii.member(jsii_name="enableResourcePropertyConstraint")
def enable_resource_property_constraint(self) -> builtins.bool:
return typing.cast(builtins.bool, jsii.get(self, "enableResourcePropertyConstraint"))
@enable_resource_property_constraint.setter
def enable_resource_property_constraint(self, value: builtins.bool) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__ec208f1782a22698df11802b17638001f3da1dd0fd1aec22303e6b6e8ed9df6d)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "enableResourcePropertyConstraint", value)
@builtins.property
@jsii.member(jsii_name="project")
def project(self) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: project: The name of project.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "project"))
@project.setter
def project(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__59b253d22184ac1ec395fa5d57c291513f62ac3cd24e0a3d37d8b46f2f2d8073)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "project", value)
@builtins.property
@jsii.member(jsii_name="serviceRole")
def service_role(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: serviceRole: Service role, which grants the IMM service the right to access other cloud resources (such as OSS). The default value is AliyunIMMDefaultRole.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "serviceRole"))
@service_role.setter
def service_role(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__bc3272b33bf6c46ced0b15888a332c2055ffe165d513455b5d0765aa4b2c8211)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "serviceRole", value)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-imm.RosProjectProps",
jsii_struct_bases=[],
name_mapping={"project": "project", "service_role": "serviceRole"},
)
class RosProjectProps:
def __init__(
self,
*,
project: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
service_role: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::IMM::Project``.
:param project:
:param service_role:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__cedd5bc3682ea7c7ca8571be7d837b555e219221ed411f94e2c9da959eddc734)
check_type(argname="argument project", value=project, expected_type=type_hints["project"])
check_type(argname="argument service_role", value=service_role, expected_type=type_hints["service_role"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"project": project,
}
if service_role is not None:
self._values["service_role"] = service_role
@builtins.property
def project(self) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: project: The name of project.
'''
result = self._values.get("project")
assert result is not None, "Required property 'project' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def service_role(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: serviceRole: Service role, which grants the IMM service the right to access other cloud resources (such as OSS). The default value is AliyunIMMDefaultRole.
'''
result = self._values.get("service_role")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "RosProjectProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
__all__ = [
"Project",
"ProjectProps",
"RosProject",
"RosProjectProps",
]
publication.publish()
def _typecheckingstub__1612fcb4340c3df6967a5118ca68582deffa442daf656533fecc4c03eef526c8(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[ProjectProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__582adcbabc3da69faf06d5aab97566ae1132b2de9f1c19e77c53f45c60123731(
*,
project: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
service_role: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__0990b8684700f1e05bd22bca5a51b3dd218da4962218817c7772f8c37ce5ff00(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[RosProjectProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__c4c327f202a214a1a37513268a6a70b7bf02e9c2b37486d8a124e94facc2f072(
props: typing.Mapping[builtins.str, typing.Any],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__ec208f1782a22698df11802b17638001f3da1dd0fd1aec22303e6b6e8ed9df6d(
value: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__59b253d22184ac1ec395fa5d57c291513f62ac3cd24e0a3d37d8b46f2f2d8073(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__bc3272b33bf6c46ced0b15888a332c2055ffe165d513455b5d0765aa4b2c8211(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__cedd5bc3682ea7c7ca8571be7d837b555e219221ed411f94e2c9da959eddc734(
*,
project: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
service_role: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass | /ros-cdk-imm-1.0.17.tar.gz/ros-cdk-imm-1.0.17/src/ros_cdk_imm/__init__.py | 0.671363 | 0.173183 | __init__.py | pypi |
import abc
import builtins
import datetime
import enum
import typing
import jsii
import publication
import typing_extensions
from typeguard import check_type
from ._jsii import *
import ros_cdk_core as _ros_cdk_core_7adfd82f
class Alias(
_ros_cdk_core_7adfd82f.Resource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-kms.Alias",
):
'''A ROS resource type: ``ALIYUN::KMS::Alias``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["AliasProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
'''Create a new ``ALIYUN::KMS::Alias``.
Param scope - scope in which this resource is defined
Param id - scoped id of the resource
Param props - resource properties
:param scope: -
:param id: -
:param props: -
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__2d84b55de613bdcf76b748f0287cf92a7777fa6cdc025c0be9895ed15affd346)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-kms.AliasProps",
jsii_struct_bases=[],
name_mapping={"alias_name": "aliasName", "key_id": "keyId"},
)
class AliasProps:
def __init__(
self,
*,
alias_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
key_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
'''Properties for defining a ``ALIYUN::KMS::Alias``.
:param alias_name: Property aliasName: - The display name of the key. You can use the alias to call APIs such as Encrypt, GenerateDataKey, and DescribeKey. - Not including the prefix, the minimum length of an alias is 1 and the maximum length is 255. - The prefix alias/ must be included.
:param key_id: Property keyId: Globally unique identifier of the CMK.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__f889d0cb8aa4e3402d3225e419e6628ef6c5aa948f4b5a44d8d29108e001e232)
check_type(argname="argument alias_name", value=alias_name, expected_type=type_hints["alias_name"])
check_type(argname="argument key_id", value=key_id, expected_type=type_hints["key_id"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"alias_name": alias_name,
"key_id": key_id,
}
@builtins.property
def alias_name(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property aliasName: - The display name of the key.
You can use the alias to call APIs such as Encrypt, GenerateDataKey, and DescribeKey. - Not including the prefix, the minimum length of an alias is 1 and the maximum length is 255. - The prefix alias/ must be included.
'''
result = self._values.get("alias_name")
assert result is not None, "Required property 'alias_name' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def key_id(self) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property keyId: Globally unique identifier of the CMK.'''
result = self._values.get("key_id")
assert result is not None, "Required property 'key_id' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "AliasProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class Key(
_ros_cdk_core_7adfd82f.Resource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-kms.Key",
):
'''A ROS resource type: ``ALIYUN::KMS::Key``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Optional[typing.Union["KeyProps", typing.Dict[builtins.str, typing.Any]]] = None,
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
'''Create a new ``ALIYUN::KMS::Key``.
Param scope - scope in which this resource is defined
Param id - scoped id of the resource
Param props - resource properties
:param scope: -
:param id: -
:param props: -
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__43ec175dd3033fca91582b45c33da55f637eff186c676a14e5bad3cac7b6816a)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@builtins.property
@jsii.member(jsii_name="attrKeyId")
def attr_key_id(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute KeyId: The globally unique identifier for the CMK.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrKeyId"))
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-kms.KeyProps",
jsii_struct_bases=[],
name_mapping={
"description": "description",
"dkms_instance_id": "dkmsInstanceId",
"enable": "enable",
"enable_automatic_rotation": "enableAutomaticRotation",
"key_spec": "keySpec",
"key_usage": "keyUsage",
"pending_window_in_days": "pendingWindowInDays",
"protection_level": "protectionLevel",
"rotation_interval": "rotationInterval",
},
)
class KeyProps:
def __init__(
self,
*,
description: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
dkms_instance_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
enable: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
enable_automatic_rotation: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
key_spec: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
key_usage: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
pending_window_in_days: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
protection_level: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
rotation_interval: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::KMS::Key``.
:param description: Property description: The description of the CMK. Length constraints: Minimum length of 0 characters. Maximum length of 8192 characters.
:param dkms_instance_id: Property dkmsInstanceId: The ID of the dedicated KMS instance.
:param enable: Property enable: Specifies whether the key is enabled. Defaults to true.
:param enable_automatic_rotation: Property enableAutomaticRotation: Whether to enable automatic key rotation. Valid value: true/false (default)
:param key_spec: Property keySpec: Key type. Valid value: Aliyun_AES_256/Aliyun_SM4/RSA_2048/EC_P256/EC_P256K/EC_SM2
:param key_usage: Property keyUsage: The usage of the CMK. Valid values: ENCRYPT/DECRYPT: encrypts or decrypts data. SIGN/VERIFY: generates or verifies a digital signature. If the CMK supports signature verification, the default value is SIGN/VERIFY. If the CMK does not support signature verification, the default value is ENCRYPT/DECRYPT.
:param pending_window_in_days: Property pendingWindowInDays: The waiting period, specified in number of days. During this period, you can cancel the CMK in PendingDeletion status. After the waiting period expires, you cannot cancel the deletion. The value must be between 7 and 366. Default value is 30.
:param protection_level: Property protectionLevel: The protection level of the CMK to create. Valid value: SOFTWARE and HSM. When this parameter is set to HSM: If the Origin parameter is set to Aliyun_KMS, the CMK is created in Managed HSM. If the Origin parameter is set to EXTERNAL, you can import external keys to Managed HSM.
:param rotation_interval: Property rotationInterval: The time period for automatic rotation. The format is integer[unit], where integer represents the length of time and unit represents the time unit. The legal unit units are: d (day), h (hour), m (minute), s (second). 7d or 604800s both represent a 7-day cycle. Value: 7~730 days.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__46d9a9efb2e8afe83cf572cd8a027ba567e0f1734b5dbbb6d462d22b88711c5d)
check_type(argname="argument description", value=description, expected_type=type_hints["description"])
check_type(argname="argument dkms_instance_id", value=dkms_instance_id, expected_type=type_hints["dkms_instance_id"])
check_type(argname="argument enable", value=enable, expected_type=type_hints["enable"])
check_type(argname="argument enable_automatic_rotation", value=enable_automatic_rotation, expected_type=type_hints["enable_automatic_rotation"])
check_type(argname="argument key_spec", value=key_spec, expected_type=type_hints["key_spec"])
check_type(argname="argument key_usage", value=key_usage, expected_type=type_hints["key_usage"])
check_type(argname="argument pending_window_in_days", value=pending_window_in_days, expected_type=type_hints["pending_window_in_days"])
check_type(argname="argument protection_level", value=protection_level, expected_type=type_hints["protection_level"])
check_type(argname="argument rotation_interval", value=rotation_interval, expected_type=type_hints["rotation_interval"])
self._values: typing.Dict[builtins.str, typing.Any] = {}
if description is not None:
self._values["description"] = description
if dkms_instance_id is not None:
self._values["dkms_instance_id"] = dkms_instance_id
if enable is not None:
self._values["enable"] = enable
if enable_automatic_rotation is not None:
self._values["enable_automatic_rotation"] = enable_automatic_rotation
if key_spec is not None:
self._values["key_spec"] = key_spec
if key_usage is not None:
self._values["key_usage"] = key_usage
if pending_window_in_days is not None:
self._values["pending_window_in_days"] = pending_window_in_days
if protection_level is not None:
self._values["protection_level"] = protection_level
if rotation_interval is not None:
self._values["rotation_interval"] = rotation_interval
@builtins.property
def description(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property description: The description of the CMK.
Length constraints: Minimum length of 0 characters. Maximum length of 8192 characters.
'''
result = self._values.get("description")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def dkms_instance_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property dkmsInstanceId: The ID of the dedicated KMS instance.'''
result = self._values.get("dkms_instance_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def enable(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property enable: Specifies whether the key is enabled.
Defaults to true.
'''
result = self._values.get("enable")
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def enable_automatic_rotation(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property enableAutomaticRotation: Whether to enable automatic key rotation.
Valid value: true/false (default)
'''
result = self._values.get("enable_automatic_rotation")
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def key_spec(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property keySpec: Key type.
Valid value: Aliyun_AES_256/Aliyun_SM4/RSA_2048/EC_P256/EC_P256K/EC_SM2
'''
result = self._values.get("key_spec")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def key_usage(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property keyUsage: The usage of the CMK.
Valid values:
ENCRYPT/DECRYPT: encrypts or decrypts data.
SIGN/VERIFY: generates or verifies a digital signature.
If the CMK supports signature verification, the default value is SIGN/VERIFY. If the CMK does not support signature verification, the default value is ENCRYPT/DECRYPT.
'''
result = self._values.get("key_usage")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def pending_window_in_days(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property pendingWindowInDays: The waiting period, specified in number of days.
During this period, you can cancel the CMK in PendingDeletion status. After the waiting period expires, you cannot cancel the deletion. The value must be between 7 and 366. Default value is 30.
'''
result = self._values.get("pending_window_in_days")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def protection_level(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property protectionLevel: The protection level of the CMK to create.
Valid value: SOFTWARE and HSM. When this parameter is set to HSM:
If the Origin parameter is set to Aliyun_KMS, the CMK is created in Managed HSM.
If the Origin parameter is set to EXTERNAL, you can import external keys to Managed HSM.
'''
result = self._values.get("protection_level")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def rotation_interval(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property rotationInterval: The time period for automatic rotation.
The format is integer[unit], where integer represents the length of time and unit represents the time unit. The legal unit units are: d (day), h (hour), m (minute), s (second). 7d or 604800s both represent a 7-day cycle. Value: 7~730 days.
'''
result = self._values.get("rotation_interval")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "KeyProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class RosAlias(
_ros_cdk_core_7adfd82f.RosResource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-kms.RosAlias",
):
'''A ROS template type: ``ALIYUN::KMS::Alias``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["RosAliasProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
'''Create a new ``ALIYUN::KMS::Alias``.
:param scope: - scope in which this resource is defined.
:param id: - scoped id of the resource.
:param props: - resource properties.
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__58ae2b2ab6cdf6c54fb0e37c0774cc63f395eea609ba3da41129828a48b7257a)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@jsii.member(jsii_name="renderProperties")
def _render_properties(
self,
props: typing.Mapping[builtins.str, typing.Any],
) -> typing.Mapping[builtins.str, typing.Any]:
'''
:param props: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__c7eaa5bae0816bcf2b2723748af01a54e03f60a6c8f1916eb920e7cdef77e32c)
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))
@jsii.python.classproperty
@jsii.member(jsii_name="ROS_RESOURCE_TYPE_NAME")
def ROS_RESOURCE_TYPE_NAME(cls) -> builtins.str:
'''The resource type name for this resource class.'''
return typing.cast(builtins.str, jsii.sget(cls, "ROS_RESOURCE_TYPE_NAME"))
@builtins.property
@jsii.member(jsii_name="rosProperties")
def _ros_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "rosProperties"))
@builtins.property
@jsii.member(jsii_name="aliasName")
def alias_name(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: aliasName: - The display name of the key. You can use the alias to call APIs such as Encrypt, GenerateDataKey, and DescribeKey. - Not including the prefix, the minimum length of an alias is 1 and the maximum length is 255. - The prefix alias/ must be included.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "aliasName"))
@alias_name.setter
def alias_name(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__b20ffbbca84f490bd06e47e714c9ac73149297bbc454a3cdf8640bdd70e28b3d)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "aliasName", value)
@builtins.property
@jsii.member(jsii_name="enableResourcePropertyConstraint")
def enable_resource_property_constraint(self) -> builtins.bool:
'''A factory method that creates a new instance of this class from an object containing the properties of this ROS resource.'''
return typing.cast(builtins.bool, jsii.get(self, "enableResourcePropertyConstraint"))
@enable_resource_property_constraint.setter
def enable_resource_property_constraint(self, value: builtins.bool) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__4a0aff505d1fcb79e4b680b1d68789117f0752cf950a7731989a040a15f61e17)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "enableResourcePropertyConstraint", value)
@builtins.property
@jsii.member(jsii_name="keyId")
def key_id(self) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: keyId: Globally unique identifier of the CMK.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "keyId"))
@key_id.setter
def key_id(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__4c2bd31c15e61742d8e2c02643b0d230d57130ca216980a06ac13ba2943e59b4)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "keyId", value)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-kms.RosAliasProps",
jsii_struct_bases=[],
name_mapping={"alias_name": "aliasName", "key_id": "keyId"},
)
class RosAliasProps:
def __init__(
self,
*,
alias_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
key_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
'''Properties for defining a ``ALIYUN::KMS::Alias``.
:param alias_name:
:param key_id:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__883b1f45a3bc36d63bcb4dc59937e8d0a3fee32b273870433b7176fb904e0412)
check_type(argname="argument alias_name", value=alias_name, expected_type=type_hints["alias_name"])
check_type(argname="argument key_id", value=key_id, expected_type=type_hints["key_id"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"alias_name": alias_name,
"key_id": key_id,
}
@builtins.property
def alias_name(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: aliasName: - The display name of the key. You can use the alias to call APIs such as Encrypt, GenerateDataKey, and DescribeKey. - Not including the prefix, the minimum length of an alias is 1 and the maximum length is 255. - The prefix alias/ must be included.
'''
result = self._values.get("alias_name")
assert result is not None, "Required property 'alias_name' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def key_id(self) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: keyId: Globally unique identifier of the CMK.
'''
result = self._values.get("key_id")
assert result is not None, "Required property 'key_id' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "RosAliasProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class RosKey(
_ros_cdk_core_7adfd82f.RosResource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-kms.RosKey",
):
'''A ROS template type: ``ALIYUN::KMS::Key``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["RosKeyProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
'''Create a new ``ALIYUN::KMS::Key``.
:param scope: - scope in which this resource is defined.
:param id: - scoped id of the resource.
:param props: - resource properties.
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__28dd1fc1704c23bfb17c18b3e03ed5157b821276907a684ed5d60829c191ac7c)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@jsii.member(jsii_name="renderProperties")
def _render_properties(
self,
props: typing.Mapping[builtins.str, typing.Any],
) -> typing.Mapping[builtins.str, typing.Any]:
'''
:param props: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__7e61cb3c251854069fcbf77c5bc7e6963a0bde8c8012b35b79d78af2d0463d5d)
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))
@jsii.python.classproperty
@jsii.member(jsii_name="ROS_RESOURCE_TYPE_NAME")
def ROS_RESOURCE_TYPE_NAME(cls) -> builtins.str:
'''The resource type name for this resource class.'''
return typing.cast(builtins.str, jsii.sget(cls, "ROS_RESOURCE_TYPE_NAME"))
@builtins.property
@jsii.member(jsii_name="attrKeyId")
def attr_key_id(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: KeyId: The globally unique identifier for the CMK.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrKeyId"))
@builtins.property
@jsii.member(jsii_name="rosProperties")
def _ros_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "rosProperties"))
@builtins.property
@jsii.member(jsii_name="enableResourcePropertyConstraint")
def enable_resource_property_constraint(self) -> builtins.bool:
return typing.cast(builtins.bool, jsii.get(self, "enableResourcePropertyConstraint"))
@enable_resource_property_constraint.setter
def enable_resource_property_constraint(self, value: builtins.bool) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__d31e59b3ed53a78c9421ce07e15473c2a79d40ac0591fe737294b14ee292df3c)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "enableResourcePropertyConstraint", value)
@builtins.property
@jsii.member(jsii_name="description")
def description(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: description: The description of the CMK. Length constraints: Minimum length of 0 characters. Maximum length of 8192 characters.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "description"))
@description.setter
def description(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__36a182a13fa1f0d5bc5717ba6ff7c4cc51041ba7fe11f79e657c273893458bb7)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "description", value)
@builtins.property
@jsii.member(jsii_name="dkmsInstanceId")
def dkms_instance_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: dkmsInstanceId: The ID of the dedicated KMS instance.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "dkmsInstanceId"))
@dkms_instance_id.setter
def dkms_instance_id(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__cc1281479c4004281d8d23b0d8c2863ea5ed1e5d154c236c08d90e65a5fef543)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "dkmsInstanceId", value)
@builtins.property
@jsii.member(jsii_name="enable")
def enable(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: enable: Specifies whether the key is enabled. Defaults to true.
'''
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "enable"))
@enable.setter
def enable(
self,
value: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__42022b89ff4eab02d371f5a96e8d40b52ebb0c7a3fe88d160638dc2796e36a1e)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "enable", value)
@builtins.property
@jsii.member(jsii_name="enableAutomaticRotation")
def enable_automatic_rotation(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: enableAutomaticRotation: Whether to enable automatic key rotation. Valid value: true/false (default)
'''
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "enableAutomaticRotation"))
@enable_automatic_rotation.setter
def enable_automatic_rotation(
self,
value: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__766425b4ed72a9f7392891d89bc3e16ef9e03f0c1758870514f89e7924b4fc00)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "enableAutomaticRotation", value)
@builtins.property
@jsii.member(jsii_name="keySpec")
def key_spec(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: keySpec: Key type. Valid value: Aliyun_AES_256/Aliyun_SM4/RSA_2048/EC_P256/EC_P256K/EC_SM2
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "keySpec"))
@key_spec.setter
def key_spec(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__628647a3b81c9e938cb382743e20554a9428650359f767cd1afb401f7dada288)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "keySpec", value)
@builtins.property
@jsii.member(jsii_name="keyUsage")
def key_usage(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
keyUsage: The usage of the CMK. Valid values:
ENCRYPT/DECRYPT: encrypts or decrypts data.
SIGN/VERIFY: generates or verifies a digital signature.
If the CMK supports signature verification, the default value is SIGN/VERIFY. If the CMK does not support signature verification, the default value is ENCRYPT/DECRYPT.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "keyUsage"))
@key_usage.setter
def key_usage(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__b0130ffa22ecece206cd498917b5890c195261c7e45e4532b62759fb742d6709)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "keyUsage", value)
@builtins.property
@jsii.member(jsii_name="pendingWindowInDays")
def pending_window_in_days(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: pendingWindowInDays: The waiting period, specified in number of days. During this period, you can cancel the CMK in PendingDeletion status. After the waiting period expires, you cannot cancel the deletion. The value must be between 7 and 366. Default value is 30.
'''
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "pendingWindowInDays"))
@pending_window_in_days.setter
def pending_window_in_days(
self,
value: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__781c18250da0a30c26157cb65f9af850defd7205556d3956e12ef75ae9a2d876)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "pendingWindowInDays", value)
@builtins.property
@jsii.member(jsii_name="protectionLevel")
def protection_level(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
protectionLevel: The protection level of the CMK to create. Valid value: SOFTWARE and HSM. When this parameter is set to HSM:
If the Origin parameter is set to Aliyun_KMS, the CMK is created in Managed HSM.
If the Origin parameter is set to EXTERNAL, you can import external keys to Managed HSM.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "protectionLevel"))
@protection_level.setter
def protection_level(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__37a33bda5bd597749acb91ea5b89bce164a6fc7c82fe12772030635be5d63de0)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "protectionLevel", value)
@builtins.property
@jsii.member(jsii_name="rotationInterval")
def rotation_interval(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: rotationInterval: The time period for automatic rotation. The format is integer[unit], where integer represents the length of time and unit represents the time unit. The legal unit units are: d (day), h (hour), m (minute), s (second). 7d or 604800s both represent a 7-day cycle. Value: 7~730 days.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "rotationInterval"))
@rotation_interval.setter
def rotation_interval(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__623040d58497cb35ae08e3ebab8b107624675590e71b906b3b817202c4019bde)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "rotationInterval", value)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-kms.RosKeyProps",
jsii_struct_bases=[],
name_mapping={
"description": "description",
"dkms_instance_id": "dkmsInstanceId",
"enable": "enable",
"enable_automatic_rotation": "enableAutomaticRotation",
"key_spec": "keySpec",
"key_usage": "keyUsage",
"pending_window_in_days": "pendingWindowInDays",
"protection_level": "protectionLevel",
"rotation_interval": "rotationInterval",
},
)
class RosKeyProps:
def __init__(
self,
*,
description: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
dkms_instance_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
enable: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
enable_automatic_rotation: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
key_spec: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
key_usage: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
pending_window_in_days: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
protection_level: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
rotation_interval: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::KMS::Key``.
:param description:
:param dkms_instance_id:
:param enable:
:param enable_automatic_rotation:
:param key_spec:
:param key_usage:
:param pending_window_in_days:
:param protection_level:
:param rotation_interval:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__bca81428725d92140b30bca0cde5fe7eff1fb7a179a783874638e54d197a2513)
check_type(argname="argument description", value=description, expected_type=type_hints["description"])
check_type(argname="argument dkms_instance_id", value=dkms_instance_id, expected_type=type_hints["dkms_instance_id"])
check_type(argname="argument enable", value=enable, expected_type=type_hints["enable"])
check_type(argname="argument enable_automatic_rotation", value=enable_automatic_rotation, expected_type=type_hints["enable_automatic_rotation"])
check_type(argname="argument key_spec", value=key_spec, expected_type=type_hints["key_spec"])
check_type(argname="argument key_usage", value=key_usage, expected_type=type_hints["key_usage"])
check_type(argname="argument pending_window_in_days", value=pending_window_in_days, expected_type=type_hints["pending_window_in_days"])
check_type(argname="argument protection_level", value=protection_level, expected_type=type_hints["protection_level"])
check_type(argname="argument rotation_interval", value=rotation_interval, expected_type=type_hints["rotation_interval"])
self._values: typing.Dict[builtins.str, typing.Any] = {}
if description is not None:
self._values["description"] = description
if dkms_instance_id is not None:
self._values["dkms_instance_id"] = dkms_instance_id
if enable is not None:
self._values["enable"] = enable
if enable_automatic_rotation is not None:
self._values["enable_automatic_rotation"] = enable_automatic_rotation
if key_spec is not None:
self._values["key_spec"] = key_spec
if key_usage is not None:
self._values["key_usage"] = key_usage
if pending_window_in_days is not None:
self._values["pending_window_in_days"] = pending_window_in_days
if protection_level is not None:
self._values["protection_level"] = protection_level
if rotation_interval is not None:
self._values["rotation_interval"] = rotation_interval
@builtins.property
def description(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: description: The description of the CMK. Length constraints: Minimum length of 0 characters. Maximum length of 8192 characters.
'''
result = self._values.get("description")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def dkms_instance_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: dkmsInstanceId: The ID of the dedicated KMS instance.
'''
result = self._values.get("dkms_instance_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def enable(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: enable: Specifies whether the key is enabled. Defaults to true.
'''
result = self._values.get("enable")
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def enable_automatic_rotation(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: enableAutomaticRotation: Whether to enable automatic key rotation. Valid value: true/false (default)
'''
result = self._values.get("enable_automatic_rotation")
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def key_spec(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: keySpec: Key type. Valid value: Aliyun_AES_256/Aliyun_SM4/RSA_2048/EC_P256/EC_P256K/EC_SM2
'''
result = self._values.get("key_spec")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def key_usage(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
keyUsage: The usage of the CMK. Valid values:
ENCRYPT/DECRYPT: encrypts or decrypts data.
SIGN/VERIFY: generates or verifies a digital signature.
If the CMK supports signature verification, the default value is SIGN/VERIFY. If the CMK does not support signature verification, the default value is ENCRYPT/DECRYPT.
'''
result = self._values.get("key_usage")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def pending_window_in_days(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: pendingWindowInDays: The waiting period, specified in number of days. During this period, you can cancel the CMK in PendingDeletion status. After the waiting period expires, you cannot cancel the deletion. The value must be between 7 and 366. Default value is 30.
'''
result = self._values.get("pending_window_in_days")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def protection_level(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
protectionLevel: The protection level of the CMK to create. Valid value: SOFTWARE and HSM. When this parameter is set to HSM:
If the Origin parameter is set to Aliyun_KMS, the CMK is created in Managed HSM.
If the Origin parameter is set to EXTERNAL, you can import external keys to Managed HSM.
'''
result = self._values.get("protection_level")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def rotation_interval(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: rotationInterval: The time period for automatic rotation. The format is integer[unit], where integer represents the length of time and unit represents the time unit. The legal unit units are: d (day), h (hour), m (minute), s (second). 7d or 604800s both represent a 7-day cycle. Value: 7~730 days.
'''
result = self._values.get("rotation_interval")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "RosKeyProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class RosSecret(
_ros_cdk_core_7adfd82f.RosResource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-kms.RosSecret",
):
'''A ROS template type: ``ALIYUN::KMS::Secret``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["RosSecretProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
'''Create a new ``ALIYUN::KMS::Secret``.
:param scope: - scope in which this resource is defined.
:param id: - scoped id of the resource.
:param props: - resource properties.
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__8b5741850c81a916c5989f99983673f36656796a788dd2452c0129890cca34b6)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@jsii.member(jsii_name="renderProperties")
def _render_properties(
self,
props: typing.Mapping[builtins.str, typing.Any],
) -> typing.Mapping[builtins.str, typing.Any]:
'''
:param props: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__82342dcb733ac8f12ae557eec20e74bf96fab9bfe0ada4d96a171f07304ddfda)
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))
@jsii.python.classproperty
@jsii.member(jsii_name="ROS_RESOURCE_TYPE_NAME")
def ROS_RESOURCE_TYPE_NAME(cls) -> builtins.str:
'''The resource type name for this resource class.'''
return typing.cast(builtins.str, jsii.sget(cls, "ROS_RESOURCE_TYPE_NAME"))
@builtins.property
@jsii.member(jsii_name="attrArn")
def attr_arn(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: Arn: The Alibaba Cloud Resource Name (ARN).
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrArn"))
@builtins.property
@jsii.member(jsii_name="attrSecretName")
def attr_secret_name(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: SecretName: The name of the secret.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrSecretName"))
@builtins.property
@jsii.member(jsii_name="rosProperties")
def _ros_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "rosProperties"))
@builtins.property
@jsii.member(jsii_name="enableResourcePropertyConstraint")
def enable_resource_property_constraint(self) -> builtins.bool:
return typing.cast(builtins.bool, jsii.get(self, "enableResourcePropertyConstraint"))
@enable_resource_property_constraint.setter
def enable_resource_property_constraint(self, value: builtins.bool) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__5001f4e03d1fbf3010ba019dc79dafc2d7e67a944779bff473be408d339e3709)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "enableResourcePropertyConstraint", value)
@builtins.property
@jsii.member(jsii_name="secretData")
def secret_data(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
secretData: The value of the secret that you want to create. Secrets Manager encrypts the secret
value and stores it in the initial version.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "secretData"))
@secret_data.setter
def secret_data(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__1e592678bac7b2e44a8e1faa56adc582b883e5cc627359bc3a572c7dd9077acb)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "secretData", value)
@builtins.property
@jsii.member(jsii_name="secretName")
def secret_name(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: secretName: The name of the secret.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "secretName"))
@secret_name.setter
def secret_name(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__44f64c594383423fa8217bbe455c42334979fe7599a1e2be155e8433c24302d4)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "secretName", value)
@builtins.property
@jsii.member(jsii_name="versionId")
def version_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
versionId: The version number of the initial version. Version numbers are unique in each secret
object.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "versionId"))
@version_id.setter
def version_id(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__368499400378014795e926d0c21628cc96fcfe68a2f12d6d1cc85083c2eab863)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "versionId", value)
@builtins.property
@jsii.member(jsii_name="description")
def description(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: description: The description of the secret.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "description"))
@description.setter
def description(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__bd81ed7e4da6707b77c2a6c44590e77038568c23bb5fc64f0687e73e9b4a360c)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "description", value)
@builtins.property
@jsii.member(jsii_name="dkmsInstanceId")
def dkms_instance_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: dkmsInstanceId: The ID of the dedicated KMS instance.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "dkmsInstanceId"))
@dkms_instance_id.setter
def dkms_instance_id(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__a443461ffa3d2965967b9e3f4fd1727f94df2f368653f0c40b266b24dc68fcc4)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "dkmsInstanceId", value)
@builtins.property
@jsii.member(jsii_name="enableAutomaticRotation")
def enable_automatic_rotation(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
enableAutomaticRotation: Specifies whether to enable automatic rotation. Valid values:
true: specifies to enable automatic rotation.
false: specifies to disable automatic rotation. This is the default value.
'''
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "enableAutomaticRotation"))
@enable_automatic_rotation.setter
def enable_automatic_rotation(
self,
value: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__1e28b945206719717bd068a5ab46a0a94f8b57c88367dbeba9ded4912c417daa)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "enableAutomaticRotation", value)
@builtins.property
@jsii.member(jsii_name="encryptionKeyId")
def encryption_key_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
encryptionKeyId: The ID of the KMS CMK that is used to encrypt the secret value.
If you do not specify this parameter, Secrets Manager automatically creates an encryption
key to encrypt the secret.
Note The KMS CMK must be a symmetric key.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "encryptionKeyId"))
@encryption_key_id.setter
def encryption_key_id(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__b5e805cbeabc12ed1f3fe2064cc47697c5f3a7f1ef3f97bd32051682d1f7b12f)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "encryptionKeyId", value)
@builtins.property
@jsii.member(jsii_name="extendedConfig")
def extended_config(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]]:
'''
:Property: extendedConfig: The extended configuration of the secret. This parameter specifies the properties of the secret of the specific type.
'''
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]], jsii.get(self, "extendedConfig"))
@extended_config.setter
def extended_config(
self,
value: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__665295dced0f788c88dee7b072597085400890af7b839e9b4d4f1ad43ef0760d)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "extendedConfig", value)
@builtins.property
@jsii.member(jsii_name="forceDeleteWithoutRecovery")
def force_delete_without_recovery(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
forceDeleteWithoutRecovery: Specifies whether to forcibly delete the secret. If this parameter is set to true, the secret cannot be recovered. Valid values:
true
false (default value)
'''
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "forceDeleteWithoutRecovery"))
@force_delete_without_recovery.setter
def force_delete_without_recovery(
self,
value: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__795033bd5b14a25538ec652e70d4d75f08d62415172a80681e45b9e3132a99ae)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "forceDeleteWithoutRecovery", value)
@builtins.property
@jsii.member(jsii_name="recoveryWindowInDays")
def recovery_window_in_days(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: recoveryWindowInDays: Specifies the recovery period of the secret if you do not forcibly delete it. Default value: 30
'''
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "recoveryWindowInDays"))
@recovery_window_in_days.setter
def recovery_window_in_days(
self,
value: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__4741b8cfd5f57336e3648d331400d3faf7ac4a7a6ade01b7636919b8bfd534ff)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "recoveryWindowInDays", value)
@builtins.property
@jsii.member(jsii_name="rotationInterval")
def rotation_interval(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
rotationInterval: The interval for automatic rotation. Valid values: 6 hours to 8,760 hours (365 days).
The value is in the integer[unit] format.
The unit can be d (day), h (hour), m (minute), or s (second). For example, both 7d and 604800s indicate a seven-day interval.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "rotationInterval"))
@rotation_interval.setter
def rotation_interval(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__70e2c3e453870e9d9a91da230df7cdfc886d1bb569d5115856119a4ef13a07bc)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "rotationInterval", value)
@builtins.property
@jsii.member(jsii_name="secretDataType")
def secret_data_type(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
secretDataType: The type of the secret value. Valid values:
text (default value)
binary
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "secretDataType"))
@secret_data_type.setter
def secret_data_type(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__6e5778fa12bdf5b2866701d0276fb95491b924155e2d5b609c7b78028d356f66)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "secretDataType", value)
@builtins.property
@jsii.member(jsii_name="secretType")
def secret_type(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
secretType: The type of the secret. Valid values:
Generic: specifies a generic secret.
Rds: specifies a managed ApsaraDB RDS secret.
RAMCredentials: specifies a managed RAM secret.
ECS: specifies a managed ECS secret.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "secretType"))
@secret_type.setter
def secret_type(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__c583c4ecf1182cb5d94cbaf0233b3f9220393d289e2bbd0597f596bf44d5f129)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "secretType", value)
@builtins.property
@jsii.member(jsii_name="versionStages")
def version_stages(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]]:
'''
:Property: versionStages: The stage labels that mark the secret version. ACSCurrent will be marked as DefaultIf you do not specify it, Secrets Manager marks it with "ACSCurrent".
'''
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]], jsii.get(self, "versionStages"))
@version_stages.setter
def version_stages(
self,
value: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__e061489cfbc1b62d514a9dd61320690c12dc1867e894c55fa050f95752ffcb7d)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "versionStages", value)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-kms.RosSecretProps",
jsii_struct_bases=[],
name_mapping={
"secret_data": "secretData",
"secret_name": "secretName",
"version_id": "versionId",
"description": "description",
"dkms_instance_id": "dkmsInstanceId",
"enable_automatic_rotation": "enableAutomaticRotation",
"encryption_key_id": "encryptionKeyId",
"extended_config": "extendedConfig",
"force_delete_without_recovery": "forceDeleteWithoutRecovery",
"recovery_window_in_days": "recoveryWindowInDays",
"rotation_interval": "rotationInterval",
"secret_data_type": "secretDataType",
"secret_type": "secretType",
"version_stages": "versionStages",
},
)
class RosSecretProps:
def __init__(
self,
*,
secret_data: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
secret_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
version_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
description: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
dkms_instance_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
enable_automatic_rotation: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
encryption_key_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
extended_config: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]] = None,
force_delete_without_recovery: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
recovery_window_in_days: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
rotation_interval: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
secret_data_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
secret_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
version_stages: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::KMS::Secret``.
:param secret_data:
:param secret_name:
:param version_id:
:param description:
:param dkms_instance_id:
:param enable_automatic_rotation:
:param encryption_key_id:
:param extended_config:
:param force_delete_without_recovery:
:param recovery_window_in_days:
:param rotation_interval:
:param secret_data_type:
:param secret_type:
:param version_stages:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__40c88ab19e625b93cc2d4808001c6ce0b82cc5b624a5edc61c91c78eb34dc557)
check_type(argname="argument secret_data", value=secret_data, expected_type=type_hints["secret_data"])
check_type(argname="argument secret_name", value=secret_name, expected_type=type_hints["secret_name"])
check_type(argname="argument version_id", value=version_id, expected_type=type_hints["version_id"])
check_type(argname="argument description", value=description, expected_type=type_hints["description"])
check_type(argname="argument dkms_instance_id", value=dkms_instance_id, expected_type=type_hints["dkms_instance_id"])
check_type(argname="argument enable_automatic_rotation", value=enable_automatic_rotation, expected_type=type_hints["enable_automatic_rotation"])
check_type(argname="argument encryption_key_id", value=encryption_key_id, expected_type=type_hints["encryption_key_id"])
check_type(argname="argument extended_config", value=extended_config, expected_type=type_hints["extended_config"])
check_type(argname="argument force_delete_without_recovery", value=force_delete_without_recovery, expected_type=type_hints["force_delete_without_recovery"])
check_type(argname="argument recovery_window_in_days", value=recovery_window_in_days, expected_type=type_hints["recovery_window_in_days"])
check_type(argname="argument rotation_interval", value=rotation_interval, expected_type=type_hints["rotation_interval"])
check_type(argname="argument secret_data_type", value=secret_data_type, expected_type=type_hints["secret_data_type"])
check_type(argname="argument secret_type", value=secret_type, expected_type=type_hints["secret_type"])
check_type(argname="argument version_stages", value=version_stages, expected_type=type_hints["version_stages"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"secret_data": secret_data,
"secret_name": secret_name,
"version_id": version_id,
}
if description is not None:
self._values["description"] = description
if dkms_instance_id is not None:
self._values["dkms_instance_id"] = dkms_instance_id
if enable_automatic_rotation is not None:
self._values["enable_automatic_rotation"] = enable_automatic_rotation
if encryption_key_id is not None:
self._values["encryption_key_id"] = encryption_key_id
if extended_config is not None:
self._values["extended_config"] = extended_config
if force_delete_without_recovery is not None:
self._values["force_delete_without_recovery"] = force_delete_without_recovery
if recovery_window_in_days is not None:
self._values["recovery_window_in_days"] = recovery_window_in_days
if rotation_interval is not None:
self._values["rotation_interval"] = rotation_interval
if secret_data_type is not None:
self._values["secret_data_type"] = secret_data_type
if secret_type is not None:
self._values["secret_type"] = secret_type
if version_stages is not None:
self._values["version_stages"] = version_stages
@builtins.property
def secret_data(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
secretData: The value of the secret that you want to create. Secrets Manager encrypts the secret
value and stores it in the initial version.
'''
result = self._values.get("secret_data")
assert result is not None, "Required property 'secret_data' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def secret_name(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: secretName: The name of the secret.
'''
result = self._values.get("secret_name")
assert result is not None, "Required property 'secret_name' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def version_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
versionId: The version number of the initial version. Version numbers are unique in each secret
object.
'''
result = self._values.get("version_id")
assert result is not None, "Required property 'version_id' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def description(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: description: The description of the secret.
'''
result = self._values.get("description")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def dkms_instance_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: dkmsInstanceId: The ID of the dedicated KMS instance.
'''
result = self._values.get("dkms_instance_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def enable_automatic_rotation(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
enableAutomaticRotation: Specifies whether to enable automatic rotation. Valid values:
true: specifies to enable automatic rotation.
false: specifies to disable automatic rotation. This is the default value.
'''
result = self._values.get("enable_automatic_rotation")
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def encryption_key_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
encryptionKeyId: The ID of the KMS CMK that is used to encrypt the secret value.
If you do not specify this parameter, Secrets Manager automatically creates an encryption
key to encrypt the secret.
Note The KMS CMK must be a symmetric key.
'''
result = self._values.get("encryption_key_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def extended_config(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]]:
'''
:Property: extendedConfig: The extended configuration of the secret. This parameter specifies the properties of the secret of the specific type.
'''
result = self._values.get("extended_config")
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]], result)
@builtins.property
def force_delete_without_recovery(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
forceDeleteWithoutRecovery: Specifies whether to forcibly delete the secret. If this parameter is set to true, the secret cannot be recovered. Valid values:
true
false (default value)
'''
result = self._values.get("force_delete_without_recovery")
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def recovery_window_in_days(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: recoveryWindowInDays: Specifies the recovery period of the secret if you do not forcibly delete it. Default value: 30
'''
result = self._values.get("recovery_window_in_days")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def rotation_interval(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
rotationInterval: The interval for automatic rotation. Valid values: 6 hours to 8,760 hours (365 days).
The value is in the integer[unit] format.
The unit can be d (day), h (hour), m (minute), or s (second). For example, both 7d and 604800s indicate a seven-day interval.
'''
result = self._values.get("rotation_interval")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def secret_data_type(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
secretDataType: The type of the secret value. Valid values:
text (default value)
binary
'''
result = self._values.get("secret_data_type")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def secret_type(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
secretType: The type of the secret. Valid values:
Generic: specifies a generic secret.
Rds: specifies a managed ApsaraDB RDS secret.
RAMCredentials: specifies a managed RAM secret.
ECS: specifies a managed ECS secret.
'''
result = self._values.get("secret_type")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def version_stages(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]]:
'''
:Property: versionStages: The stage labels that mark the secret version. ACSCurrent will be marked as DefaultIf you do not specify it, Secrets Manager marks it with "ACSCurrent".
'''
result = self._values.get("version_stages")
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "RosSecretProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class Secret(
_ros_cdk_core_7adfd82f.Resource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-kms.Secret",
):
'''A ROS resource type: ``ALIYUN::KMS::Secret``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["SecretProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
'''Create a new ``ALIYUN::KMS::Secret``.
Param scope - scope in which this resource is defined
Param id - scoped id of the resource
Param props - resource properties
:param scope: -
:param id: -
:param props: -
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__c01a9d2663b330d122a181ceae20fbf4a11ccbd73df0bbe5fa56d30a214b1c2a)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@builtins.property
@jsii.member(jsii_name="attrArn")
def attr_arn(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute Arn: The Alibaba Cloud Resource Name (ARN).'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrArn"))
@builtins.property
@jsii.member(jsii_name="attrSecretName")
def attr_secret_name(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute SecretName: The name of the secret.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrSecretName"))
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-kms.SecretProps",
jsii_struct_bases=[],
name_mapping={
"secret_data": "secretData",
"secret_name": "secretName",
"version_id": "versionId",
"description": "description",
"dkms_instance_id": "dkmsInstanceId",
"enable_automatic_rotation": "enableAutomaticRotation",
"encryption_key_id": "encryptionKeyId",
"extended_config": "extendedConfig",
"force_delete_without_recovery": "forceDeleteWithoutRecovery",
"recovery_window_in_days": "recoveryWindowInDays",
"rotation_interval": "rotationInterval",
"secret_data_type": "secretDataType",
"secret_type": "secretType",
"version_stages": "versionStages",
},
)
class SecretProps:
def __init__(
self,
*,
secret_data: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
secret_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
version_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
description: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
dkms_instance_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
enable_automatic_rotation: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
encryption_key_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
extended_config: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]] = None,
force_delete_without_recovery: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
recovery_window_in_days: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
rotation_interval: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
secret_data_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
secret_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
version_stages: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::KMS::Secret``.
:param secret_data: Property secretData: The value of the secret that you want to create. Secrets Manager encrypts the secret value and stores it in the initial version.
:param secret_name: Property secretName: The name of the secret.
:param version_id: Property versionId: The version number of the initial version. Version numbers are unique in each secret object.
:param description: Property description: The description of the secret.
:param dkms_instance_id: Property dkmsInstanceId: The ID of the dedicated KMS instance.
:param enable_automatic_rotation: Property enableAutomaticRotation: Specifies whether to enable automatic rotation. Valid values: true: specifies to enable automatic rotation. false: specifies to disable automatic rotation. This is the default value.
:param encryption_key_id: Property encryptionKeyId: The ID of the KMS CMK that is used to encrypt the secret value. If you do not specify this parameter, Secrets Manager automatically creates an encryption key to encrypt the secret. Note The KMS CMK must be a symmetric key.
:param extended_config: Property extendedConfig: The extended configuration of the secret. This parameter specifies the properties of the secret of the specific type.
:param force_delete_without_recovery: Property forceDeleteWithoutRecovery: Specifies whether to forcibly delete the secret. If this parameter is set to true, the secret cannot be recovered. Valid values: true false (default value)
:param recovery_window_in_days: Property recoveryWindowInDays: Specifies the recovery period of the secret if you do not forcibly delete it. Default value: 30
:param rotation_interval: Property rotationInterval: The interval for automatic rotation. Valid values: 6 hours to 8,760 hours (365 days). The value is in the integer[unit] format. The unit can be d (day), h (hour), m (minute), or s (second). For example, both 7d and 604800s indicate a seven-day interval.
:param secret_data_type: Property secretDataType: The type of the secret value. Valid values: text (default value) binary
:param secret_type: Property secretType: The type of the secret. Valid values: Generic: specifies a generic secret. Rds: specifies a managed ApsaraDB RDS secret. RAMCredentials: specifies a managed RAM secret. ECS: specifies a managed ECS secret.
:param version_stages: Property versionStages: The stage labels that mark the secret version. ACSCurrent will be marked as DefaultIf you do not specify it, Secrets Manager marks it with "ACSCurrent".
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__9760dfd361f32811b8303ce1e3434e76c146ed527c99e26d52593df25360ed54)
check_type(argname="argument secret_data", value=secret_data, expected_type=type_hints["secret_data"])
check_type(argname="argument secret_name", value=secret_name, expected_type=type_hints["secret_name"])
check_type(argname="argument version_id", value=version_id, expected_type=type_hints["version_id"])
check_type(argname="argument description", value=description, expected_type=type_hints["description"])
check_type(argname="argument dkms_instance_id", value=dkms_instance_id, expected_type=type_hints["dkms_instance_id"])
check_type(argname="argument enable_automatic_rotation", value=enable_automatic_rotation, expected_type=type_hints["enable_automatic_rotation"])
check_type(argname="argument encryption_key_id", value=encryption_key_id, expected_type=type_hints["encryption_key_id"])
check_type(argname="argument extended_config", value=extended_config, expected_type=type_hints["extended_config"])
check_type(argname="argument force_delete_without_recovery", value=force_delete_without_recovery, expected_type=type_hints["force_delete_without_recovery"])
check_type(argname="argument recovery_window_in_days", value=recovery_window_in_days, expected_type=type_hints["recovery_window_in_days"])
check_type(argname="argument rotation_interval", value=rotation_interval, expected_type=type_hints["rotation_interval"])
check_type(argname="argument secret_data_type", value=secret_data_type, expected_type=type_hints["secret_data_type"])
check_type(argname="argument secret_type", value=secret_type, expected_type=type_hints["secret_type"])
check_type(argname="argument version_stages", value=version_stages, expected_type=type_hints["version_stages"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"secret_data": secret_data,
"secret_name": secret_name,
"version_id": version_id,
}
if description is not None:
self._values["description"] = description
if dkms_instance_id is not None:
self._values["dkms_instance_id"] = dkms_instance_id
if enable_automatic_rotation is not None:
self._values["enable_automatic_rotation"] = enable_automatic_rotation
if encryption_key_id is not None:
self._values["encryption_key_id"] = encryption_key_id
if extended_config is not None:
self._values["extended_config"] = extended_config
if force_delete_without_recovery is not None:
self._values["force_delete_without_recovery"] = force_delete_without_recovery
if recovery_window_in_days is not None:
self._values["recovery_window_in_days"] = recovery_window_in_days
if rotation_interval is not None:
self._values["rotation_interval"] = rotation_interval
if secret_data_type is not None:
self._values["secret_data_type"] = secret_data_type
if secret_type is not None:
self._values["secret_type"] = secret_type
if version_stages is not None:
self._values["version_stages"] = version_stages
@builtins.property
def secret_data(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property secretData: The value of the secret that you want to create.
Secrets Manager encrypts the secret
value and stores it in the initial version.
'''
result = self._values.get("secret_data")
assert result is not None, "Required property 'secret_data' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def secret_name(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property secretName: The name of the secret.'''
result = self._values.get("secret_name")
assert result is not None, "Required property 'secret_name' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def version_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property versionId: The version number of the initial version.
Version numbers are unique in each secret
object.
'''
result = self._values.get("version_id")
assert result is not None, "Required property 'version_id' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def description(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property description: The description of the secret.'''
result = self._values.get("description")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def dkms_instance_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property dkmsInstanceId: The ID of the dedicated KMS instance.'''
result = self._values.get("dkms_instance_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def enable_automatic_rotation(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property enableAutomaticRotation: Specifies whether to enable automatic rotation.
Valid values:
true: specifies to enable automatic rotation.
false: specifies to disable automatic rotation. This is the default value.
'''
result = self._values.get("enable_automatic_rotation")
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def encryption_key_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property encryptionKeyId: The ID of the KMS CMK that is used to encrypt the secret value.
If you do not specify this parameter, Secrets Manager automatically creates an encryption
key to encrypt the secret.
Note The KMS CMK must be a symmetric key.
'''
result = self._values.get("encryption_key_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def extended_config(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]]:
'''Property extendedConfig: The extended configuration of the secret.
This parameter specifies the properties of the secret of the specific type.
'''
result = self._values.get("extended_config")
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]], result)
@builtins.property
def force_delete_without_recovery(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property forceDeleteWithoutRecovery: Specifies whether to forcibly delete the secret.
If this parameter is set to true, the secret cannot be recovered. Valid values:
true
false (default value)
'''
result = self._values.get("force_delete_without_recovery")
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def recovery_window_in_days(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property recoveryWindowInDays: Specifies the recovery period of the secret if you do not forcibly delete it.
Default value: 30
'''
result = self._values.get("recovery_window_in_days")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def rotation_interval(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property rotationInterval: The interval for automatic rotation.
Valid values: 6 hours to 8,760 hours (365 days).
The value is in the integer[unit] format.
The unit can be d (day), h (hour), m (minute), or s (second). For example, both 7d and 604800s indicate a seven-day interval.
'''
result = self._values.get("rotation_interval")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def secret_data_type(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property secretDataType: The type of the secret value.
Valid values:
text (default value)
binary
'''
result = self._values.get("secret_data_type")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def secret_type(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property secretType: The type of the secret.
Valid values:
Generic: specifies a generic secret.
Rds: specifies a managed ApsaraDB RDS secret.
RAMCredentials: specifies a managed RAM secret.
ECS: specifies a managed ECS secret.
'''
result = self._values.get("secret_type")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def version_stages(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]]:
'''Property versionStages: The stage labels that mark the secret version.
ACSCurrent will be marked as DefaultIf you do not specify it, Secrets Manager marks it with "ACSCurrent".
'''
result = self._values.get("version_stages")
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "SecretProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
__all__ = [
"Alias",
"AliasProps",
"Key",
"KeyProps",
"RosAlias",
"RosAliasProps",
"RosKey",
"RosKeyProps",
"RosSecret",
"RosSecretProps",
"Secret",
"SecretProps",
"datasource",
]
publication.publish()
# Loading modules to ensure their types are registered with the jsii runtime library
from . import datasource
def _typecheckingstub__2d84b55de613bdcf76b748f0287cf92a7777fa6cdc025c0be9895ed15affd346(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[AliasProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__f889d0cb8aa4e3402d3225e419e6628ef6c5aa948f4b5a44d8d29108e001e232(
*,
alias_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
key_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__43ec175dd3033fca91582b45c33da55f637eff186c676a14e5bad3cac7b6816a(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Optional[typing.Union[KeyProps, typing.Dict[builtins.str, typing.Any]]] = None,
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__46d9a9efb2e8afe83cf572cd8a027ba567e0f1734b5dbbb6d462d22b88711c5d(
*,
description: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
dkms_instance_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
enable: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
enable_automatic_rotation: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
key_spec: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
key_usage: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
pending_window_in_days: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
protection_level: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
rotation_interval: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__58ae2b2ab6cdf6c54fb0e37c0774cc63f395eea609ba3da41129828a48b7257a(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[RosAliasProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__c7eaa5bae0816bcf2b2723748af01a54e03f60a6c8f1916eb920e7cdef77e32c(
props: typing.Mapping[builtins.str, typing.Any],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__b20ffbbca84f490bd06e47e714c9ac73149297bbc454a3cdf8640bdd70e28b3d(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__4a0aff505d1fcb79e4b680b1d68789117f0752cf950a7731989a040a15f61e17(
value: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__4c2bd31c15e61742d8e2c02643b0d230d57130ca216980a06ac13ba2943e59b4(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__883b1f45a3bc36d63bcb4dc59937e8d0a3fee32b273870433b7176fb904e0412(
*,
alias_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
key_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__28dd1fc1704c23bfb17c18b3e03ed5157b821276907a684ed5d60829c191ac7c(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[RosKeyProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__7e61cb3c251854069fcbf77c5bc7e6963a0bde8c8012b35b79d78af2d0463d5d(
props: typing.Mapping[builtins.str, typing.Any],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__d31e59b3ed53a78c9421ce07e15473c2a79d40ac0591fe737294b14ee292df3c(
value: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__36a182a13fa1f0d5bc5717ba6ff7c4cc51041ba7fe11f79e657c273893458bb7(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__cc1281479c4004281d8d23b0d8c2863ea5ed1e5d154c236c08d90e65a5fef543(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__42022b89ff4eab02d371f5a96e8d40b52ebb0c7a3fe88d160638dc2796e36a1e(
value: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__766425b4ed72a9f7392891d89bc3e16ef9e03f0c1758870514f89e7924b4fc00(
value: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__628647a3b81c9e938cb382743e20554a9428650359f767cd1afb401f7dada288(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__b0130ffa22ecece206cd498917b5890c195261c7e45e4532b62759fb742d6709(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__781c18250da0a30c26157cb65f9af850defd7205556d3956e12ef75ae9a2d876(
value: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__37a33bda5bd597749acb91ea5b89bce164a6fc7c82fe12772030635be5d63de0(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__623040d58497cb35ae08e3ebab8b107624675590e71b906b3b817202c4019bde(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__bca81428725d92140b30bca0cde5fe7eff1fb7a179a783874638e54d197a2513(
*,
description: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
dkms_instance_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
enable: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
enable_automatic_rotation: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
key_spec: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
key_usage: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
pending_window_in_days: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
protection_level: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
rotation_interval: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__8b5741850c81a916c5989f99983673f36656796a788dd2452c0129890cca34b6(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[RosSecretProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__82342dcb733ac8f12ae557eec20e74bf96fab9bfe0ada4d96a171f07304ddfda(
props: typing.Mapping[builtins.str, typing.Any],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__5001f4e03d1fbf3010ba019dc79dafc2d7e67a944779bff473be408d339e3709(
value: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__1e592678bac7b2e44a8e1faa56adc582b883e5cc627359bc3a572c7dd9077acb(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__44f64c594383423fa8217bbe455c42334979fe7599a1e2be155e8433c24302d4(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__368499400378014795e926d0c21628cc96fcfe68a2f12d6d1cc85083c2eab863(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__bd81ed7e4da6707b77c2a6c44590e77038568c23bb5fc64f0687e73e9b4a360c(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__a443461ffa3d2965967b9e3f4fd1727f94df2f368653f0c40b266b24dc68fcc4(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__1e28b945206719717bd068a5ab46a0a94f8b57c88367dbeba9ded4912c417daa(
value: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__b5e805cbeabc12ed1f3fe2064cc47697c5f3a7f1ef3f97bd32051682d1f7b12f(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__665295dced0f788c88dee7b072597085400890af7b839e9b4d4f1ad43ef0760d(
value: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__795033bd5b14a25538ec652e70d4d75f08d62415172a80681e45b9e3132a99ae(
value: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__4741b8cfd5f57336e3648d331400d3faf7ac4a7a6ade01b7636919b8bfd534ff(
value: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__70e2c3e453870e9d9a91da230df7cdfc886d1bb569d5115856119a4ef13a07bc(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__6e5778fa12bdf5b2866701d0276fb95491b924155e2d5b609c7b78028d356f66(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__c583c4ecf1182cb5d94cbaf0233b3f9220393d289e2bbd0597f596bf44d5f129(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__e061489cfbc1b62d514a9dd61320690c12dc1867e894c55fa050f95752ffcb7d(
value: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__40c88ab19e625b93cc2d4808001c6ce0b82cc5b624a5edc61c91c78eb34dc557(
*,
secret_data: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
secret_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
version_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
description: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
dkms_instance_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
enable_automatic_rotation: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
encryption_key_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
extended_config: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]] = None,
force_delete_without_recovery: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
recovery_window_in_days: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
rotation_interval: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
secret_data_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
secret_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
version_stages: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__c01a9d2663b330d122a181ceae20fbf4a11ccbd73df0bbe5fa56d30a214b1c2a(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[SecretProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__9760dfd361f32811b8303ce1e3434e76c146ed527c99e26d52593df25360ed54(
*,
secret_data: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
secret_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
version_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
description: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
dkms_instance_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
enable_automatic_rotation: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
encryption_key_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
extended_config: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]] = None,
force_delete_without_recovery: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
recovery_window_in_days: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
rotation_interval: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
secret_data_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
secret_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
version_stages: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]] = None,
) -> None:
"""Type checking stubs"""
pass | /ros-cdk-kms-1.0.17.tar.gz/ros-cdk-kms-1.0.17/src/ros_cdk_kms/__init__.py | 0.722625 | 0.166235 | __init__.py | pypi |
import abc
import builtins
import datetime
import enum
import typing
import jsii
import publication
import typing_extensions
from typeguard import check_type
from ._jsii import *
import ros_cdk_core as _ros_cdk_core_7adfd82f
class Order(
_ros_cdk_core_7adfd82f.Resource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-marketplace.Order",
):
'''A ROS resource type: ``ALIYUN::MarketPlace::Order``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["OrderProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
'''Create a new ``ALIYUN::MarketPlace::Order``.
Param scope - scope in which this resource is defined
Param id - scoped id of the resource
Param props - resource properties
:param scope: -
:param id: -
:param props: -
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__d4a26317660d73579904a69f5918eafa30efbe6182479710ce5a14ad48b8b67a)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@builtins.property
@jsii.member(jsii_name="attrOrderId")
def attr_order_id(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute OrderId: Order ID of created instance.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrOrderId"))
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-marketplace.OrderProps",
jsii_struct_bases=[],
name_mapping={
"product_code": "productCode",
"sku_code": "skuCode",
"charge_type": "chargeType",
"duration": "duration",
"preference": "preference",
"pricing_cycle": "pricingCycle",
"quantity": "quantity",
},
)
class OrderProps:
def __init__(
self,
*,
product_code: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
sku_code: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
charge_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
duration: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
preference: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]] = None,
pricing_cycle: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
quantity: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::MarketPlace::Order``.
:param product_code: Property productCode: Product code for the resource.
:param sku_code: Property skuCode: Sku code for the resource.
:param charge_type: Property chargeType: The resource charge type. Default value is Prepaid
:param duration: Property duration: Duration of the resource. If ChargeType is specified as Postpaid, this value will be ignore.
:param preference: Property preference: Customized parameters.
:param pricing_cycle: Property pricingCycle: Price cycle of the resource. This property has no default value. If ChargeType is specified as Postpaid, this value will be ignore.
:param quantity: Property quantity: Resource number. Default value is 1
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__cd72d890b6d7c59831aa39cd8836d629b90743e65d5da45678f077a778d09a07)
check_type(argname="argument product_code", value=product_code, expected_type=type_hints["product_code"])
check_type(argname="argument sku_code", value=sku_code, expected_type=type_hints["sku_code"])
check_type(argname="argument charge_type", value=charge_type, expected_type=type_hints["charge_type"])
check_type(argname="argument duration", value=duration, expected_type=type_hints["duration"])
check_type(argname="argument preference", value=preference, expected_type=type_hints["preference"])
check_type(argname="argument pricing_cycle", value=pricing_cycle, expected_type=type_hints["pricing_cycle"])
check_type(argname="argument quantity", value=quantity, expected_type=type_hints["quantity"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"product_code": product_code,
"sku_code": sku_code,
}
if charge_type is not None:
self._values["charge_type"] = charge_type
if duration is not None:
self._values["duration"] = duration
if preference is not None:
self._values["preference"] = preference
if pricing_cycle is not None:
self._values["pricing_cycle"] = pricing_cycle
if quantity is not None:
self._values["quantity"] = quantity
@builtins.property
def product_code(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property productCode: Product code for the resource.'''
result = self._values.get("product_code")
assert result is not None, "Required property 'product_code' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def sku_code(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property skuCode: Sku code for the resource.'''
result = self._values.get("sku_code")
assert result is not None, "Required property 'sku_code' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def charge_type(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property chargeType: The resource charge type.
Default value is Prepaid
'''
result = self._values.get("charge_type")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def duration(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property duration: Duration of the resource.
If ChargeType is specified as Postpaid, this value will be ignore.
'''
result = self._values.get("duration")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def preference(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]]:
'''Property preference: Customized parameters.'''
result = self._values.get("preference")
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]], result)
@builtins.property
def pricing_cycle(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property pricingCycle: Price cycle of the resource.
This property has no default value. If ChargeType is specified as Postpaid, this value will be ignore.
'''
result = self._values.get("pricing_cycle")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def quantity(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property quantity: Resource number.
Default value is 1
'''
result = self._values.get("quantity")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "OrderProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class RosOrder(
_ros_cdk_core_7adfd82f.RosResource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-marketplace.RosOrder",
):
'''A ROS template type: ``ALIYUN::MarketPlace::Order``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["RosOrderProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
'''Create a new ``ALIYUN::MarketPlace::Order``.
:param scope: - scope in which this resource is defined.
:param id: - scoped id of the resource.
:param props: - resource properties.
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__6ceb558ee632565eec13e026cb5b254b2145a3a52f846cf646eac0517e93f251)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@jsii.member(jsii_name="renderProperties")
def _render_properties(
self,
props: typing.Mapping[builtins.str, typing.Any],
) -> typing.Mapping[builtins.str, typing.Any]:
'''
:param props: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__8653f3d3d8439cdeeb3bc504ad73ed7fcdc5a910289bb2c588f319dcd44e0d06)
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))
@jsii.python.classproperty
@jsii.member(jsii_name="ROS_RESOURCE_TYPE_NAME")
def ROS_RESOURCE_TYPE_NAME(cls) -> builtins.str:
'''The resource type name for this resource class.'''
return typing.cast(builtins.str, jsii.sget(cls, "ROS_RESOURCE_TYPE_NAME"))
@builtins.property
@jsii.member(jsii_name="attrOrderId")
def attr_order_id(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: OrderId: Order ID of created instance.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrOrderId"))
@builtins.property
@jsii.member(jsii_name="rosProperties")
def _ros_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "rosProperties"))
@builtins.property
@jsii.member(jsii_name="enableResourcePropertyConstraint")
def enable_resource_property_constraint(self) -> builtins.bool:
return typing.cast(builtins.bool, jsii.get(self, "enableResourcePropertyConstraint"))
@enable_resource_property_constraint.setter
def enable_resource_property_constraint(self, value: builtins.bool) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__0a16d2e9c453fbba8b0dad8ca071f3cd2532462da19dde90e1d58b816a250ed4)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "enableResourcePropertyConstraint", value)
@builtins.property
@jsii.member(jsii_name="productCode")
def product_code(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: productCode: Product code for the resource.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "productCode"))
@product_code.setter
def product_code(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__473fc6c795588382c162ed3e49ffe480e3b8ae8d42f54c0722e908766eab91a4)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "productCode", value)
@builtins.property
@jsii.member(jsii_name="skuCode")
def sku_code(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: skuCode: Sku code for the resource.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "skuCode"))
@sku_code.setter
def sku_code(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__203a98d8874ae39e2da33d8330607c449681e7ea00e7cac6d2805220ea9079d9)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "skuCode", value)
@builtins.property
@jsii.member(jsii_name="chargeType")
def charge_type(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: chargeType: The resource charge type. Default value is Prepaid
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "chargeType"))
@charge_type.setter
def charge_type(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__92fa5b50170a485f29e8eabf9378e8908a785a789e52e9cf30ba5f47a5fec3ee)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "chargeType", value)
@builtins.property
@jsii.member(jsii_name="duration")
def duration(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: duration: Duration of the resource. If ChargeType is specified as Postpaid, this value will be ignore.
'''
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "duration"))
@duration.setter
def duration(
self,
value: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__75740f7171f54e44c5069ce7c8e7d7ce0f852a56fca3b5f417cb301670ede18c)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "duration", value)
@builtins.property
@jsii.member(jsii_name="preference")
def preference(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]]:
'''
:Property: preference: Customized parameters.
'''
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]], jsii.get(self, "preference"))
@preference.setter
def preference(
self,
value: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__f82992ad6d179ec33c0403ae94764dd8526233ee74dc7211433256c5ce41ed0e)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "preference", value)
@builtins.property
@jsii.member(jsii_name="pricingCycle")
def pricing_cycle(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: pricingCycle: Price cycle of the resource. This property has no default value. If ChargeType is specified as Postpaid, this value will be ignore.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "pricingCycle"))
@pricing_cycle.setter
def pricing_cycle(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__9d149389ce4f7774dd280c706df425ffb3d1b3d02473cf582ca8323fb3fe2d7f)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "pricingCycle", value)
@builtins.property
@jsii.member(jsii_name="quantity")
def quantity(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: quantity: Resource number. Default value is 1
'''
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "quantity"))
@quantity.setter
def quantity(
self,
value: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__f6ba61aea8ad3752866b787c055d26711814231a395874475a54b9548aea2c21)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "quantity", value)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-marketplace.RosOrderProps",
jsii_struct_bases=[],
name_mapping={
"product_code": "productCode",
"sku_code": "skuCode",
"charge_type": "chargeType",
"duration": "duration",
"preference": "preference",
"pricing_cycle": "pricingCycle",
"quantity": "quantity",
},
)
class RosOrderProps:
def __init__(
self,
*,
product_code: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
sku_code: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
charge_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
duration: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
preference: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]] = None,
pricing_cycle: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
quantity: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::MarketPlace::Order``.
:param product_code:
:param sku_code:
:param charge_type:
:param duration:
:param preference:
:param pricing_cycle:
:param quantity:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__c171336b03b09259ffd375980c1616178db0f762ee6e6819247011dd6ea37461)
check_type(argname="argument product_code", value=product_code, expected_type=type_hints["product_code"])
check_type(argname="argument sku_code", value=sku_code, expected_type=type_hints["sku_code"])
check_type(argname="argument charge_type", value=charge_type, expected_type=type_hints["charge_type"])
check_type(argname="argument duration", value=duration, expected_type=type_hints["duration"])
check_type(argname="argument preference", value=preference, expected_type=type_hints["preference"])
check_type(argname="argument pricing_cycle", value=pricing_cycle, expected_type=type_hints["pricing_cycle"])
check_type(argname="argument quantity", value=quantity, expected_type=type_hints["quantity"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"product_code": product_code,
"sku_code": sku_code,
}
if charge_type is not None:
self._values["charge_type"] = charge_type
if duration is not None:
self._values["duration"] = duration
if preference is not None:
self._values["preference"] = preference
if pricing_cycle is not None:
self._values["pricing_cycle"] = pricing_cycle
if quantity is not None:
self._values["quantity"] = quantity
@builtins.property
def product_code(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: productCode: Product code for the resource.
'''
result = self._values.get("product_code")
assert result is not None, "Required property 'product_code' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def sku_code(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: skuCode: Sku code for the resource.
'''
result = self._values.get("sku_code")
assert result is not None, "Required property 'sku_code' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def charge_type(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: chargeType: The resource charge type. Default value is Prepaid
'''
result = self._values.get("charge_type")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def duration(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: duration: Duration of the resource. If ChargeType is specified as Postpaid, this value will be ignore.
'''
result = self._values.get("duration")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def preference(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]]:
'''
:Property: preference: Customized parameters.
'''
result = self._values.get("preference")
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]], result)
@builtins.property
def pricing_cycle(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: pricingCycle: Price cycle of the resource. This property has no default value. If ChargeType is specified as Postpaid, this value will be ignore.
'''
result = self._values.get("pricing_cycle")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def quantity(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: quantity: Resource number. Default value is 1
'''
result = self._values.get("quantity")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "RosOrderProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
__all__ = [
"Order",
"OrderProps",
"RosOrder",
"RosOrderProps",
]
publication.publish()
def _typecheckingstub__d4a26317660d73579904a69f5918eafa30efbe6182479710ce5a14ad48b8b67a(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[OrderProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__cd72d890b6d7c59831aa39cd8836d629b90743e65d5da45678f077a778d09a07(
*,
product_code: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
sku_code: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
charge_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
duration: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
preference: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]] = None,
pricing_cycle: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
quantity: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__6ceb558ee632565eec13e026cb5b254b2145a3a52f846cf646eac0517e93f251(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[RosOrderProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__8653f3d3d8439cdeeb3bc504ad73ed7fcdc5a910289bb2c588f319dcd44e0d06(
props: typing.Mapping[builtins.str, typing.Any],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__0a16d2e9c453fbba8b0dad8ca071f3cd2532462da19dde90e1d58b816a250ed4(
value: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__473fc6c795588382c162ed3e49ffe480e3b8ae8d42f54c0722e908766eab91a4(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__203a98d8874ae39e2da33d8330607c449681e7ea00e7cac6d2805220ea9079d9(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__92fa5b50170a485f29e8eabf9378e8908a785a789e52e9cf30ba5f47a5fec3ee(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__75740f7171f54e44c5069ce7c8e7d7ce0f852a56fca3b5f417cb301670ede18c(
value: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__f82992ad6d179ec33c0403ae94764dd8526233ee74dc7211433256c5ce41ed0e(
value: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__9d149389ce4f7774dd280c706df425ffb3d1b3d02473cf582ca8323fb3fe2d7f(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__f6ba61aea8ad3752866b787c055d26711814231a395874475a54b9548aea2c21(
value: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__c171336b03b09259ffd375980c1616178db0f762ee6e6819247011dd6ea37461(
*,
product_code: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
sku_code: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
charge_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
duration: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
preference: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]] = None,
pricing_cycle: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
quantity: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass | /ros-cdk-marketplace-1.0.17.tar.gz/ros-cdk-marketplace-1.0.17/src/ros_cdk_marketplace/__init__.py | 0.655446 | 0.169784 | __init__.py | pypi |
import abc
import builtins
import datetime
import enum
import typing
import jsii
import publication
import typing_extensions
from typeguard import check_type
from ._jsii import *
import ros_cdk_core as _ros_cdk_core_7adfd82f
class Pipeline(
_ros_cdk_core_7adfd82f.Resource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-mps.Pipeline",
):
'''A ROS resource type: ``ALIYUN::MPS::Pipeline``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["PipelineProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
'''Create a new ``ALIYUN::MPS::Pipeline``.
Param scope - scope in which this resource is defined
Param id - scoped id of the resource
Param props - resource properties
:param scope: -
:param id: -
:param props: -
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__c34fa85b3e09b08bbb46d54b5f1ff43f9356eb7ef98c96b5059c6a64e522f2c2)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@builtins.property
@jsii.member(jsii_name="attrPipelineId")
def attr_pipeline_id(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute PipelineId: The ID of the MPS queue.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrPipelineId"))
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-mps.PipelineProps",
jsii_struct_bases=[],
name_mapping={
"name": "name",
"notify_config": "notifyConfig",
"role": "role",
"speed": "speed",
"speed_level": "speedLevel",
"state": "state",
},
)
class PipelineProps:
def __init__(
self,
*,
name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
notify_config: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union["RosPipeline.NotifyConfigProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
role: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
speed: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
speed_level: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
state: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::MPS::Pipeline``.
:param name: Property name: The new name of the MPS queue. The value can contain letters, digits, and special characters such as hyphens (-) and can be up to 128 bytes in size. The value cannot start with a special character.
:param notify_config: Property notifyConfig: The Message Service (MNS) configuration, such as the information about the MNS queue or topic. For more information, see NotifyConfig.
:param role: Property role: The role that is assigned to the current RAM user. To obtain the role, you can log on to the RAM console and choose Identities > Roles in the left-side navigation pane.
:param speed: Property speed: Pipe type. Value: Boost: Double-speed transcoding Standard: ordinary pipe NarrowBandHDV2: Narrowband HD 2.0 AIVideoCover: Smart Screenshots AIVideoTag: video tag (supports regions Shanghai, Beijing, Hangzhou). Default: Standard.
:param speed_level: Property speedLevel: Speed level.
:param state: Property state: The new state of the MPS queue. Active: The MPS queue is active. Jobs in the MPS queue can be scheduled and run by MPS. Paused: The MPS queue is paused. Jobs in the MPS queue cannot be scheduled or run by MPS, and all jobs remain in the Submitted state. Jobs that are running will not be affected.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__ba9ffc6b88ce88179af71c7f3f1d5eb164f95d57d47581e3f71ee56e43c75b19)
check_type(argname="argument name", value=name, expected_type=type_hints["name"])
check_type(argname="argument notify_config", value=notify_config, expected_type=type_hints["notify_config"])
check_type(argname="argument role", value=role, expected_type=type_hints["role"])
check_type(argname="argument speed", value=speed, expected_type=type_hints["speed"])
check_type(argname="argument speed_level", value=speed_level, expected_type=type_hints["speed_level"])
check_type(argname="argument state", value=state, expected_type=type_hints["state"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"name": name,
}
if notify_config is not None:
self._values["notify_config"] = notify_config
if role is not None:
self._values["role"] = role
if speed is not None:
self._values["speed"] = speed
if speed_level is not None:
self._values["speed_level"] = speed_level
if state is not None:
self._values["state"] = state
@builtins.property
def name(self) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property name: The new name of the MPS queue.
The value can contain letters, digits, and special
characters such as hyphens (-) and can be up to 128 bytes in size. The value cannot
start with a special character.
'''
result = self._values.get("name")
assert result is not None, "Required property 'name' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def notify_config(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosPipeline.NotifyConfigProperty"]]:
'''Property notifyConfig: The Message Service (MNS) configuration, such as the information about the MNS queue or topic.
For more information, see NotifyConfig.
'''
result = self._values.get("notify_config")
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosPipeline.NotifyConfigProperty"]], result)
@builtins.property
def role(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property role: The role that is assigned to the current RAM user.
To obtain the role, you can log on to the RAM console and choose Identities > Roles in the left-side navigation pane.
'''
result = self._values.get("role")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def speed(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property speed: Pipe type.
Value:
Boost: Double-speed transcoding
Standard: ordinary pipe
NarrowBandHDV2: Narrowband HD 2.0
AIVideoCover: Smart Screenshots
AIVideoTag: video tag (supports regions Shanghai, Beijing, Hangzhou).
Default: Standard.
'''
result = self._values.get("speed")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def speed_level(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property speedLevel: Speed level.'''
result = self._values.get("speed_level")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def state(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property state: The new state of the MPS queue.
Active: The MPS queue is active. Jobs in the MPS queue can be scheduled and run by MPS.
Paused: The MPS queue is paused. Jobs in the MPS queue cannot be scheduled or run by MPS, and all jobs remain in the Submitted state. Jobs that are running will not be affected.
'''
result = self._values.get("state")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "PipelineProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class RosPipeline(
_ros_cdk_core_7adfd82f.RosResource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-mps.RosPipeline",
):
'''A ROS template type: ``ALIYUN::MPS::Pipeline``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["RosPipelineProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
'''Create a new ``ALIYUN::MPS::Pipeline``.
:param scope: - scope in which this resource is defined.
:param id: - scoped id of the resource.
:param props: - resource properties.
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__495d8b51dd1e6c508994271ce3137e365e077767dd14e1fb2cf34ab707e320a3)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@jsii.member(jsii_name="renderProperties")
def _render_properties(
self,
props: typing.Mapping[builtins.str, typing.Any],
) -> typing.Mapping[builtins.str, typing.Any]:
'''
:param props: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__de1beef9d117cfc42c06de99777a78393be3beda523c14417b9f2fa5fa480d9c)
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))
@jsii.python.classproperty
@jsii.member(jsii_name="ROS_RESOURCE_TYPE_NAME")
def ROS_RESOURCE_TYPE_NAME(cls) -> builtins.str:
'''The resource type name for this resource class.'''
return typing.cast(builtins.str, jsii.sget(cls, "ROS_RESOURCE_TYPE_NAME"))
@builtins.property
@jsii.member(jsii_name="attrPipelineId")
def attr_pipeline_id(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: PipelineId: The ID of the MPS queue.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrPipelineId"))
@builtins.property
@jsii.member(jsii_name="rosProperties")
def _ros_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "rosProperties"))
@builtins.property
@jsii.member(jsii_name="enableResourcePropertyConstraint")
def enable_resource_property_constraint(self) -> builtins.bool:
return typing.cast(builtins.bool, jsii.get(self, "enableResourcePropertyConstraint"))
@enable_resource_property_constraint.setter
def enable_resource_property_constraint(self, value: builtins.bool) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__e007d522ea7e8862f4d49ff225cc6cfccdcf9f0bd60ae52e68b71cc4c8502b86)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "enableResourcePropertyConstraint", value)
@builtins.property
@jsii.member(jsii_name="name")
def name(self) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
name: The new name of the MPS queue. The value can contain letters, digits, and special
characters such as hyphens (-) and can be up to 128 bytes in size. The value cannot
start with a special character.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "name"))
@name.setter
def name(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__679431cd8af4d7adb2c48f003ae60576cabccd2ac16ca01e661dd541bf3eb1c0)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "name", value)
@builtins.property
@jsii.member(jsii_name="notifyConfig")
def notify_config(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosPipeline.NotifyConfigProperty"]]:
'''
:Property:
notifyConfig: The Message Service (MNS) configuration, such as the information about the MNS queue
or topic. For more information, see NotifyConfig.
'''
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosPipeline.NotifyConfigProperty"]], jsii.get(self, "notifyConfig"))
@notify_config.setter
def notify_config(
self,
value: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosPipeline.NotifyConfigProperty"]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__d46b1f5444045316e5ce778a8c088a682e2bf7885c139e8197817ce6371f9f78)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "notifyConfig", value)
@builtins.property
@jsii.member(jsii_name="role")
def role(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: role: The role that is assigned to the current RAM user. To obtain the role, you can log on to the RAM console and choose Identities > Roles in the left-side navigation pane.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "role"))
@role.setter
def role(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__f464cb1eff47ed68e818cd17ee30f28e06bfee77fbab0e64c7c60a443f0bb223)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "role", value)
@builtins.property
@jsii.member(jsii_name="speed")
def speed(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
speed: Pipe type. Value:
Boost: Double-speed transcoding
Standard: ordinary pipe
NarrowBandHDV2: Narrowband HD 2.0
AIVideoCover: Smart Screenshots
AIVideoTag: video tag (supports regions Shanghai, Beijing, Hangzhou).
Default: Standard.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "speed"))
@speed.setter
def speed(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__fae9113464f733e991df85ec0b6084d6db57cbc1d0f0de7f3896b026ce160687)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "speed", value)
@builtins.property
@jsii.member(jsii_name="speedLevel")
def speed_level(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: speedLevel: Speed level.
'''
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "speedLevel"))
@speed_level.setter
def speed_level(
self,
value: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__0da350506beafd3690a3a63a67248f2f5db4882148d21ba166693940ec255bed)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "speedLevel", value)
@builtins.property
@jsii.member(jsii_name="state")
def state(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
state: The new state of the MPS queue.
Active: The MPS queue is active. Jobs in the MPS queue can be scheduled and run by MPS.
Paused: The MPS queue is paused. Jobs in the MPS queue cannot be scheduled or run by MPS, and all jobs remain in the Submitted state. Jobs that are running will not be affected.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "state"))
@state.setter
def state(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__324bee693e3228711d84295cbd59868b6ba0e6b7782ed8173d6ce3092efe6fdd)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "state", value)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-mps.RosPipeline.NotifyConfigProperty",
jsii_struct_bases=[],
name_mapping={"queue_name": "queueName", "topic": "topic"},
)
class NotifyConfigProperty:
def __init__(
self,
*,
queue_name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
topic: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''
:param queue_name:
:param topic:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__49ca89b0528221844489052e15956933aa7a7af997c851fd5088cd2053e37a48)
check_type(argname="argument queue_name", value=queue_name, expected_type=type_hints["queue_name"])
check_type(argname="argument topic", value=topic, expected_type=type_hints["topic"])
self._values: typing.Dict[builtins.str, typing.Any] = {}
if queue_name is not None:
self._values["queue_name"] = queue_name
if topic is not None:
self._values["topic"] = topic
@builtins.property
def queue_name(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: queueName: undefined
'''
result = self._values.get("queue_name")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def topic(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: topic: undefined
'''
result = self._values.get("topic")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "NotifyConfigProperty(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-mps.RosPipelineProps",
jsii_struct_bases=[],
name_mapping={
"name": "name",
"notify_config": "notifyConfig",
"role": "role",
"speed": "speed",
"speed_level": "speedLevel",
"state": "state",
},
)
class RosPipelineProps:
def __init__(
self,
*,
name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
notify_config: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union[RosPipeline.NotifyConfigProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
role: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
speed: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
speed_level: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
state: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::MPS::Pipeline``.
:param name:
:param notify_config:
:param role:
:param speed:
:param speed_level:
:param state:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__732efec3bd0e9ebaac86783200e3665817b4dd72ca5c52f804d2fc0ab6190c3b)
check_type(argname="argument name", value=name, expected_type=type_hints["name"])
check_type(argname="argument notify_config", value=notify_config, expected_type=type_hints["notify_config"])
check_type(argname="argument role", value=role, expected_type=type_hints["role"])
check_type(argname="argument speed", value=speed, expected_type=type_hints["speed"])
check_type(argname="argument speed_level", value=speed_level, expected_type=type_hints["speed_level"])
check_type(argname="argument state", value=state, expected_type=type_hints["state"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"name": name,
}
if notify_config is not None:
self._values["notify_config"] = notify_config
if role is not None:
self._values["role"] = role
if speed is not None:
self._values["speed"] = speed
if speed_level is not None:
self._values["speed_level"] = speed_level
if state is not None:
self._values["state"] = state
@builtins.property
def name(self) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
name: The new name of the MPS queue. The value can contain letters, digits, and special
characters such as hyphens (-) and can be up to 128 bytes in size. The value cannot
start with a special character.
'''
result = self._values.get("name")
assert result is not None, "Required property 'name' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def notify_config(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, RosPipeline.NotifyConfigProperty]]:
'''
:Property:
notifyConfig: The Message Service (MNS) configuration, such as the information about the MNS queue
or topic. For more information, see NotifyConfig.
'''
result = self._values.get("notify_config")
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, RosPipeline.NotifyConfigProperty]], result)
@builtins.property
def role(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: role: The role that is assigned to the current RAM user. To obtain the role, you can log on to the RAM console and choose Identities > Roles in the left-side navigation pane.
'''
result = self._values.get("role")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def speed(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
speed: Pipe type. Value:
Boost: Double-speed transcoding
Standard: ordinary pipe
NarrowBandHDV2: Narrowband HD 2.0
AIVideoCover: Smart Screenshots
AIVideoTag: video tag (supports regions Shanghai, Beijing, Hangzhou).
Default: Standard.
'''
result = self._values.get("speed")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def speed_level(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: speedLevel: Speed level.
'''
result = self._values.get("speed_level")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def state(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
state: The new state of the MPS queue.
Active: The MPS queue is active. Jobs in the MPS queue can be scheduled and run by MPS.
Paused: The MPS queue is paused. Jobs in the MPS queue cannot be scheduled or run by MPS, and all jobs remain in the Submitted state. Jobs that are running will not be affected.
'''
result = self._values.get("state")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "RosPipelineProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
__all__ = [
"Pipeline",
"PipelineProps",
"RosPipeline",
"RosPipelineProps",
]
publication.publish()
def _typecheckingstub__c34fa85b3e09b08bbb46d54b5f1ff43f9356eb7ef98c96b5059c6a64e522f2c2(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[PipelineProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__ba9ffc6b88ce88179af71c7f3f1d5eb164f95d57d47581e3f71ee56e43c75b19(
*,
name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
notify_config: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union[RosPipeline.NotifyConfigProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
role: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
speed: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
speed_level: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
state: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__495d8b51dd1e6c508994271ce3137e365e077767dd14e1fb2cf34ab707e320a3(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[RosPipelineProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__de1beef9d117cfc42c06de99777a78393be3beda523c14417b9f2fa5fa480d9c(
props: typing.Mapping[builtins.str, typing.Any],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__e007d522ea7e8862f4d49ff225cc6cfccdcf9f0bd60ae52e68b71cc4c8502b86(
value: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__679431cd8af4d7adb2c48f003ae60576cabccd2ac16ca01e661dd541bf3eb1c0(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__d46b1f5444045316e5ce778a8c088a682e2bf7885c139e8197817ce6371f9f78(
value: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, RosPipeline.NotifyConfigProperty]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__f464cb1eff47ed68e818cd17ee30f28e06bfee77fbab0e64c7c60a443f0bb223(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__fae9113464f733e991df85ec0b6084d6db57cbc1d0f0de7f3896b026ce160687(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__0da350506beafd3690a3a63a67248f2f5db4882148d21ba166693940ec255bed(
value: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__324bee693e3228711d84295cbd59868b6ba0e6b7782ed8173d6ce3092efe6fdd(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__49ca89b0528221844489052e15956933aa7a7af997c851fd5088cd2053e37a48(
*,
queue_name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
topic: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__732efec3bd0e9ebaac86783200e3665817b4dd72ca5c52f804d2fc0ab6190c3b(
*,
name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
notify_config: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union[RosPipeline.NotifyConfigProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
role: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
speed: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
speed_level: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
state: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass | /ros-cdk-mps-1.0.17.tar.gz/ros-cdk-mps-1.0.17/src/ros_cdk_mps/__init__.py | 0.659515 | 0.174938 | __init__.py | pypi |
import abc
import builtins
import datetime
import enum
import typing
import jsii
import publication
import typing_extensions
from typeguard import check_type
from ._jsii import *
import ros_cdk_core as _ros_cdk_core_7adfd82f
class AccessGroup(
_ros_cdk_core_7adfd82f.Resource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-nas.AccessGroup",
):
'''A ROS resource type: ``ALIYUN::NAS::AccessGroup``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["AccessGroupProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
'''Create a new ``ALIYUN::NAS::AccessGroup``.
Param scope - scope in which this resource is defined
Param id - scoped id of the resource
Param props - resource properties
:param scope: -
:param id: -
:param props: -
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__18f8c298f10dda5f46a5c7a0e038df9f0e230454cb630fd508bd594b6e4da1da)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@builtins.property
@jsii.member(jsii_name="attrAccessGroupName")
def attr_access_group_name(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute AccessGroupName: Permission group name.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrAccessGroupName"))
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-nas.AccessGroupProps",
jsii_struct_bases=[],
name_mapping={
"access_group_name": "accessGroupName",
"access_group_type": "accessGroupType",
"description": "description",
"file_system_type": "fileSystemType",
},
)
class AccessGroupProps:
def __init__(
self,
*,
access_group_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
access_group_type: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
description: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
file_system_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::NAS::AccessGroup``.
:param access_group_name: Property accessGroupName: Permission group name.
:param access_group_type: Property accessGroupType: Permission group type, including the Vpc and Classic types.
:param description: Property description: Permission group description. It is the same as the permission group name by default.
:param file_system_type: Property fileSystemType: File system type. Values: standard (default), extreme
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__39b9a144f1df420efd946b760447cdf23ef6e6c6fa4c30ec6ec54674f046df3f)
check_type(argname="argument access_group_name", value=access_group_name, expected_type=type_hints["access_group_name"])
check_type(argname="argument access_group_type", value=access_group_type, expected_type=type_hints["access_group_type"])
check_type(argname="argument description", value=description, expected_type=type_hints["description"])
check_type(argname="argument file_system_type", value=file_system_type, expected_type=type_hints["file_system_type"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"access_group_name": access_group_name,
"access_group_type": access_group_type,
}
if description is not None:
self._values["description"] = description
if file_system_type is not None:
self._values["file_system_type"] = file_system_type
@builtins.property
def access_group_name(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property accessGroupName: Permission group name.'''
result = self._values.get("access_group_name")
assert result is not None, "Required property 'access_group_name' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def access_group_type(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property accessGroupType: Permission group type, including the Vpc and Classic types.'''
result = self._values.get("access_group_type")
assert result is not None, "Required property 'access_group_type' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def description(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property description: Permission group description.
It is the same as the permission group name by default.
'''
result = self._values.get("description")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def file_system_type(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property fileSystemType: File system type.
Values: standard (default), extreme
'''
result = self._values.get("file_system_type")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "AccessGroupProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class AccessRule(
_ros_cdk_core_7adfd82f.Resource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-nas.AccessRule",
):
'''A ROS resource type: ``ALIYUN::NAS::AccessRule``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["AccessRuleProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
'''Create a new ``ALIYUN::NAS::AccessRule``.
Param scope - scope in which this resource is defined
Param id - scoped id of the resource
Param props - resource properties
:param scope: -
:param id: -
:param props: -
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__e31eaf701123f48de8bfcc3d4279f6fb373a3227869cf26a9a34fcb407aa51f6)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@builtins.property
@jsii.member(jsii_name="attrAccessRuleId")
def attr_access_rule_id(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute AccessRuleId: Rule serial number.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrAccessRuleId"))
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-nas.AccessRuleProps",
jsii_struct_bases=[],
name_mapping={
"access_group_name": "accessGroupName",
"file_system_type": "fileSystemType",
"ipv6_source_cidr_ip": "ipv6SourceCidrIp",
"priority": "priority",
"rw_access_type": "rwAccessType",
"source_cidr_ip": "sourceCidrIp",
"user_access_type": "userAccessType",
},
)
class AccessRuleProps:
def __init__(
self,
*,
access_group_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
file_system_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
ipv6_source_cidr_ip: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
priority: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
rw_access_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
source_cidr_ip: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
user_access_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::NAS::AccessRule``.
:param access_group_name: Property accessGroupName: Permission group name.
:param file_system_type: Property fileSystemType: The type of file system. Values: standard: the general NAS extreme: the extreme NAS
:param ipv6_source_cidr_ip: Property ipv6SourceCidrIp: Source IPv6 CIDR address segment. IP addresses in CIDR format and IPv6 format are supported. Currently, only the ultra-fast NAS in mainland China supports the IPv6 function, and the file system needs to enable the IPv6 function. Only VPC private network is supported. IPv4 and IPv6 are mutually exclusive, and the types cannot be converted.
:param priority: Property priority: Priority level. Range: 1-100. Default value: 1
:param rw_access_type: Property rwAccessType: Read-write permission type: RDWR (default), RDONLY.
:param source_cidr_ip: Property sourceCidrIp: Address or address segment.
:param user_access_type: Property userAccessType: User permission type: no_squash (default), root_squash, all_squash.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__d6b08a221352ddf828597145f5104e395a7ec07a7829c2851cdf48d1ff5b6a0f)
check_type(argname="argument access_group_name", value=access_group_name, expected_type=type_hints["access_group_name"])
check_type(argname="argument file_system_type", value=file_system_type, expected_type=type_hints["file_system_type"])
check_type(argname="argument ipv6_source_cidr_ip", value=ipv6_source_cidr_ip, expected_type=type_hints["ipv6_source_cidr_ip"])
check_type(argname="argument priority", value=priority, expected_type=type_hints["priority"])
check_type(argname="argument rw_access_type", value=rw_access_type, expected_type=type_hints["rw_access_type"])
check_type(argname="argument source_cidr_ip", value=source_cidr_ip, expected_type=type_hints["source_cidr_ip"])
check_type(argname="argument user_access_type", value=user_access_type, expected_type=type_hints["user_access_type"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"access_group_name": access_group_name,
}
if file_system_type is not None:
self._values["file_system_type"] = file_system_type
if ipv6_source_cidr_ip is not None:
self._values["ipv6_source_cidr_ip"] = ipv6_source_cidr_ip
if priority is not None:
self._values["priority"] = priority
if rw_access_type is not None:
self._values["rw_access_type"] = rw_access_type
if source_cidr_ip is not None:
self._values["source_cidr_ip"] = source_cidr_ip
if user_access_type is not None:
self._values["user_access_type"] = user_access_type
@builtins.property
def access_group_name(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property accessGroupName: Permission group name.'''
result = self._values.get("access_group_name")
assert result is not None, "Required property 'access_group_name' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def file_system_type(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property fileSystemType: The type of file system.
Values:
standard: the general NAS
extreme: the extreme NAS
'''
result = self._values.get("file_system_type")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def ipv6_source_cidr_ip(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property ipv6SourceCidrIp: Source IPv6 CIDR address segment.
IP addresses in CIDR format and IPv6 format are supported.
Currently, only the ultra-fast NAS in mainland China supports the IPv6 function, and the file system needs to enable the IPv6 function.
Only VPC private network is supported.
IPv4 and IPv6 are mutually exclusive, and the types cannot be converted.
'''
result = self._values.get("ipv6_source_cidr_ip")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def priority(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property priority: Priority level.
Range: 1-100. Default value: 1
'''
result = self._values.get("priority")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def rw_access_type(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property rwAccessType: Read-write permission type: RDWR (default), RDONLY.'''
result = self._values.get("rw_access_type")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def source_cidr_ip(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property sourceCidrIp: Address or address segment.'''
result = self._values.get("source_cidr_ip")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def user_access_type(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property userAccessType: User permission type: no_squash (default), root_squash, all_squash.'''
result = self._values.get("user_access_type")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "AccessRuleProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class DataFlow(
_ros_cdk_core_7adfd82f.Resource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-nas.DataFlow",
):
'''A ROS resource type: ``ALIYUN::NAS::DataFlow``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["DataFlowProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
'''Create a new ``ALIYUN::NAS::DataFlow``.
Param scope - scope in which this resource is defined
Param id - scoped id of the resource
Param props - resource properties
:param scope: -
:param id: -
:param props: -
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__b5e70b6fecd551511d1921080e2464dbbb9da08550fbf8a9a3cbc2733b4ed64b)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@builtins.property
@jsii.member(jsii_name="attrDataFlowId")
def attr_data_flow_id(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute DataFlowId: Data flow ID.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrDataFlowId"))
@builtins.property
@jsii.member(jsii_name="attrFileSystemId")
def attr_file_system_id(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute FileSystemId: File system ID.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrFileSystemId"))
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-nas.DataFlowProps",
jsii_struct_bases=[],
name_mapping={
"file_system_id": "fileSystemId",
"fset_id": "fsetId",
"source_storage": "sourceStorage",
"throughput": "throughput",
"auto_refresh_interval": "autoRefreshInterval",
"auto_refresh_policy": "autoRefreshPolicy",
"auto_refreshs": "autoRefreshs",
"description": "description",
"source_security_type": "sourceSecurityType",
},
)
class DataFlowProps:
def __init__(
self,
*,
file_system_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
fset_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
source_storage: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
throughput: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
auto_refresh_interval: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
auto_refresh_policy: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
auto_refreshs: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union["RosDataFlow.AutoRefreshsProperty", typing.Dict[builtins.str, typing.Any]]]]]] = None,
description: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
source_security_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::NAS::DataFlow``.
:param file_system_id: Property fileSystemId: File system ID.
:param fset_id: Property fsetId: Fileset ID.
:param source_storage: Property sourceStorage: Access path stored at the source.Format: : // . in: Storage Type: Currently only supports OSS. PATH: OSS's bucket name.Limit the following. Only support the lowercase letters, numbers and short strokes (-) and must start with a lowercase letter or number. The length is 8 ~ 128 English characters. Use UTF-8 encoding. Can't start with http: // and https: //. Explain that the OSS BUCKET must be the bucket that exists in the region.
:param throughput: Property throughput: The upper limit of transmission bandwidth for data flow, unit: MB/s. Value: 600 1200 1500. Explanation The transmission bandwidth of the data flow must be smaller than the IO bandwidth of the file system.
:param auto_refresh_interval: Property autoRefreshInterval: The automatic update interval time, every time the interval, the CPFS checks whether there is a data update in the directory. If there is data update, start the automatic update task, unit: minute. Scope of value: 5 ~ 525600, default value: 10.
:param auto_refresh_policy: Property autoRefreshPolicy: Automatic update strategy, after the source data is updated, the data update is introduced to the CPFS strategy. None (default): The data update of the source is not automatically imported into CPFS. Users can import data update at the source end of the source through data flow tasks. Importchanged: The data update at the source automatically imports CPFS.
:param auto_refreshs: Property autoRefreshs:.
:param description: Property description: Description of data flow. limit: The length is 2 to 128 English or Chinese characters. Start with a lowercase letter or Chinese, and you cannot start with http:// and https: //. It can contain numbers, half-horn colon (:), down line (_) or short lines (-).
:param source_security_type: Property sourceSecurityType: The type of safety protection types of the source storage. If the source storage must be protected through safety protection, please specify the type of safety protection type storage.Value: No (default value): It means that the source storage does not need to be accessed by safe protection. SSL: Protective access through SSL certificates.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__d9e168188f0d970a9c342231f51a2739302ab7e0cf9e2a3e1fff344592ed952d)
check_type(argname="argument file_system_id", value=file_system_id, expected_type=type_hints["file_system_id"])
check_type(argname="argument fset_id", value=fset_id, expected_type=type_hints["fset_id"])
check_type(argname="argument source_storage", value=source_storage, expected_type=type_hints["source_storage"])
check_type(argname="argument throughput", value=throughput, expected_type=type_hints["throughput"])
check_type(argname="argument auto_refresh_interval", value=auto_refresh_interval, expected_type=type_hints["auto_refresh_interval"])
check_type(argname="argument auto_refresh_policy", value=auto_refresh_policy, expected_type=type_hints["auto_refresh_policy"])
check_type(argname="argument auto_refreshs", value=auto_refreshs, expected_type=type_hints["auto_refreshs"])
check_type(argname="argument description", value=description, expected_type=type_hints["description"])
check_type(argname="argument source_security_type", value=source_security_type, expected_type=type_hints["source_security_type"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"file_system_id": file_system_id,
"fset_id": fset_id,
"source_storage": source_storage,
"throughput": throughput,
}
if auto_refresh_interval is not None:
self._values["auto_refresh_interval"] = auto_refresh_interval
if auto_refresh_policy is not None:
self._values["auto_refresh_policy"] = auto_refresh_policy
if auto_refreshs is not None:
self._values["auto_refreshs"] = auto_refreshs
if description is not None:
self._values["description"] = description
if source_security_type is not None:
self._values["source_security_type"] = source_security_type
@builtins.property
def file_system_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property fileSystemId: File system ID.'''
result = self._values.get("file_system_id")
assert result is not None, "Required property 'file_system_id' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def fset_id(self) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property fsetId: Fileset ID.'''
result = self._values.get("fset_id")
assert result is not None, "Required property 'fset_id' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def source_storage(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property sourceStorage: Access path stored at the source.Format: : // . in: Storage Type: Currently only supports OSS. PATH: OSS's bucket name.Limit the following. Only support the lowercase letters, numbers and short strokes (-) and must start with a lowercase letter or number. The length is 8 ~ 128 English characters. Use UTF-8 encoding. Can't start with http: // and https: //. Explain that the OSS BUCKET must be the bucket that exists in the region.'''
result = self._values.get("source_storage")
assert result is not None, "Required property 'source_storage' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def throughput(
self,
) -> typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property throughput: The upper limit of transmission bandwidth for data flow, unit: MB/s. Value: 600 1200 1500.
Explanation The transmission bandwidth of the data flow must be smaller than the IO bandwidth of the file system.
'''
result = self._values.get("throughput")
assert result is not None, "Required property 'throughput' is missing"
return typing.cast(typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def auto_refresh_interval(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property autoRefreshInterval: The automatic update interval time, every time the interval, the CPFS checks whether there is a data update in the directory.
If there is data update, start the automatic update task, unit: minute.
Scope of value: 5 ~ 525600, default value: 10.
'''
result = self._values.get("auto_refresh_interval")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def auto_refresh_policy(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property autoRefreshPolicy: Automatic update strategy, after the source data is updated, the data update is introduced to the CPFS strategy.
None (default): The data update of the source is not automatically imported into CPFS. Users can import data update at the source end of the source through data flow tasks.
Importchanged: The data update at the source automatically imports CPFS.
'''
result = self._values.get("auto_refresh_policy")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def auto_refreshs(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosDataFlow.AutoRefreshsProperty"]]]]:
'''Property autoRefreshs:.'''
result = self._values.get("auto_refreshs")
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosDataFlow.AutoRefreshsProperty"]]]], result)
@builtins.property
def description(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property description: Description of data flow.
limit:
The length is 2 to 128 English or Chinese characters.
Start with a lowercase letter or Chinese, and you cannot start with http:// and https: //.
It can contain numbers, half-horn colon (:), down line (_) or short lines (-).
'''
result = self._values.get("description")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def source_security_type(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property sourceSecurityType: The type of safety protection types of the source storage.
If the source storage must be protected through safety protection, please specify the type of safety protection type storage.Value:
No (default value): It means that the source storage does not need to be accessed by safe protection.
SSL: Protective access through SSL certificates.
'''
result = self._values.get("source_security_type")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "DataFlowProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class FileSystem(
_ros_cdk_core_7adfd82f.Resource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-nas.FileSystem",
):
'''A ROS resource type: ``ALIYUN::NAS::FileSystem``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["FileSystemProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
'''Create a new ``ALIYUN::NAS::FileSystem``.
Param scope - scope in which this resource is defined
Param id - scoped id of the resource
Param props - resource properties
:param scope: -
:param id: -
:param props: -
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__f08e36f508bf6c26be2684e621f4c27b458de129cd7b2ed6334a675f7da67e2d)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@builtins.property
@jsii.member(jsii_name="attrFileSystemId")
def attr_file_system_id(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute FileSystemId: ID of the file system created.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrFileSystemId"))
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-nas.FileSystemProps",
jsii_struct_bases=[],
name_mapping={
"protocol_type": "protocolType",
"storage_type": "storageType",
"bandwidth": "bandwidth",
"capacity": "capacity",
"charge_type": "chargeType",
"deletion_force": "deletionForce",
"description": "description",
"duration": "duration",
"encrypt_type": "encryptType",
"file_system_type": "fileSystemType",
"snapshot_id": "snapshotId",
"tags": "tags",
"vpc_id": "vpcId",
"v_switch_id": "vSwitchId",
"zone_id": "zoneId",
},
)
class FileSystemProps:
def __init__(
self,
*,
protocol_type: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
storage_type: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
bandwidth: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
capacity: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
charge_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
deletion_force: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
description: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
duration: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
encrypt_type: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
file_system_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
snapshot_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
tags: typing.Optional[typing.Sequence[typing.Union["RosFileSystem.TagsProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
vpc_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
v_switch_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
zone_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::NAS::FileSystem``.
:param protocol_type: Property protocolType: Type of protocol used. Valid values: NFS, SMB, cpfs.
:param storage_type: Property storageType: The storage type of the file System. Valid values: Performance、Capacity(Available when the file_system_type is standard) standard、advance(Available when the file_system_type is extreme) advance_100、advance_200(Available when the file_system_type is cpfs)
:param bandwidth: Property bandwidth: Maximum file system throughput, unit is MB/s. Required and valid only when FileSystemType=cpfs.
:param capacity: Property capacity: File system capacity, the unit is GB. Required and valid when FileSystemType=extreme or cpfs.
:param charge_type: Property chargeType: Type of payment: PayAsYouGo (pay as you go) Subscription.
:param deletion_force: Property deletionForce: Whether delete all mount targets on the file system and then delete file system. Default is false
:param description: Property description: File system description (space characters are not allowed).
:param duration: Property duration: The period of subscription in months. Required and valid when ChargeType is Subscription. When the annual and monthly subscription instance expires without renewal, the instance will automatically expire and be released.
:param encrypt_type: Property encryptType: Specifies whether to encrypt data. You can use keys that are hosted by Key Management Service (KMS) to encrypt data stored on a file system. Data is automatically decrypted when you access encrypted data. Valid values: 0: specifies that no encryption is applied to data on the file system. 1: specifies that encryption is applied to data on the file system.
:param file_system_type: Property fileSystemType: File system type. Allowed values: standard(default), extreme, cpfs
:param snapshot_id: Property snapshotId: Snapshot ID.
:param tags: Property tags: Tags to attach to filesystem. Max support 20 tags to add during create filesystem. Each tag with two properties Key and Value, and Key is required.
:param vpc_id: Property vpcId: Vpc ID.
:param v_switch_id: Property vSwitchId: VSwitch ID.
:param zone_id: Property zoneId: Zone ID.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__4b629c1ab030cee3e8346720296fc68af606d8edcd8ca2e6fddb5daf51882ef5)
check_type(argname="argument protocol_type", value=protocol_type, expected_type=type_hints["protocol_type"])
check_type(argname="argument storage_type", value=storage_type, expected_type=type_hints["storage_type"])
check_type(argname="argument bandwidth", value=bandwidth, expected_type=type_hints["bandwidth"])
check_type(argname="argument capacity", value=capacity, expected_type=type_hints["capacity"])
check_type(argname="argument charge_type", value=charge_type, expected_type=type_hints["charge_type"])
check_type(argname="argument deletion_force", value=deletion_force, expected_type=type_hints["deletion_force"])
check_type(argname="argument description", value=description, expected_type=type_hints["description"])
check_type(argname="argument duration", value=duration, expected_type=type_hints["duration"])
check_type(argname="argument encrypt_type", value=encrypt_type, expected_type=type_hints["encrypt_type"])
check_type(argname="argument file_system_type", value=file_system_type, expected_type=type_hints["file_system_type"])
check_type(argname="argument snapshot_id", value=snapshot_id, expected_type=type_hints["snapshot_id"])
check_type(argname="argument tags", value=tags, expected_type=type_hints["tags"])
check_type(argname="argument vpc_id", value=vpc_id, expected_type=type_hints["vpc_id"])
check_type(argname="argument v_switch_id", value=v_switch_id, expected_type=type_hints["v_switch_id"])
check_type(argname="argument zone_id", value=zone_id, expected_type=type_hints["zone_id"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"protocol_type": protocol_type,
"storage_type": storage_type,
}
if bandwidth is not None:
self._values["bandwidth"] = bandwidth
if capacity is not None:
self._values["capacity"] = capacity
if charge_type is not None:
self._values["charge_type"] = charge_type
if deletion_force is not None:
self._values["deletion_force"] = deletion_force
if description is not None:
self._values["description"] = description
if duration is not None:
self._values["duration"] = duration
if encrypt_type is not None:
self._values["encrypt_type"] = encrypt_type
if file_system_type is not None:
self._values["file_system_type"] = file_system_type
if snapshot_id is not None:
self._values["snapshot_id"] = snapshot_id
if tags is not None:
self._values["tags"] = tags
if vpc_id is not None:
self._values["vpc_id"] = vpc_id
if v_switch_id is not None:
self._values["v_switch_id"] = v_switch_id
if zone_id is not None:
self._values["zone_id"] = zone_id
@builtins.property
def protocol_type(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property protocolType: Type of protocol used.
Valid values: NFS, SMB, cpfs.
'''
result = self._values.get("protocol_type")
assert result is not None, "Required property 'protocol_type' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def storage_type(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property storageType: The storage type of the file System.
Valid values:
Performance、Capacity(Available when the file_system_type is standard)
standard、advance(Available when the file_system_type is extreme)
advance_100、advance_200(Available when the file_system_type is cpfs)
'''
result = self._values.get("storage_type")
assert result is not None, "Required property 'storage_type' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def bandwidth(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property bandwidth: Maximum file system throughput, unit is MB/s.
Required and valid only when FileSystemType=cpfs.
'''
result = self._values.get("bandwidth")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def capacity(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property capacity: File system capacity, the unit is GB.
Required and valid when FileSystemType=extreme or cpfs.
'''
result = self._values.get("capacity")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def charge_type(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property chargeType: Type of payment: PayAsYouGo (pay as you go) Subscription.'''
result = self._values.get("charge_type")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def deletion_force(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property deletionForce: Whether delete all mount targets on the file system and then delete file system.
Default is false
'''
result = self._values.get("deletion_force")
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def description(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property description: File system description (space characters are not allowed).'''
result = self._values.get("description")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def duration(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property duration: The period of subscription in months.
Required and valid when ChargeType is Subscription.
When the annual and monthly subscription instance expires without renewal, the instance will automatically expire and be released.
'''
result = self._values.get("duration")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def encrypt_type(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property encryptType: Specifies whether to encrypt data.
You can use keys that are hosted by Key Management Service (KMS) to encrypt data stored on a file system. Data is automatically decrypted when you access encrypted data. Valid values:
0: specifies that no encryption is applied to data on the file system.
1: specifies that encryption is applied to data on the file system.
'''
result = self._values.get("encrypt_type")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def file_system_type(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property fileSystemType: File system type.
Allowed values: standard(default), extreme, cpfs
'''
result = self._values.get("file_system_type")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def snapshot_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property snapshotId: Snapshot ID.'''
result = self._values.get("snapshot_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def tags(self) -> typing.Optional[typing.List["RosFileSystem.TagsProperty"]]:
'''Property tags: Tags to attach to filesystem.
Max support 20 tags to add during create filesystem. Each tag with two properties Key and Value, and Key is required.
'''
result = self._values.get("tags")
return typing.cast(typing.Optional[typing.List["RosFileSystem.TagsProperty"]], result)
@builtins.property
def vpc_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property vpcId: Vpc ID.'''
result = self._values.get("vpc_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def v_switch_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property vSwitchId: VSwitch ID.'''
result = self._values.get("v_switch_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def zone_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property zoneId: Zone ID.'''
result = self._values.get("zone_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "FileSystemProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class Fileset(
_ros_cdk_core_7adfd82f.Resource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-nas.Fileset",
):
'''A ROS resource type: ``ALIYUN::NAS::Fileset``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["FilesetProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
'''Create a new ``ALIYUN::NAS::Fileset``.
Param scope - scope in which this resource is defined
Param id - scoped id of the resource
Param props - resource properties
:param scope: -
:param id: -
:param props: -
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__d1d717ec7a00a869738ca6b33860bc335263b80fedb8a2fbebb041c6c425a226)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@builtins.property
@jsii.member(jsii_name="attrFileSystemId")
def attr_file_system_id(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute FileSystemId: File system ID.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrFileSystemId"))
@builtins.property
@jsii.member(jsii_name="attrFileSystemPath")
def attr_file_system_path(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute FileSystemPath: File system path.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrFileSystemPath"))
@builtins.property
@jsii.member(jsii_name="attrFsetId")
def attr_fset_id(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute FsetId: Fileset ID.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrFsetId"))
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-nas.FilesetProps",
jsii_struct_bases=[],
name_mapping={
"file_system_id": "fileSystemId",
"file_system_path": "fileSystemPath",
"description": "description",
},
)
class FilesetProps:
def __init__(
self,
*,
file_system_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
file_system_path: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
description: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::NAS::Fileset``.
:param file_system_id: Property fileSystemId: File system ID.
:param file_system_path: Property fileSystemPath: The absolute path of Fileset to be created. The parent catalog of specified the directory must be a directory in the file system. The length is 2 to 1024 characters. Specify the directory must start with positive (/).
:param description: Property description: Fileset description information. The length is 2 to 128 English or Chinese characters. Start with a lowercase letter or Chinese, and you cannot start with http:// and https: //. It can contain numbers, half-horn colon (:), down line (_) or short lines (-).
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__368024a96739c25073aecc43ab390a7634b0c29e0b3777a4bf28ff7e12d72449)
check_type(argname="argument file_system_id", value=file_system_id, expected_type=type_hints["file_system_id"])
check_type(argname="argument file_system_path", value=file_system_path, expected_type=type_hints["file_system_path"])
check_type(argname="argument description", value=description, expected_type=type_hints["description"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"file_system_id": file_system_id,
"file_system_path": file_system_path,
}
if description is not None:
self._values["description"] = description
@builtins.property
def file_system_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property fileSystemId: File system ID.'''
result = self._values.get("file_system_id")
assert result is not None, "Required property 'file_system_id' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def file_system_path(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property fileSystemPath: The absolute path of Fileset to be created.
The parent catalog of specified the directory must be a directory in the file system.
The length is 2 to 1024 characters.
Specify the directory must start with positive (/).
'''
result = self._values.get("file_system_path")
assert result is not None, "Required property 'file_system_path' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def description(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property description: Fileset description information.
The length is 2 to 128 English or Chinese characters.
Start with a lowercase letter or Chinese, and you cannot start with http:// and https: //.
It can contain numbers, half-horn colon (:), down line (_) or short lines (-).
'''
result = self._values.get("description")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "FilesetProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class MountTarget(
_ros_cdk_core_7adfd82f.Resource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-nas.MountTarget",
):
'''A ROS resource type: ``ALIYUN::NAS::MountTarget``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["MountTargetProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
'''Create a new ``ALIYUN::NAS::MountTarget``.
Param scope - scope in which this resource is defined
Param id - scoped id of the resource
Param props - resource properties
:param scope: -
:param id: -
:param props: -
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__b1f00245bc88fe214aea0f5fcf1301cb1a9de78f42632f94bc54e1db8cbe6268)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@builtins.property
@jsii.member(jsii_name="attrMountTargetDomain")
def attr_mount_target_domain(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute MountTargetDomain: Mount point domain name.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrMountTargetDomain"))
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-nas.MountTargetProps",
jsii_struct_bases=[],
name_mapping={
"access_group_name": "accessGroupName",
"file_system_id": "fileSystemId",
"network_type": "networkType",
"enable_ipv6": "enableIpv6",
"security_group_id": "securityGroupId",
"status": "status",
"vpc_id": "vpcId",
"v_switch_id": "vSwitchId",
},
)
class MountTargetProps:
def __init__(
self,
*,
access_group_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
file_system_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
network_type: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
enable_ipv6: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
security_group_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
status: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
vpc_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
v_switch_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::NAS::MountTarget``.
:param access_group_name: Property accessGroupName: Permission group name. Default to DEFAULT_VPC_GROUP_NAME.
:param file_system_id: Property fileSystemId: File system ID.
:param network_type: Property networkType: Network type, including Vpc and Classic networks.
:param enable_ipv6: Property enableIpv6: Whether to create an IPv6 mount point.Value: true: create false (default): do not create Note Currently, only the ultra-fast NAS in mainland China supports the IPv6 function, and the file system needs to enable the IPv6 function.
:param security_group_id: Property securityGroupId: Security group Id.
:param status: Property status: Status, including Active and Inactive.
:param vpc_id: Property vpcId: VPC network ID.
:param v_switch_id: Property vSwitchId: VSwitch ID.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__503cdafbad0e86b5bb0ce1a4866d2baa7806ce596b11b936170eb711c72af6e2)
check_type(argname="argument access_group_name", value=access_group_name, expected_type=type_hints["access_group_name"])
check_type(argname="argument file_system_id", value=file_system_id, expected_type=type_hints["file_system_id"])
check_type(argname="argument network_type", value=network_type, expected_type=type_hints["network_type"])
check_type(argname="argument enable_ipv6", value=enable_ipv6, expected_type=type_hints["enable_ipv6"])
check_type(argname="argument security_group_id", value=security_group_id, expected_type=type_hints["security_group_id"])
check_type(argname="argument status", value=status, expected_type=type_hints["status"])
check_type(argname="argument vpc_id", value=vpc_id, expected_type=type_hints["vpc_id"])
check_type(argname="argument v_switch_id", value=v_switch_id, expected_type=type_hints["v_switch_id"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"access_group_name": access_group_name,
"file_system_id": file_system_id,
"network_type": network_type,
}
if enable_ipv6 is not None:
self._values["enable_ipv6"] = enable_ipv6
if security_group_id is not None:
self._values["security_group_id"] = security_group_id
if status is not None:
self._values["status"] = status
if vpc_id is not None:
self._values["vpc_id"] = vpc_id
if v_switch_id is not None:
self._values["v_switch_id"] = v_switch_id
@builtins.property
def access_group_name(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property accessGroupName: Permission group name.
Default to DEFAULT_VPC_GROUP_NAME.
'''
result = self._values.get("access_group_name")
assert result is not None, "Required property 'access_group_name' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def file_system_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property fileSystemId: File system ID.'''
result = self._values.get("file_system_id")
assert result is not None, "Required property 'file_system_id' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def network_type(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property networkType: Network type, including Vpc and Classic networks.'''
result = self._values.get("network_type")
assert result is not None, "Required property 'network_type' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def enable_ipv6(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property enableIpv6: Whether to create an IPv6 mount point.Value: true: create false (default): do not create Note Currently, only the ultra-fast NAS in mainland China supports the IPv6 function, and the file system needs to enable the IPv6 function.'''
result = self._values.get("enable_ipv6")
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def security_group_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property securityGroupId: Security group Id.'''
result = self._values.get("security_group_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def status(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property status: Status, including Active and Inactive.'''
result = self._values.get("status")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def vpc_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property vpcId: VPC network ID.'''
result = self._values.get("vpc_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def v_switch_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property vSwitchId: VSwitch ID.'''
result = self._values.get("v_switch_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "MountTargetProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class ProtocolMountTarget(
_ros_cdk_core_7adfd82f.Resource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-nas.ProtocolMountTarget",
):
'''A ROS resource type: ``ALIYUN::NAS::ProtocolMountTarget``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["ProtocolMountTargetProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
'''Create a new ``ALIYUN::NAS::ProtocolMountTarget``.
Param scope - scope in which this resource is defined
Param id - scoped id of the resource
Param props - resource properties
:param scope: -
:param id: -
:param props: -
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__de46cad0bf38a0839321f0ea748d81797eb8445d30e5e451d56dce4e3fe8b886)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@builtins.property
@jsii.member(jsii_name="attrExportId")
def attr_export_id(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute ExportId: The protocol service exports directory ID.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrExportId"))
@builtins.property
@jsii.member(jsii_name="attrFileSystemId")
def attr_file_system_id(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute FileSystemId: File system ID.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrFileSystemId"))
@builtins.property
@jsii.member(jsii_name="attrProtocolMountTargetDomain")
def attr_protocol_mount_target_domain(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute ProtocolMountTargetDomain: The protocol mount target domain.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrProtocolMountTargetDomain"))
@builtins.property
@jsii.member(jsii_name="attrProtocolServiceId")
def attr_protocol_service_id(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute ProtocolServiceId: Protocol service ID.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrProtocolServiceId"))
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-nas.ProtocolMountTargetProps",
jsii_struct_bases=[],
name_mapping={
"file_system_id": "fileSystemId",
"protocol_service_id": "protocolServiceId",
"vpc_id": "vpcId",
"v_switch_id": "vSwitchId",
"access_group_name": "accessGroupName",
"description": "description",
"fset_id": "fsetId",
"path": "path",
},
)
class ProtocolMountTargetProps:
def __init__(
self,
*,
file_system_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
protocol_service_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
vpc_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
v_switch_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
access_group_name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
description: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
fset_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
path: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::NAS::ProtocolMountTarget``.
:param file_system_id: Property fileSystemId: File system ID.
:param protocol_service_id: Property protocolServiceId: Agreement service ID.
:param vpc_id: Property vpcId: Proper network ID exported by the protocol service.
:param v_switch_id: Property vSwitchId: Switch ID exported by the protocol service.
:param access_group_name: Property accessGroupName: The name of the permissions group. Default value: DEFAULT_VPC_GROUP_NAME
:param description: Property description: Description of the protocol service to export the directory.The console is displayed as the export directory name. limit: The length is 2 to 128 English or Chinese characters. Start with a lowercase letter or Chinese, and you cannot start with http:// and https: //. It can contain numbers, half-horn colon (:), down line (_) or short lines (-).
:param fset_id: Property fsetId: Fileset ID needs to be exported. limit: The Fileset must exist. A Fileset allows only one export directory. Fileset and Path can only specify one.
:param path: Property path: The path of the CPFS directory that needs to be exported. limit: This directory must be existing directory on CPFS. The same directory allows only one export. Fileset and Path can only specify one. Format: The length is 1 to 1024 characters. Use UTF-8 encoding. It must start with the positive oblique line (/), and the root directory must be/.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__fedb67fd491330ac792c990726436fcf1a053ab8b8bebf4fd3b6ec19aaca0ee8)
check_type(argname="argument file_system_id", value=file_system_id, expected_type=type_hints["file_system_id"])
check_type(argname="argument protocol_service_id", value=protocol_service_id, expected_type=type_hints["protocol_service_id"])
check_type(argname="argument vpc_id", value=vpc_id, expected_type=type_hints["vpc_id"])
check_type(argname="argument v_switch_id", value=v_switch_id, expected_type=type_hints["v_switch_id"])
check_type(argname="argument access_group_name", value=access_group_name, expected_type=type_hints["access_group_name"])
check_type(argname="argument description", value=description, expected_type=type_hints["description"])
check_type(argname="argument fset_id", value=fset_id, expected_type=type_hints["fset_id"])
check_type(argname="argument path", value=path, expected_type=type_hints["path"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"file_system_id": file_system_id,
"protocol_service_id": protocol_service_id,
"vpc_id": vpc_id,
"v_switch_id": v_switch_id,
}
if access_group_name is not None:
self._values["access_group_name"] = access_group_name
if description is not None:
self._values["description"] = description
if fset_id is not None:
self._values["fset_id"] = fset_id
if path is not None:
self._values["path"] = path
@builtins.property
def file_system_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property fileSystemId: File system ID.'''
result = self._values.get("file_system_id")
assert result is not None, "Required property 'file_system_id' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def protocol_service_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property protocolServiceId: Agreement service ID.'''
result = self._values.get("protocol_service_id")
assert result is not None, "Required property 'protocol_service_id' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def vpc_id(self) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property vpcId: Proper network ID exported by the protocol service.'''
result = self._values.get("vpc_id")
assert result is not None, "Required property 'vpc_id' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def v_switch_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property vSwitchId: Switch ID exported by the protocol service.'''
result = self._values.get("v_switch_id")
assert result is not None, "Required property 'v_switch_id' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def access_group_name(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property accessGroupName: The name of the permissions group.
Default value: DEFAULT_VPC_GROUP_NAME
'''
result = self._values.get("access_group_name")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def description(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property description: Description of the protocol service to export the directory.The console is displayed as the export directory name. limit: The length is 2 to 128 English or Chinese characters. Start with a lowercase letter or Chinese, and you cannot start with http:// and https: //. It can contain numbers, half-horn colon (:), down line (_) or short lines (-).'''
result = self._values.get("description")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def fset_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property fsetId: Fileset ID needs to be exported.
limit:
The Fileset must exist.
A Fileset allows only one export directory.
Fileset and Path can only specify one.
'''
result = self._values.get("fset_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def path(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property path: The path of the CPFS directory that needs to be exported.
limit:
This directory must be existing directory on CPFS.
The same directory allows only one export.
Fileset and Path can only specify one.
Format:
The length is 1 to 1024 characters.
Use UTF-8 encoding.
It must start with the positive oblique line (/), and the root directory must be/.
'''
result = self._values.get("path")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "ProtocolMountTargetProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class ProtocolService(
_ros_cdk_core_7adfd82f.Resource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-nas.ProtocolService",
):
'''A ROS resource type: ``ALIYUN::NAS::ProtocolService``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["ProtocolServiceProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
'''Create a new ``ALIYUN::NAS::ProtocolService``.
Param scope - scope in which this resource is defined
Param id - scoped id of the resource
Param props - resource properties
:param scope: -
:param id: -
:param props: -
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__c6ff8d2a67f998d4210b883c834d32c40245ef46cf04cb5df5ed174d5782a7be)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@builtins.property
@jsii.member(jsii_name="attrFileSystemId")
def attr_file_system_id(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute FileSystemId: File system ID.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrFileSystemId"))
@builtins.property
@jsii.member(jsii_name="attrProtocolServiceId")
def attr_protocol_service_id(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute ProtocolServiceId: Agreement cluster group ID.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrProtocolServiceId"))
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-nas.ProtocolServiceProps",
jsii_struct_bases=[],
name_mapping={
"file_system_id": "fileSystemId",
"protocol_spec": "protocolSpec",
"protocol_type": "protocolType",
"vpc_id": "vpcId",
"v_switch_id": "vSwitchId",
"description": "description",
"throughput": "throughput",
},
)
class ProtocolServiceProps:
def __init__(
self,
*,
file_system_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
protocol_spec: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
protocol_type: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
vpc_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
v_switch_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
description: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
throughput: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::NAS::ProtocolService``.
:param file_system_id: Property fileSystemId: File system ID.
:param protocol_spec: Property protocolSpec: The spec of protocol service. Default: General. Values: General
:param protocol_type: Property protocolType: The protocol type of agreement service. Ranges: NFS: Agreement service supports NFS protocol access. The default value: NFS.
:param vpc_id: Property vpcId: The protocol service VPCID needs to be consistent with the file system VPC.
:param v_switch_id: Property vSwitchId: Agreement service vswitchid.
:param description: Property description: Description of protocol service.The console shows the "protocol service name". limit: The length is 2 to 128 English or Chinese characters. Start with a lowercase letter or Chinese, and you cannot start with http:// and https: //. It can contain numbers, half-horn colon (:), down line (_) or short lines (-).
:param throughput: Property throughput: The bandwidth of the agreement service. Unit: MB/S.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__76fd55713defe391256665574c0d5061435e8faa1a9590b2ec159a6bfe7e8771)
check_type(argname="argument file_system_id", value=file_system_id, expected_type=type_hints["file_system_id"])
check_type(argname="argument protocol_spec", value=protocol_spec, expected_type=type_hints["protocol_spec"])
check_type(argname="argument protocol_type", value=protocol_type, expected_type=type_hints["protocol_type"])
check_type(argname="argument vpc_id", value=vpc_id, expected_type=type_hints["vpc_id"])
check_type(argname="argument v_switch_id", value=v_switch_id, expected_type=type_hints["v_switch_id"])
check_type(argname="argument description", value=description, expected_type=type_hints["description"])
check_type(argname="argument throughput", value=throughput, expected_type=type_hints["throughput"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"file_system_id": file_system_id,
"protocol_spec": protocol_spec,
"protocol_type": protocol_type,
"vpc_id": vpc_id,
"v_switch_id": v_switch_id,
}
if description is not None:
self._values["description"] = description
if throughput is not None:
self._values["throughput"] = throughput
@builtins.property
def file_system_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property fileSystemId: File system ID.'''
result = self._values.get("file_system_id")
assert result is not None, "Required property 'file_system_id' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def protocol_spec(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property protocolSpec: The spec of protocol service.
Default: General. Values: General
'''
result = self._values.get("protocol_spec")
assert result is not None, "Required property 'protocol_spec' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def protocol_type(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property protocolType: The protocol type of agreement service.
Ranges:
NFS: Agreement service supports NFS protocol access.
The default value: NFS.
'''
result = self._values.get("protocol_type")
assert result is not None, "Required property 'protocol_type' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def vpc_id(self) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property vpcId: The protocol service VPCID needs to be consistent with the file system VPC.'''
result = self._values.get("vpc_id")
assert result is not None, "Required property 'vpc_id' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def v_switch_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property vSwitchId: Agreement service vswitchid.'''
result = self._values.get("v_switch_id")
assert result is not None, "Required property 'v_switch_id' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def description(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property description: Description of protocol service.The console shows the "protocol service name". limit: The length is 2 to 128 English or Chinese characters. Start with a lowercase letter or Chinese, and you cannot start with http:// and https: //. It can contain numbers, half-horn colon (:), down line (_) or short lines (-).'''
result = self._values.get("description")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def throughput(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property throughput: The bandwidth of the agreement service.
Unit: MB/S.
'''
result = self._values.get("throughput")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "ProtocolServiceProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class RosAccessGroup(
_ros_cdk_core_7adfd82f.RosResource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-nas.RosAccessGroup",
):
'''A ROS template type: ``ALIYUN::NAS::AccessGroup``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["RosAccessGroupProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
'''Create a new ``ALIYUN::NAS::AccessGroup``.
:param scope: - scope in which this resource is defined.
:param id: - scoped id of the resource.
:param props: - resource properties.
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__17d7caa04ec0f534160c6fd724465033498604c0b7b47d8ecbc263bdef694843)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@jsii.member(jsii_name="renderProperties")
def _render_properties(
self,
props: typing.Mapping[builtins.str, typing.Any],
) -> typing.Mapping[builtins.str, typing.Any]:
'''
:param props: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__260b3e9a88edd5cc45696f2a9224a6a4163b228af37d761eb0532dec42e67072)
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))
@jsii.python.classproperty
@jsii.member(jsii_name="ROS_RESOURCE_TYPE_NAME")
def ROS_RESOURCE_TYPE_NAME(cls) -> builtins.str:
'''The resource type name for this resource class.'''
return typing.cast(builtins.str, jsii.sget(cls, "ROS_RESOURCE_TYPE_NAME"))
@builtins.property
@jsii.member(jsii_name="attrAccessGroupName")
def attr_access_group_name(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: AccessGroupName: Permission group name
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrAccessGroupName"))
@builtins.property
@jsii.member(jsii_name="rosProperties")
def _ros_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "rosProperties"))
@builtins.property
@jsii.member(jsii_name="accessGroupName")
def access_group_name(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: accessGroupName: Permission group name
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "accessGroupName"))
@access_group_name.setter
def access_group_name(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__64de9dc66d110f14e43ff2a310e24c806e063bb9c71345c982e3439dc982e530)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "accessGroupName", value)
@builtins.property
@jsii.member(jsii_name="accessGroupType")
def access_group_type(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: accessGroupType: Permission group type, including the Vpc and Classic types
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "accessGroupType"))
@access_group_type.setter
def access_group_type(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__3d29204d60677bb489ab4a6497e6a1dd73efb156b6b93ca283541d9f98038e5a)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "accessGroupType", value)
@builtins.property
@jsii.member(jsii_name="enableResourcePropertyConstraint")
def enable_resource_property_constraint(self) -> builtins.bool:
return typing.cast(builtins.bool, jsii.get(self, "enableResourcePropertyConstraint"))
@enable_resource_property_constraint.setter
def enable_resource_property_constraint(self, value: builtins.bool) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__997068ffafd53ab7eca2ba5035ae391dbc877e5de4fb6ca24f26a2fd67ae34bd)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "enableResourcePropertyConstraint", value)
@builtins.property
@jsii.member(jsii_name="description")
def description(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: description: Permission group description. It is the same as the permission group name by default.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "description"))
@description.setter
def description(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__5038db951ef3e6113822ac996dd6369f1960f22cabedaae3e1ea9275d2e74849)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "description", value)
@builtins.property
@jsii.member(jsii_name="fileSystemType")
def file_system_type(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
fileSystemType: File system type.
Values: standard (default), extreme
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "fileSystemType"))
@file_system_type.setter
def file_system_type(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__2214608aae77eb4a9aa44cc8a50bf4a0c75116b81bb8bc360db32a3010fff738)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "fileSystemType", value)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-nas.RosAccessGroupProps",
jsii_struct_bases=[],
name_mapping={
"access_group_name": "accessGroupName",
"access_group_type": "accessGroupType",
"description": "description",
"file_system_type": "fileSystemType",
},
)
class RosAccessGroupProps:
def __init__(
self,
*,
access_group_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
access_group_type: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
description: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
file_system_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::NAS::AccessGroup``.
:param access_group_name:
:param access_group_type:
:param description:
:param file_system_type:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__894d86d5092e4136137947715c57558d006d0810f9d2223cd5815028c53323cf)
check_type(argname="argument access_group_name", value=access_group_name, expected_type=type_hints["access_group_name"])
check_type(argname="argument access_group_type", value=access_group_type, expected_type=type_hints["access_group_type"])
check_type(argname="argument description", value=description, expected_type=type_hints["description"])
check_type(argname="argument file_system_type", value=file_system_type, expected_type=type_hints["file_system_type"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"access_group_name": access_group_name,
"access_group_type": access_group_type,
}
if description is not None:
self._values["description"] = description
if file_system_type is not None:
self._values["file_system_type"] = file_system_type
@builtins.property
def access_group_name(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: accessGroupName: Permission group name
'''
result = self._values.get("access_group_name")
assert result is not None, "Required property 'access_group_name' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def access_group_type(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: accessGroupType: Permission group type, including the Vpc and Classic types
'''
result = self._values.get("access_group_type")
assert result is not None, "Required property 'access_group_type' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def description(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: description: Permission group description. It is the same as the permission group name by default.
'''
result = self._values.get("description")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def file_system_type(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
fileSystemType: File system type.
Values: standard (default), extreme
'''
result = self._values.get("file_system_type")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "RosAccessGroupProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class RosAccessRule(
_ros_cdk_core_7adfd82f.RosResource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-nas.RosAccessRule",
):
'''A ROS template type: ``ALIYUN::NAS::AccessRule``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["RosAccessRuleProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
'''Create a new ``ALIYUN::NAS::AccessRule``.
:param scope: - scope in which this resource is defined.
:param id: - scoped id of the resource.
:param props: - resource properties.
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__c127ef585711a654fff848ac0fe54d2ed0a46fb75f9e8082c9f31b1a01b3481a)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@jsii.member(jsii_name="renderProperties")
def _render_properties(
self,
props: typing.Mapping[builtins.str, typing.Any],
) -> typing.Mapping[builtins.str, typing.Any]:
'''
:param props: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__c149c12fbe435f30c97ace841d85d460e72d1b3f9ca9699bcf98789dbee6d02d)
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))
@jsii.python.classproperty
@jsii.member(jsii_name="ROS_RESOURCE_TYPE_NAME")
def ROS_RESOURCE_TYPE_NAME(cls) -> builtins.str:
'''The resource type name for this resource class.'''
return typing.cast(builtins.str, jsii.sget(cls, "ROS_RESOURCE_TYPE_NAME"))
@builtins.property
@jsii.member(jsii_name="attrAccessRuleId")
def attr_access_rule_id(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: AccessRuleId: Rule serial number
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrAccessRuleId"))
@builtins.property
@jsii.member(jsii_name="rosProperties")
def _ros_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "rosProperties"))
@builtins.property
@jsii.member(jsii_name="accessGroupName")
def access_group_name(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: accessGroupName: Permission group name
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "accessGroupName"))
@access_group_name.setter
def access_group_name(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__2e5a292a3a40dce89521c918c412d6026a7c0d795da6e4b8c144b4654969a815)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "accessGroupName", value)
@builtins.property
@jsii.member(jsii_name="enableResourcePropertyConstraint")
def enable_resource_property_constraint(self) -> builtins.bool:
return typing.cast(builtins.bool, jsii.get(self, "enableResourcePropertyConstraint"))
@enable_resource_property_constraint.setter
def enable_resource_property_constraint(self, value: builtins.bool) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__44f29a4bb0ef2642c5d1bf914e831bb9736dc3ac45d6e1effc62c326ec381308)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "enableResourcePropertyConstraint", value)
@builtins.property
@jsii.member(jsii_name="fileSystemType")
def file_system_type(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
fileSystemType: The type of file system. Values:
standard: the general NAS
extreme: the extreme NAS
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "fileSystemType"))
@file_system_type.setter
def file_system_type(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__99c7e8731b648ae4d8e93aef822910bb3cf0c398dc1cbfa3548cc1531f6ba3f6)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "fileSystemType", value)
@builtins.property
@jsii.member(jsii_name="ipv6SourceCidrIp")
def ipv6_source_cidr_ip(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
ipv6SourceCidrIp: Source IPv6 CIDR address segment. IP addresses in CIDR format and IPv6 format are supported.
Currently, only the ultra-fast NAS in mainland China supports the IPv6 function, and the file system needs to enable the IPv6 function.
Only VPC private network is supported.
IPv4 and IPv6 are mutually exclusive, and the types cannot be converted.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "ipv6SourceCidrIp"))
@ipv6_source_cidr_ip.setter
def ipv6_source_cidr_ip(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__1897a73cb46242cf34f507a56688529e174a36dc109c5773df12898abe515758)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "ipv6SourceCidrIp", value)
@builtins.property
@jsii.member(jsii_name="priority")
def priority(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: priority: Priority level. Range: 1-100. Default value: 1
'''
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "priority"))
@priority.setter
def priority(
self,
value: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__2a427490a582a571a18e1b7cb1d5963b24135ce78fc29ec89a2970b9123dfff1)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "priority", value)
@builtins.property
@jsii.member(jsii_name="rwAccessType")
def rw_access_type(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: rwAccessType: Read-write permission type: RDWR (default), RDONLY
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "rwAccessType"))
@rw_access_type.setter
def rw_access_type(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__d425bc1f462fccd1532eac85ce6709d44a2f7aeb36a46ac3b7847c2b786e652b)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "rwAccessType", value)
@builtins.property
@jsii.member(jsii_name="sourceCidrIp")
def source_cidr_ip(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: sourceCidrIp: Address or address segment
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "sourceCidrIp"))
@source_cidr_ip.setter
def source_cidr_ip(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__7293e86f1208efaa25433115fbbad7e7956a1cf2be94c226e3f78dd67840d879)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "sourceCidrIp", value)
@builtins.property
@jsii.member(jsii_name="userAccessType")
def user_access_type(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: userAccessType: User permission type: no_squash (default), root_squash, all_squash
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "userAccessType"))
@user_access_type.setter
def user_access_type(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__2e2306745096dfb9ed3f0bb2ecbc6b5cb5f1f6e8cb5287458ff063301383e740)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "userAccessType", value)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-nas.RosAccessRuleProps",
jsii_struct_bases=[],
name_mapping={
"access_group_name": "accessGroupName",
"file_system_type": "fileSystemType",
"ipv6_source_cidr_ip": "ipv6SourceCidrIp",
"priority": "priority",
"rw_access_type": "rwAccessType",
"source_cidr_ip": "sourceCidrIp",
"user_access_type": "userAccessType",
},
)
class RosAccessRuleProps:
def __init__(
self,
*,
access_group_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
file_system_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
ipv6_source_cidr_ip: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
priority: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
rw_access_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
source_cidr_ip: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
user_access_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::NAS::AccessRule``.
:param access_group_name:
:param file_system_type:
:param ipv6_source_cidr_ip:
:param priority:
:param rw_access_type:
:param source_cidr_ip:
:param user_access_type:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__168086a55681ea64a5e0c16598b5bb0e13ffacecb5e3e64c6629d01eb622ca0f)
check_type(argname="argument access_group_name", value=access_group_name, expected_type=type_hints["access_group_name"])
check_type(argname="argument file_system_type", value=file_system_type, expected_type=type_hints["file_system_type"])
check_type(argname="argument ipv6_source_cidr_ip", value=ipv6_source_cidr_ip, expected_type=type_hints["ipv6_source_cidr_ip"])
check_type(argname="argument priority", value=priority, expected_type=type_hints["priority"])
check_type(argname="argument rw_access_type", value=rw_access_type, expected_type=type_hints["rw_access_type"])
check_type(argname="argument source_cidr_ip", value=source_cidr_ip, expected_type=type_hints["source_cidr_ip"])
check_type(argname="argument user_access_type", value=user_access_type, expected_type=type_hints["user_access_type"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"access_group_name": access_group_name,
}
if file_system_type is not None:
self._values["file_system_type"] = file_system_type
if ipv6_source_cidr_ip is not None:
self._values["ipv6_source_cidr_ip"] = ipv6_source_cidr_ip
if priority is not None:
self._values["priority"] = priority
if rw_access_type is not None:
self._values["rw_access_type"] = rw_access_type
if source_cidr_ip is not None:
self._values["source_cidr_ip"] = source_cidr_ip
if user_access_type is not None:
self._values["user_access_type"] = user_access_type
@builtins.property
def access_group_name(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: accessGroupName: Permission group name
'''
result = self._values.get("access_group_name")
assert result is not None, "Required property 'access_group_name' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def file_system_type(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
fileSystemType: The type of file system. Values:
standard: the general NAS
extreme: the extreme NAS
'''
result = self._values.get("file_system_type")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def ipv6_source_cidr_ip(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
ipv6SourceCidrIp: Source IPv6 CIDR address segment. IP addresses in CIDR format and IPv6 format are supported.
Currently, only the ultra-fast NAS in mainland China supports the IPv6 function, and the file system needs to enable the IPv6 function.
Only VPC private network is supported.
IPv4 and IPv6 are mutually exclusive, and the types cannot be converted.
'''
result = self._values.get("ipv6_source_cidr_ip")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def priority(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: priority: Priority level. Range: 1-100. Default value: 1
'''
result = self._values.get("priority")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def rw_access_type(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: rwAccessType: Read-write permission type: RDWR (default), RDONLY
'''
result = self._values.get("rw_access_type")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def source_cidr_ip(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: sourceCidrIp: Address or address segment
'''
result = self._values.get("source_cidr_ip")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def user_access_type(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: userAccessType: User permission type: no_squash (default), root_squash, all_squash
'''
result = self._values.get("user_access_type")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "RosAccessRuleProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class RosDataFlow(
_ros_cdk_core_7adfd82f.RosResource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-nas.RosDataFlow",
):
'''A ROS template type: ``ALIYUN::NAS::DataFlow``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["RosDataFlowProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
'''Create a new ``ALIYUN::NAS::DataFlow``.
:param scope: - scope in which this resource is defined.
:param id: - scoped id of the resource.
:param props: - resource properties.
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__86db75dbc818cc45f7a30541573d7761bcea29d2107bb458416ec06c025dc8ab)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@jsii.member(jsii_name="renderProperties")
def _render_properties(
self,
props: typing.Mapping[builtins.str, typing.Any],
) -> typing.Mapping[builtins.str, typing.Any]:
'''
:param props: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__0e1f31fac01da09b536dc10d970b3becc86216ec8b499eef3370e1034980b917)
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))
@jsii.python.classproperty
@jsii.member(jsii_name="ROS_RESOURCE_TYPE_NAME")
def ROS_RESOURCE_TYPE_NAME(cls) -> builtins.str:
'''The resource type name for this resource class.'''
return typing.cast(builtins.str, jsii.sget(cls, "ROS_RESOURCE_TYPE_NAME"))
@builtins.property
@jsii.member(jsii_name="attrDataFlowId")
def attr_data_flow_id(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: DataFlowId: Data flow ID.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrDataFlowId"))
@builtins.property
@jsii.member(jsii_name="attrFileSystemId")
def attr_file_system_id(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: FileSystemId: File system ID.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrFileSystemId"))
@builtins.property
@jsii.member(jsii_name="rosProperties")
def _ros_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "rosProperties"))
@builtins.property
@jsii.member(jsii_name="enableResourcePropertyConstraint")
def enable_resource_property_constraint(self) -> builtins.bool:
return typing.cast(builtins.bool, jsii.get(self, "enableResourcePropertyConstraint"))
@enable_resource_property_constraint.setter
def enable_resource_property_constraint(self, value: builtins.bool) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__a0f4557a2b8d5afa65362b7c158a88a22684e46cfde4492fc46df5f0be938330)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "enableResourcePropertyConstraint", value)
@builtins.property
@jsii.member(jsii_name="fileSystemId")
def file_system_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: fileSystemId: File system ID.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "fileSystemId"))
@file_system_id.setter
def file_system_id(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__00dd7850eae7be3c8669a88403300be5eaabe4a57bbae57d8832a5a8bd89bea3)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "fileSystemId", value)
@builtins.property
@jsii.member(jsii_name="fsetId")
def fset_id(self) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: fsetId: Fileset ID.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "fsetId"))
@fset_id.setter
def fset_id(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__39c355c7132cad9a6407a1e316dbc472c4e88bee1d2a1e6ee29fededdf98a131)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "fsetId", value)
@builtins.property
@jsii.member(jsii_name="sourceStorage")
def source_storage(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
sourceStorage: Access path stored at the source.Format: : // .
in:
Storage Type: Currently only supports OSS.
PATH: OSS's bucket name.Limit the following.
Only support the lowercase letters, numbers and short strokes (-) and must start with a lowercase letter or number.
The length is 8 ~ 128 English characters.
Use UTF-8 encoding.
Can't start with http: // and https: //.
Explain that the OSS BUCKET must be the bucket that exists in the region.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "sourceStorage"))
@source_storage.setter
def source_storage(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__31c74f488186bf7dc01c95cdbe314ca14fdb069b4ab23e5bedcde5463334de0f)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "sourceStorage", value)
@builtins.property
@jsii.member(jsii_name="throughput")
def throughput(
self,
) -> typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
throughput: The upper limit of transmission bandwidth for data flow, unit: MB/s.
Value:
600
1200
1500
Explanation The transmission bandwidth of the data flow must be smaller than the IO bandwidth of the file system.
'''
return typing.cast(typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "throughput"))
@throughput.setter
def throughput(
self,
value: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__7de8a6fca7223853104406b64fdead80449f5afe372c73739a1cd8295fc9df59)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "throughput", value)
@builtins.property
@jsii.member(jsii_name="autoRefreshInterval")
def auto_refresh_interval(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
autoRefreshInterval: The automatic update interval time, every time the interval, the CPFS checks whether there is a data update in the directory. If there is data update, start the automatic update task, unit: minute.
Scope of value: 5 ~ 525600, default value: 10.
'''
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "autoRefreshInterval"))
@auto_refresh_interval.setter
def auto_refresh_interval(
self,
value: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__b27b3a427efa9dc29327d9b6a41d39f76894946cd71254ce6772964aa0688e21)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "autoRefreshInterval", value)
@builtins.property
@jsii.member(jsii_name="autoRefreshPolicy")
def auto_refresh_policy(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
autoRefreshPolicy: Automatic update strategy, after the source data is updated, the data update is introduced to the CPFS strategy.
None (default): The data update of the source is not automatically imported into CPFS. Users can import data update at the source end of the source through data flow tasks.
Importchanged: The data update at the source automatically imports CPFS.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "autoRefreshPolicy"))
@auto_refresh_policy.setter
def auto_refresh_policy(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__fdb38926341d3d711fabac1a319abe5ee01602943a02b8d60e5766104dd3adf7)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "autoRefreshPolicy", value)
@builtins.property
@jsii.member(jsii_name="autoRefreshs")
def auto_refreshs(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosDataFlow.AutoRefreshsProperty"]]]]:
'''
:Property: autoRefreshs:
'''
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosDataFlow.AutoRefreshsProperty"]]]], jsii.get(self, "autoRefreshs"))
@auto_refreshs.setter
def auto_refreshs(
self,
value: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosDataFlow.AutoRefreshsProperty"]]]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__afd0b11c25b34b04165b4b17341da571c75c63388bc8eac53b7b2ad01c24d587)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "autoRefreshs", value)
@builtins.property
@jsii.member(jsii_name="description")
def description(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
description: Description of data flow.
limit:
The length is 2 to 128 English or Chinese characters.
Start with a lowercase letter or Chinese, and you cannot start with http:// and https: //.
It can contain numbers, half-horn colon (:), down line (_) or short lines (-).
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "description"))
@description.setter
def description(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__c570b60a7acacafc49e043aa92b2ad5944e22ad576830748c8518454c1665622)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "description", value)
@builtins.property
@jsii.member(jsii_name="sourceSecurityType")
def source_security_type(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
sourceSecurityType: The type of safety protection types of the source storage. If the source storage must be protected through safety protection, please specify the type of safety protection type storage.Value:
No (default value): It means that the source storage does not need to be accessed by safe protection.
SSL: Protective access through SSL certificates.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "sourceSecurityType"))
@source_security_type.setter
def source_security_type(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__4d5346b37986c85ca586f8de228a10264d859971b34be199512c897daed62387)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "sourceSecurityType", value)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-nas.RosDataFlow.AutoRefreshsProperty",
jsii_struct_bases=[],
name_mapping={"refresh_path": "refreshPath"},
)
class AutoRefreshsProperty:
def __init__(
self,
*,
refresh_path: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
'''
:param refresh_path:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__d4e0677af98c37d7a598fe09b07d89bc6e1f470aeb2033a36ce2a9a33bde5d17)
check_type(argname="argument refresh_path", value=refresh_path, expected_type=type_hints["refresh_path"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"refresh_path": refresh_path,
}
@builtins.property
def refresh_path(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
refreshPath: Automatic update directory, data modification incident stored at the CPFS registration source end, check whether the source data in the directory is updated and automatically imported the updated data.
The default is empty. Any data update stored at the source will not automatically import the CPFS. You need to import and update through manual tasks.
limit:
The length is 2 to 1024 characters.
Use UTF-8 encoding.
It must start with a positive oblique line (/).
This directory must be existing directory on CPFS and must be located in the Fileset directory that flows in the data.
'''
result = self._values.get("refresh_path")
assert result is not None, "Required property 'refresh_path' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "AutoRefreshsProperty(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-nas.RosDataFlowProps",
jsii_struct_bases=[],
name_mapping={
"file_system_id": "fileSystemId",
"fset_id": "fsetId",
"source_storage": "sourceStorage",
"throughput": "throughput",
"auto_refresh_interval": "autoRefreshInterval",
"auto_refresh_policy": "autoRefreshPolicy",
"auto_refreshs": "autoRefreshs",
"description": "description",
"source_security_type": "sourceSecurityType",
},
)
class RosDataFlowProps:
def __init__(
self,
*,
file_system_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
fset_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
source_storage: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
throughput: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
auto_refresh_interval: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
auto_refresh_policy: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
auto_refreshs: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union[RosDataFlow.AutoRefreshsProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
description: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
source_security_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::NAS::DataFlow``.
:param file_system_id:
:param fset_id:
:param source_storage:
:param throughput:
:param auto_refresh_interval:
:param auto_refresh_policy:
:param auto_refreshs:
:param description:
:param source_security_type:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__3003cffe28660bb9388dcaf896e791ba8082dfd544c4fbedef9ef50c05575f55)
check_type(argname="argument file_system_id", value=file_system_id, expected_type=type_hints["file_system_id"])
check_type(argname="argument fset_id", value=fset_id, expected_type=type_hints["fset_id"])
check_type(argname="argument source_storage", value=source_storage, expected_type=type_hints["source_storage"])
check_type(argname="argument throughput", value=throughput, expected_type=type_hints["throughput"])
check_type(argname="argument auto_refresh_interval", value=auto_refresh_interval, expected_type=type_hints["auto_refresh_interval"])
check_type(argname="argument auto_refresh_policy", value=auto_refresh_policy, expected_type=type_hints["auto_refresh_policy"])
check_type(argname="argument auto_refreshs", value=auto_refreshs, expected_type=type_hints["auto_refreshs"])
check_type(argname="argument description", value=description, expected_type=type_hints["description"])
check_type(argname="argument source_security_type", value=source_security_type, expected_type=type_hints["source_security_type"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"file_system_id": file_system_id,
"fset_id": fset_id,
"source_storage": source_storage,
"throughput": throughput,
}
if auto_refresh_interval is not None:
self._values["auto_refresh_interval"] = auto_refresh_interval
if auto_refresh_policy is not None:
self._values["auto_refresh_policy"] = auto_refresh_policy
if auto_refreshs is not None:
self._values["auto_refreshs"] = auto_refreshs
if description is not None:
self._values["description"] = description
if source_security_type is not None:
self._values["source_security_type"] = source_security_type
@builtins.property
def file_system_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: fileSystemId: File system ID.
'''
result = self._values.get("file_system_id")
assert result is not None, "Required property 'file_system_id' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def fset_id(self) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: fsetId: Fileset ID.
'''
result = self._values.get("fset_id")
assert result is not None, "Required property 'fset_id' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def source_storage(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
sourceStorage: Access path stored at the source.Format: : // .
in:
Storage Type: Currently only supports OSS.
PATH: OSS's bucket name.Limit the following.
Only support the lowercase letters, numbers and short strokes (-) and must start with a lowercase letter or number.
The length is 8 ~ 128 English characters.
Use UTF-8 encoding.
Can't start with http: // and https: //.
Explain that the OSS BUCKET must be the bucket that exists in the region.
'''
result = self._values.get("source_storage")
assert result is not None, "Required property 'source_storage' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def throughput(
self,
) -> typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
throughput: The upper limit of transmission bandwidth for data flow, unit: MB/s.
Value:
600
1200
1500
Explanation The transmission bandwidth of the data flow must be smaller than the IO bandwidth of the file system.
'''
result = self._values.get("throughput")
assert result is not None, "Required property 'throughput' is missing"
return typing.cast(typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def auto_refresh_interval(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
autoRefreshInterval: The automatic update interval time, every time the interval, the CPFS checks whether there is a data update in the directory. If there is data update, start the automatic update task, unit: minute.
Scope of value: 5 ~ 525600, default value: 10.
'''
result = self._values.get("auto_refresh_interval")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def auto_refresh_policy(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
autoRefreshPolicy: Automatic update strategy, after the source data is updated, the data update is introduced to the CPFS strategy.
None (default): The data update of the source is not automatically imported into CPFS. Users can import data update at the source end of the source through data flow tasks.
Importchanged: The data update at the source automatically imports CPFS.
'''
result = self._values.get("auto_refresh_policy")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def auto_refreshs(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, RosDataFlow.AutoRefreshsProperty]]]]:
'''
:Property: autoRefreshs:
'''
result = self._values.get("auto_refreshs")
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, RosDataFlow.AutoRefreshsProperty]]]], result)
@builtins.property
def description(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
description: Description of data flow.
limit:
The length is 2 to 128 English or Chinese characters.
Start with a lowercase letter or Chinese, and you cannot start with http:// and https: //.
It can contain numbers, half-horn colon (:), down line (_) or short lines (-).
'''
result = self._values.get("description")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def source_security_type(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
sourceSecurityType: The type of safety protection types of the source storage. If the source storage must be protected through safety protection, please specify the type of safety protection type storage.Value:
No (default value): It means that the source storage does not need to be accessed by safe protection.
SSL: Protective access through SSL certificates.
'''
result = self._values.get("source_security_type")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "RosDataFlowProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class RosFileSystem(
_ros_cdk_core_7adfd82f.RosResource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-nas.RosFileSystem",
):
'''A ROS template type: ``ALIYUN::NAS::FileSystem``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["RosFileSystemProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
'''Create a new ``ALIYUN::NAS::FileSystem``.
:param scope: - scope in which this resource is defined.
:param id: - scoped id of the resource.
:param props: - resource properties.
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__3b618ca4066169ac4c43de01db915fe3acfb35495d4f913e2f9c4505da185adb)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@jsii.member(jsii_name="renderProperties")
def _render_properties(
self,
props: typing.Mapping[builtins.str, typing.Any],
) -> typing.Mapping[builtins.str, typing.Any]:
'''
:param props: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__6331cd590d51f5392a263500d440539ca7ce5e155b621832258560e912ce6523)
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))
@jsii.python.classproperty
@jsii.member(jsii_name="ROS_RESOURCE_TYPE_NAME")
def ROS_RESOURCE_TYPE_NAME(cls) -> builtins.str:
'''The resource type name for this resource class.'''
return typing.cast(builtins.str, jsii.sget(cls, "ROS_RESOURCE_TYPE_NAME"))
@builtins.property
@jsii.member(jsii_name="attrFileSystemId")
def attr_file_system_id(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: FileSystemId: ID of the file system created
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrFileSystemId"))
@builtins.property
@jsii.member(jsii_name="rosProperties")
def _ros_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "rosProperties"))
@builtins.property
@jsii.member(jsii_name="enableResourcePropertyConstraint")
def enable_resource_property_constraint(self) -> builtins.bool:
return typing.cast(builtins.bool, jsii.get(self, "enableResourcePropertyConstraint"))
@enable_resource_property_constraint.setter
def enable_resource_property_constraint(self, value: builtins.bool) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__491659fa974dcf8a9876b7ad0f4641e1ab52cef703b04ff77166a4c74546b475)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "enableResourcePropertyConstraint", value)
@builtins.property
@jsii.member(jsii_name="protocolType")
def protocol_type(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: protocolType: Type of protocol used. Valid values: NFS, SMB, cpfs.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "protocolType"))
@protocol_type.setter
def protocol_type(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__986fb8c0115ba9fa3cdb689c121ac0c81eacc8f5fd3ed65cdb0d18c7dea46957)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "protocolType", value)
@builtins.property
@jsii.member(jsii_name="storageType")
def storage_type(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
storageType: The storage type of the file System.
Valid values:
Performance、Capacity(Available when the file_system_type is standard)
standard、advance(Available when the file_system_type is extreme)
advance_100、advance_200(Available when the file_system_type is cpfs)
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "storageType"))
@storage_type.setter
def storage_type(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__079b90dc1c3e873a456e1d10b1a17901b9485925812f4d3dcea11f976663bd41)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "storageType", value)
@builtins.property
@jsii.member(jsii_name="bandwidth")
def bandwidth(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: bandwidth: Maximum file system throughput, unit is MB/s. Required and valid only when FileSystemType=cpfs.
'''
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "bandwidth"))
@bandwidth.setter
def bandwidth(
self,
value: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__acffeb47fb434a5da100ad39570bc5d470c4938aabf9f9b66690dd1f93ac43e0)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "bandwidth", value)
@builtins.property
@jsii.member(jsii_name="capacity")
def capacity(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: capacity: File system capacity, the unit is GB. Required and valid when FileSystemType=extreme or cpfs.
'''
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "capacity"))
@capacity.setter
def capacity(
self,
value: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__adefa2636c52a5fb546682ec9dbf959cc1a49ed51d2258a47021bdb9a6656139)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "capacity", value)
@builtins.property
@jsii.member(jsii_name="chargeType")
def charge_type(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
chargeType: Type of payment:
PayAsYouGo (pay as you go)
Subscription
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "chargeType"))
@charge_type.setter
def charge_type(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__3afa4ccea73d7e8644d9a82f6234960f6be627887ee5f75455a00f213dcc4b01)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "chargeType", value)
@builtins.property
@jsii.member(jsii_name="deletionForce")
def deletion_force(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: deletionForce: Whether delete all mount targets on the file system and then delete file system. Default is false
'''
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "deletionForce"))
@deletion_force.setter
def deletion_force(
self,
value: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__d9a3eb4a8dd889cc13fc33ea001c63869fbff90252bbf24a638accbabbc41b83)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "deletionForce", value)
@builtins.property
@jsii.member(jsii_name="description")
def description(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: description: File system description (space characters are not allowed)
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "description"))
@description.setter
def description(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__311911fbadef1a3e8d871675a924e86a3034e48dc5db94d0005fc0ce74f093cd)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "description", value)
@builtins.property
@jsii.member(jsii_name="duration")
def duration(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
duration: The period of subscription in months. Required and valid when ChargeType is Subscription.
When the annual and monthly subscription instance expires without renewal, the instance will automatically expire and be released.
'''
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "duration"))
@duration.setter
def duration(
self,
value: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__8898fabcadd84f065f2c2de27986ffbefa5c0e6816249c0bea79947bd06234f2)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "duration", value)
@builtins.property
@jsii.member(jsii_name="encryptType")
def encrypt_type(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
encryptType: Specifies whether to encrypt data. You can use keys that are hosted by Key Management Service (KMS) to encrypt data stored on a file system. Data is automatically decrypted when you access encrypted data. Valid values:
0: specifies that no encryption is applied to data on the file system.
1: specifies that encryption is applied to data on the file system.
'''
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "encryptType"))
@encrypt_type.setter
def encrypt_type(
self,
value: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__375a0a1c36f743eb876e70d21c48c26300326839559ce27c03d7241f4e83ecc8)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "encryptType", value)
@builtins.property
@jsii.member(jsii_name="fileSystemType")
def file_system_type(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: fileSystemType: File system type. Allowed values: standard(default), extreme, cpfs
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "fileSystemType"))
@file_system_type.setter
def file_system_type(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__f25766e5a3e80cb75ddedd7e5fb5052a6db839e86151289740b15644d0eeed0d)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "fileSystemType", value)
@builtins.property
@jsii.member(jsii_name="snapshotId")
def snapshot_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: snapshotId: Snapshot ID.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "snapshotId"))
@snapshot_id.setter
def snapshot_id(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__f8f56a7407cebef62811cf4cfaa5954ef8b80c008bfb7e2533b3623b158a8374)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "snapshotId", value)
@builtins.property
@jsii.member(jsii_name="tags")
def tags(self) -> typing.Optional[typing.List["RosFileSystem.TagsProperty"]]:
'''
:Property: tags: Tags to attach to filesystem. Max support 20 tags to add during create filesystem. Each tag with two properties Key and Value, and Key is required.
'''
return typing.cast(typing.Optional[typing.List["RosFileSystem.TagsProperty"]], jsii.get(self, "tags"))
@tags.setter
def tags(
self,
value: typing.Optional[typing.List["RosFileSystem.TagsProperty"]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__d68fcebb4464351798b50f8fff31aeaf57b93373be3fd4b10b7e548aead029a7)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "tags", value)
@builtins.property
@jsii.member(jsii_name="vpcId")
def vpc_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: vpcId: Vpc ID.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "vpcId"))
@vpc_id.setter
def vpc_id(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__4e31c7764e731169d4c0c4f713e70587525f88df97cb2be7eb2ae7038b1508e3)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "vpcId", value)
@builtins.property
@jsii.member(jsii_name="vSwitchId")
def v_switch_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: vSwitchId: VSwitch ID.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "vSwitchId"))
@v_switch_id.setter
def v_switch_id(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__fa65219beeec7e8e60ef1f7903c41cc31a36cb5a610531d98ab298a267399c5b)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "vSwitchId", value)
@builtins.property
@jsii.member(jsii_name="zoneId")
def zone_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: zoneId: Zone ID.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "zoneId"))
@zone_id.setter
def zone_id(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__a100f82d73a735a0a2baacb79fe8304b52cd8fa91a4b14893364a5c5cf13b7dc)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "zoneId", value)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-nas.RosFileSystem.TagsProperty",
jsii_struct_bases=[],
name_mapping={"key": "key", "value": "value"},
)
class TagsProperty:
def __init__(
self,
*,
key: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''
:param key:
:param value:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__e81fe819d38816de57f81e94c8fb72af74e798fc88b2c5308bac62522317e6b8)
check_type(argname="argument key", value=key, expected_type=type_hints["key"])
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"key": key,
}
if value is not None:
self._values["value"] = value
@builtins.property
def key(self) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: key: undefined
'''
result = self._values.get("key")
assert result is not None, "Required property 'key' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def value(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: value: undefined
'''
result = self._values.get("value")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "TagsProperty(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-nas.RosFileSystemProps",
jsii_struct_bases=[],
name_mapping={
"protocol_type": "protocolType",
"storage_type": "storageType",
"bandwidth": "bandwidth",
"capacity": "capacity",
"charge_type": "chargeType",
"deletion_force": "deletionForce",
"description": "description",
"duration": "duration",
"encrypt_type": "encryptType",
"file_system_type": "fileSystemType",
"snapshot_id": "snapshotId",
"tags": "tags",
"vpc_id": "vpcId",
"v_switch_id": "vSwitchId",
"zone_id": "zoneId",
},
)
class RosFileSystemProps:
def __init__(
self,
*,
protocol_type: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
storage_type: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
bandwidth: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
capacity: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
charge_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
deletion_force: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
description: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
duration: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
encrypt_type: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
file_system_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
snapshot_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
tags: typing.Optional[typing.Sequence[typing.Union[RosFileSystem.TagsProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
vpc_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
v_switch_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
zone_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::NAS::FileSystem``.
:param protocol_type:
:param storage_type:
:param bandwidth:
:param capacity:
:param charge_type:
:param deletion_force:
:param description:
:param duration:
:param encrypt_type:
:param file_system_type:
:param snapshot_id:
:param tags:
:param vpc_id:
:param v_switch_id:
:param zone_id:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__ca3e192edc6072b9caac2c98038a213c68ab41d46815cf1d4ce5e5cfaba61425)
check_type(argname="argument protocol_type", value=protocol_type, expected_type=type_hints["protocol_type"])
check_type(argname="argument storage_type", value=storage_type, expected_type=type_hints["storage_type"])
check_type(argname="argument bandwidth", value=bandwidth, expected_type=type_hints["bandwidth"])
check_type(argname="argument capacity", value=capacity, expected_type=type_hints["capacity"])
check_type(argname="argument charge_type", value=charge_type, expected_type=type_hints["charge_type"])
check_type(argname="argument deletion_force", value=deletion_force, expected_type=type_hints["deletion_force"])
check_type(argname="argument description", value=description, expected_type=type_hints["description"])
check_type(argname="argument duration", value=duration, expected_type=type_hints["duration"])
check_type(argname="argument encrypt_type", value=encrypt_type, expected_type=type_hints["encrypt_type"])
check_type(argname="argument file_system_type", value=file_system_type, expected_type=type_hints["file_system_type"])
check_type(argname="argument snapshot_id", value=snapshot_id, expected_type=type_hints["snapshot_id"])
check_type(argname="argument tags", value=tags, expected_type=type_hints["tags"])
check_type(argname="argument vpc_id", value=vpc_id, expected_type=type_hints["vpc_id"])
check_type(argname="argument v_switch_id", value=v_switch_id, expected_type=type_hints["v_switch_id"])
check_type(argname="argument zone_id", value=zone_id, expected_type=type_hints["zone_id"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"protocol_type": protocol_type,
"storage_type": storage_type,
}
if bandwidth is not None:
self._values["bandwidth"] = bandwidth
if capacity is not None:
self._values["capacity"] = capacity
if charge_type is not None:
self._values["charge_type"] = charge_type
if deletion_force is not None:
self._values["deletion_force"] = deletion_force
if description is not None:
self._values["description"] = description
if duration is not None:
self._values["duration"] = duration
if encrypt_type is not None:
self._values["encrypt_type"] = encrypt_type
if file_system_type is not None:
self._values["file_system_type"] = file_system_type
if snapshot_id is not None:
self._values["snapshot_id"] = snapshot_id
if tags is not None:
self._values["tags"] = tags
if vpc_id is not None:
self._values["vpc_id"] = vpc_id
if v_switch_id is not None:
self._values["v_switch_id"] = v_switch_id
if zone_id is not None:
self._values["zone_id"] = zone_id
@builtins.property
def protocol_type(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: protocolType: Type of protocol used. Valid values: NFS, SMB, cpfs.
'''
result = self._values.get("protocol_type")
assert result is not None, "Required property 'protocol_type' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def storage_type(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
storageType: The storage type of the file System.
Valid values:
Performance、Capacity(Available when the file_system_type is standard)
standard、advance(Available when the file_system_type is extreme)
advance_100、advance_200(Available when the file_system_type is cpfs)
'''
result = self._values.get("storage_type")
assert result is not None, "Required property 'storage_type' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def bandwidth(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: bandwidth: Maximum file system throughput, unit is MB/s. Required and valid only when FileSystemType=cpfs.
'''
result = self._values.get("bandwidth")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def capacity(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: capacity: File system capacity, the unit is GB. Required and valid when FileSystemType=extreme or cpfs.
'''
result = self._values.get("capacity")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def charge_type(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
chargeType: Type of payment:
PayAsYouGo (pay as you go)
Subscription
'''
result = self._values.get("charge_type")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def deletion_force(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: deletionForce: Whether delete all mount targets on the file system and then delete file system. Default is false
'''
result = self._values.get("deletion_force")
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def description(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: description: File system description (space characters are not allowed)
'''
result = self._values.get("description")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def duration(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
duration: The period of subscription in months. Required and valid when ChargeType is Subscription.
When the annual and monthly subscription instance expires without renewal, the instance will automatically expire and be released.
'''
result = self._values.get("duration")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def encrypt_type(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
encryptType: Specifies whether to encrypt data. You can use keys that are hosted by Key Management Service (KMS) to encrypt data stored on a file system. Data is automatically decrypted when you access encrypted data. Valid values:
0: specifies that no encryption is applied to data on the file system.
1: specifies that encryption is applied to data on the file system.
'''
result = self._values.get("encrypt_type")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def file_system_type(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: fileSystemType: File system type. Allowed values: standard(default), extreme, cpfs
'''
result = self._values.get("file_system_type")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def snapshot_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: snapshotId: Snapshot ID.
'''
result = self._values.get("snapshot_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def tags(self) -> typing.Optional[typing.List[RosFileSystem.TagsProperty]]:
'''
:Property: tags: Tags to attach to filesystem. Max support 20 tags to add during create filesystem. Each tag with two properties Key and Value, and Key is required.
'''
result = self._values.get("tags")
return typing.cast(typing.Optional[typing.List[RosFileSystem.TagsProperty]], result)
@builtins.property
def vpc_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: vpcId: Vpc ID.
'''
result = self._values.get("vpc_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def v_switch_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: vSwitchId: VSwitch ID.
'''
result = self._values.get("v_switch_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def zone_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: zoneId: Zone ID.
'''
result = self._values.get("zone_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "RosFileSystemProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class RosFileset(
_ros_cdk_core_7adfd82f.RosResource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-nas.RosFileset",
):
'''A ROS template type: ``ALIYUN::NAS::Fileset``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["RosFilesetProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
'''Create a new ``ALIYUN::NAS::Fileset``.
:param scope: - scope in which this resource is defined.
:param id: - scoped id of the resource.
:param props: - resource properties.
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__6c7c1a8d4c8feb5bbc5fec4db83194243a06c9882e12dbd796fe469e58b70e63)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@jsii.member(jsii_name="renderProperties")
def _render_properties(
self,
props: typing.Mapping[builtins.str, typing.Any],
) -> typing.Mapping[builtins.str, typing.Any]:
'''
:param props: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__d2e1eb4ee8d8162a7a1c812e9d514c2b27a447cfda1cbcdfae453bc6c07bb44c)
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))
@jsii.python.classproperty
@jsii.member(jsii_name="ROS_RESOURCE_TYPE_NAME")
def ROS_RESOURCE_TYPE_NAME(cls) -> builtins.str:
'''The resource type name for this resource class.'''
return typing.cast(builtins.str, jsii.sget(cls, "ROS_RESOURCE_TYPE_NAME"))
@builtins.property
@jsii.member(jsii_name="attrFileSystemId")
def attr_file_system_id(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: FileSystemId: File system ID.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrFileSystemId"))
@builtins.property
@jsii.member(jsii_name="attrFileSystemPath")
def attr_file_system_path(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: FileSystemPath: File system path.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrFileSystemPath"))
@builtins.property
@jsii.member(jsii_name="attrFsetId")
def attr_fset_id(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: FsetId: Fileset ID.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrFsetId"))
@builtins.property
@jsii.member(jsii_name="rosProperties")
def _ros_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "rosProperties"))
@builtins.property
@jsii.member(jsii_name="enableResourcePropertyConstraint")
def enable_resource_property_constraint(self) -> builtins.bool:
return typing.cast(builtins.bool, jsii.get(self, "enableResourcePropertyConstraint"))
@enable_resource_property_constraint.setter
def enable_resource_property_constraint(self, value: builtins.bool) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__a9983841a76737ec72af797a6350d987c6f640c1414b32dbebdf0864bf977485)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "enableResourcePropertyConstraint", value)
@builtins.property
@jsii.member(jsii_name="fileSystemId")
def file_system_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: fileSystemId: File system ID.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "fileSystemId"))
@file_system_id.setter
def file_system_id(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__28e4127e37a1d559225470dcae2f08977f76bc9dacd04269ff9c1bd15f44a25c)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "fileSystemId", value)
@builtins.property
@jsii.member(jsii_name="fileSystemPath")
def file_system_path(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
fileSystemPath: The absolute path of Fileset to be created.
The parent catalog of specified the directory must be a directory in the file system.
The length is 2 to 1024 characters.
Specify the directory must start with positive (/).
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "fileSystemPath"))
@file_system_path.setter
def file_system_path(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__c7be1441ea70f9f9e4475ea7ce7c68552d796d480800d07c0f8cf8ca188de0a7)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "fileSystemPath", value)
@builtins.property
@jsii.member(jsii_name="description")
def description(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
description: Fileset description information.
The length is 2 to 128 English or Chinese characters.
Start with a lowercase letter or Chinese, and you cannot start with http:// and https: //.
It can contain numbers, half-horn colon (:), down line (_) or short lines (-).
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "description"))
@description.setter
def description(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__1dbe557df307980974e51809d20b5028af3e1df92e717ba74f3473589716e226)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "description", value)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-nas.RosFilesetProps",
jsii_struct_bases=[],
name_mapping={
"file_system_id": "fileSystemId",
"file_system_path": "fileSystemPath",
"description": "description",
},
)
class RosFilesetProps:
def __init__(
self,
*,
file_system_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
file_system_path: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
description: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::NAS::Fileset``.
:param file_system_id:
:param file_system_path:
:param description:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__e66afd6f275baaa041b5d45940936d8dc4e8b2b85ea480f96e215070d874669e)
check_type(argname="argument file_system_id", value=file_system_id, expected_type=type_hints["file_system_id"])
check_type(argname="argument file_system_path", value=file_system_path, expected_type=type_hints["file_system_path"])
check_type(argname="argument description", value=description, expected_type=type_hints["description"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"file_system_id": file_system_id,
"file_system_path": file_system_path,
}
if description is not None:
self._values["description"] = description
@builtins.property
def file_system_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: fileSystemId: File system ID.
'''
result = self._values.get("file_system_id")
assert result is not None, "Required property 'file_system_id' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def file_system_path(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
fileSystemPath: The absolute path of Fileset to be created.
The parent catalog of specified the directory must be a directory in the file system.
The length is 2 to 1024 characters.
Specify the directory must start with positive (/).
'''
result = self._values.get("file_system_path")
assert result is not None, "Required property 'file_system_path' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def description(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
description: Fileset description information.
The length is 2 to 128 English or Chinese characters.
Start with a lowercase letter or Chinese, and you cannot start with http:// and https: //.
It can contain numbers, half-horn colon (:), down line (_) or short lines (-).
'''
result = self._values.get("description")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "RosFilesetProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class RosMountTarget(
_ros_cdk_core_7adfd82f.RosResource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-nas.RosMountTarget",
):
'''A ROS template type: ``ALIYUN::NAS::MountTarget``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["RosMountTargetProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
'''Create a new ``ALIYUN::NAS::MountTarget``.
:param scope: - scope in which this resource is defined.
:param id: - scoped id of the resource.
:param props: - resource properties.
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__fbaa6948b82b45f72b3219341c207fb7b5d2dad32e911f456ccd123c22b30d4d)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@jsii.member(jsii_name="renderProperties")
def _render_properties(
self,
props: typing.Mapping[builtins.str, typing.Any],
) -> typing.Mapping[builtins.str, typing.Any]:
'''
:param props: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__b4b91938a2fff6d4815d4dc973571dd0e7dfa0f4562f0ef51a1d6f52d91b6a63)
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))
@jsii.python.classproperty
@jsii.member(jsii_name="ROS_RESOURCE_TYPE_NAME")
def ROS_RESOURCE_TYPE_NAME(cls) -> builtins.str:
'''The resource type name for this resource class.'''
return typing.cast(builtins.str, jsii.sget(cls, "ROS_RESOURCE_TYPE_NAME"))
@builtins.property
@jsii.member(jsii_name="attrMountTargetDomain")
def attr_mount_target_domain(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: MountTargetDomain: Mount point domain name
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrMountTargetDomain"))
@builtins.property
@jsii.member(jsii_name="rosProperties")
def _ros_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "rosProperties"))
@builtins.property
@jsii.member(jsii_name="accessGroupName")
def access_group_name(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: accessGroupName: Permission group name. Default to DEFAULT_VPC_GROUP_NAME.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "accessGroupName"))
@access_group_name.setter
def access_group_name(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__4c2d0334c66c9c90b6cc03b0ca5aa26505c7dae7407e4f2a5cfaca712caa1b17)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "accessGroupName", value)
@builtins.property
@jsii.member(jsii_name="enableResourcePropertyConstraint")
def enable_resource_property_constraint(self) -> builtins.bool:
return typing.cast(builtins.bool, jsii.get(self, "enableResourcePropertyConstraint"))
@enable_resource_property_constraint.setter
def enable_resource_property_constraint(self, value: builtins.bool) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__9543207777664059608ba9680f052fd58302a7c8879c2a2e44b5ed5bae6ea9dd)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "enableResourcePropertyConstraint", value)
@builtins.property
@jsii.member(jsii_name="fileSystemId")
def file_system_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: fileSystemId: File system ID
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "fileSystemId"))
@file_system_id.setter
def file_system_id(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__345141c8132d575b934196721039ea9073feda9fe8e43f1fe0d45ca7a25fb449)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "fileSystemId", value)
@builtins.property
@jsii.member(jsii_name="networkType")
def network_type(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: networkType: Network type, including Vpc and Classic networks.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "networkType"))
@network_type.setter
def network_type(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__c44f535881b857f02efe1e7dc2af2ade5b0689d87b163f22adcc1e8e30fd75f7)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "networkType", value)
@builtins.property
@jsii.member(jsii_name="enableIpv6")
def enable_ipv6(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
enableIpv6: Whether to create an IPv6 mount point.Value:
true: create
false (default): do not create
Note Currently, only the ultra-fast NAS in mainland China supports the IPv6 function, and the file system needs to enable the IPv6 function.
'''
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "enableIpv6"))
@enable_ipv6.setter
def enable_ipv6(
self,
value: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__37b834f9a450b53b5421d5d58c0e8db3764a54caf9d1e0a6c9135825ba3bd0a5)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "enableIpv6", value)
@builtins.property
@jsii.member(jsii_name="securityGroupId")
def security_group_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: securityGroupId: Security group Id
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "securityGroupId"))
@security_group_id.setter
def security_group_id(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__c0a043f8b53444874359daa03208d36c265885f4bca09fd8a82fe534cc2b39b2)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "securityGroupId", value)
@builtins.property
@jsii.member(jsii_name="status")
def status(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: status: Status, including Active and Inactive
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "status"))
@status.setter
def status(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__fdc45d0bb32ef343c1fa43c8f27e41a7b12c8b3bf2f0184ea7b1b0cbc013bde0)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "status", value)
@builtins.property
@jsii.member(jsii_name="vpcId")
def vpc_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: vpcId: VPC network ID
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "vpcId"))
@vpc_id.setter
def vpc_id(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__1389b1b8e879e36caa6ded984bf3cbca407845e55edeac4028dc85911132a2e4)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "vpcId", value)
@builtins.property
@jsii.member(jsii_name="vSwitchId")
def v_switch_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: vSwitchId: VSwitch ID.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "vSwitchId"))
@v_switch_id.setter
def v_switch_id(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__553b75b354f1fbfe41ebaa38a9daeea0815c4cd349005f846f293fbccf6e7307)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "vSwitchId", value)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-nas.RosMountTargetProps",
jsii_struct_bases=[],
name_mapping={
"access_group_name": "accessGroupName",
"file_system_id": "fileSystemId",
"network_type": "networkType",
"enable_ipv6": "enableIpv6",
"security_group_id": "securityGroupId",
"status": "status",
"vpc_id": "vpcId",
"v_switch_id": "vSwitchId",
},
)
class RosMountTargetProps:
def __init__(
self,
*,
access_group_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
file_system_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
network_type: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
enable_ipv6: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
security_group_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
status: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
vpc_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
v_switch_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::NAS::MountTarget``.
:param access_group_name:
:param file_system_id:
:param network_type:
:param enable_ipv6:
:param security_group_id:
:param status:
:param vpc_id:
:param v_switch_id:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__8e50d045eea2d7b9dd1a6c2ecc7d6d9a43201226bb2dac2bf10a55d3d81a5ce0)
check_type(argname="argument access_group_name", value=access_group_name, expected_type=type_hints["access_group_name"])
check_type(argname="argument file_system_id", value=file_system_id, expected_type=type_hints["file_system_id"])
check_type(argname="argument network_type", value=network_type, expected_type=type_hints["network_type"])
check_type(argname="argument enable_ipv6", value=enable_ipv6, expected_type=type_hints["enable_ipv6"])
check_type(argname="argument security_group_id", value=security_group_id, expected_type=type_hints["security_group_id"])
check_type(argname="argument status", value=status, expected_type=type_hints["status"])
check_type(argname="argument vpc_id", value=vpc_id, expected_type=type_hints["vpc_id"])
check_type(argname="argument v_switch_id", value=v_switch_id, expected_type=type_hints["v_switch_id"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"access_group_name": access_group_name,
"file_system_id": file_system_id,
"network_type": network_type,
}
if enable_ipv6 is not None:
self._values["enable_ipv6"] = enable_ipv6
if security_group_id is not None:
self._values["security_group_id"] = security_group_id
if status is not None:
self._values["status"] = status
if vpc_id is not None:
self._values["vpc_id"] = vpc_id
if v_switch_id is not None:
self._values["v_switch_id"] = v_switch_id
@builtins.property
def access_group_name(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: accessGroupName: Permission group name. Default to DEFAULT_VPC_GROUP_NAME.
'''
result = self._values.get("access_group_name")
assert result is not None, "Required property 'access_group_name' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def file_system_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: fileSystemId: File system ID
'''
result = self._values.get("file_system_id")
assert result is not None, "Required property 'file_system_id' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def network_type(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: networkType: Network type, including Vpc and Classic networks.
'''
result = self._values.get("network_type")
assert result is not None, "Required property 'network_type' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def enable_ipv6(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
enableIpv6: Whether to create an IPv6 mount point.Value:
true: create
false (default): do not create
Note Currently, only the ultra-fast NAS in mainland China supports the IPv6 function, and the file system needs to enable the IPv6 function.
'''
result = self._values.get("enable_ipv6")
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def security_group_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: securityGroupId: Security group Id
'''
result = self._values.get("security_group_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def status(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: status: Status, including Active and Inactive
'''
result = self._values.get("status")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def vpc_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: vpcId: VPC network ID
'''
result = self._values.get("vpc_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def v_switch_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: vSwitchId: VSwitch ID.
'''
result = self._values.get("v_switch_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "RosMountTargetProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class RosProtocolMountTarget(
_ros_cdk_core_7adfd82f.RosResource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-nas.RosProtocolMountTarget",
):
'''A ROS template type: ``ALIYUN::NAS::ProtocolMountTarget``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["RosProtocolMountTargetProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
'''Create a new ``ALIYUN::NAS::ProtocolMountTarget``.
:param scope: - scope in which this resource is defined.
:param id: - scoped id of the resource.
:param props: - resource properties.
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__7181588ce75cc65cf406ca327697d88fa8368a539a5578d79169360c8e665b45)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@jsii.member(jsii_name="renderProperties")
def _render_properties(
self,
props: typing.Mapping[builtins.str, typing.Any],
) -> typing.Mapping[builtins.str, typing.Any]:
'''
:param props: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__bb399a5ca06f618f627ac24a1ff0ff779c229d9d6176e933cc94d807dbe49830)
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))
@jsii.python.classproperty
@jsii.member(jsii_name="ROS_RESOURCE_TYPE_NAME")
def ROS_RESOURCE_TYPE_NAME(cls) -> builtins.str:
'''The resource type name for this resource class.'''
return typing.cast(builtins.str, jsii.sget(cls, "ROS_RESOURCE_TYPE_NAME"))
@builtins.property
@jsii.member(jsii_name="attrExportId")
def attr_export_id(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: ExportId: The protocol service exports directory ID.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrExportId"))
@builtins.property
@jsii.member(jsii_name="attrFileSystemId")
def attr_file_system_id(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: FileSystemId: File system ID.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrFileSystemId"))
@builtins.property
@jsii.member(jsii_name="attrProtocolMountTargetDomain")
def attr_protocol_mount_target_domain(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: ProtocolMountTargetDomain: The protocol mount target domain.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrProtocolMountTargetDomain"))
@builtins.property
@jsii.member(jsii_name="attrProtocolServiceId")
def attr_protocol_service_id(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: ProtocolServiceId: Protocol service ID.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrProtocolServiceId"))
@builtins.property
@jsii.member(jsii_name="rosProperties")
def _ros_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "rosProperties"))
@builtins.property
@jsii.member(jsii_name="enableResourcePropertyConstraint")
def enable_resource_property_constraint(self) -> builtins.bool:
return typing.cast(builtins.bool, jsii.get(self, "enableResourcePropertyConstraint"))
@enable_resource_property_constraint.setter
def enable_resource_property_constraint(self, value: builtins.bool) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__0e7ec81276d0ff5cb72f2254a7ede164e8bcd3bf1a6457e5b5c1433b46ad72f5)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "enableResourcePropertyConstraint", value)
@builtins.property
@jsii.member(jsii_name="fileSystemId")
def file_system_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: fileSystemId: File system ID.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "fileSystemId"))
@file_system_id.setter
def file_system_id(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__be14e0a0178e89b4d1d61c6e7059f0d39329e8efe0e2465d774388b8a77f4ecb)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "fileSystemId", value)
@builtins.property
@jsii.member(jsii_name="protocolServiceId")
def protocol_service_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: protocolServiceId: Agreement service ID.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "protocolServiceId"))
@protocol_service_id.setter
def protocol_service_id(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__1952a48f767f19de886389c10228d801cc201bcfc53a83c34c0dca19635fe3f4)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "protocolServiceId", value)
@builtins.property
@jsii.member(jsii_name="vpcId")
def vpc_id(self) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: vpcId: Proper network ID exported by the protocol service.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "vpcId"))
@vpc_id.setter
def vpc_id(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__598cf922a243c1fb57304c5727156ddee9e093f0dde5c96cfef60412a6bd3d7a)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "vpcId", value)
@builtins.property
@jsii.member(jsii_name="vSwitchId")
def v_switch_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: vSwitchId: Switch ID exported by the protocol service.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "vSwitchId"))
@v_switch_id.setter
def v_switch_id(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__04db921f49b9482adfecce2b478bbfc2a9d67711f06d99ac5feaf1274a711e05)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "vSwitchId", value)
@builtins.property
@jsii.member(jsii_name="accessGroupName")
def access_group_name(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
accessGroupName: The name of the permissions group.
Default value: DEFAULT_VPC_GROUP_NAME
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "accessGroupName"))
@access_group_name.setter
def access_group_name(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__27481f4a06f871e0b9853ea07e7448c5c6f8617a78eaec1de5713f2dc2103cfe)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "accessGroupName", value)
@builtins.property
@jsii.member(jsii_name="description")
def description(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
description: Description of the protocol service to export the directory.The console is displayed as the export directory name.
limit:
The length is 2 to 128 English or Chinese characters.
Start with a lowercase letter or Chinese, and you cannot start with http:// and https: //.
It can contain numbers, half-horn colon (:), down line (_) or short lines (-).
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "description"))
@description.setter
def description(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__3bbb4bb2289fd51031c1d4ce9906ed5865000b03975fa67872f02cfd6b20b694)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "description", value)
@builtins.property
@jsii.member(jsii_name="fsetId")
def fset_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
fsetId: Fileset ID needs to be exported.
limit:
The Fileset must exist.
A Fileset allows only one export directory.
Fileset and Path can only specify one.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "fsetId"))
@fset_id.setter
def fset_id(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__f9f79402278391f41c4c25db8037b7cfad436808f9d02ffae2ab1d788a6be531)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "fsetId", value)
@builtins.property
@jsii.member(jsii_name="path")
def path(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
path: The path of the CPFS directory that needs to be exported.
limit:
This directory must be existing directory on CPFS.
The same directory allows only one export.
Fileset and Path can only specify one.
Format:
The length is 1 to 1024 characters.
Use UTF-8 encoding.
It must start with the positive oblique line (/), and the root directory must be/.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "path"))
@path.setter
def path(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__bd7bbfd70af43b96f5ebcb46b3ce6cd5f8ff7e2b1a31f5e096b4aabd1072e076)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "path", value)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-nas.RosProtocolMountTargetProps",
jsii_struct_bases=[],
name_mapping={
"file_system_id": "fileSystemId",
"protocol_service_id": "protocolServiceId",
"vpc_id": "vpcId",
"v_switch_id": "vSwitchId",
"access_group_name": "accessGroupName",
"description": "description",
"fset_id": "fsetId",
"path": "path",
},
)
class RosProtocolMountTargetProps:
def __init__(
self,
*,
file_system_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
protocol_service_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
vpc_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
v_switch_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
access_group_name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
description: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
fset_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
path: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::NAS::ProtocolMountTarget``.
:param file_system_id:
:param protocol_service_id:
:param vpc_id:
:param v_switch_id:
:param access_group_name:
:param description:
:param fset_id:
:param path:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__27cb04cb342c4092c8293caf1a2b5904927de7e107334df5c62a920f2f70b7c8)
check_type(argname="argument file_system_id", value=file_system_id, expected_type=type_hints["file_system_id"])
check_type(argname="argument protocol_service_id", value=protocol_service_id, expected_type=type_hints["protocol_service_id"])
check_type(argname="argument vpc_id", value=vpc_id, expected_type=type_hints["vpc_id"])
check_type(argname="argument v_switch_id", value=v_switch_id, expected_type=type_hints["v_switch_id"])
check_type(argname="argument access_group_name", value=access_group_name, expected_type=type_hints["access_group_name"])
check_type(argname="argument description", value=description, expected_type=type_hints["description"])
check_type(argname="argument fset_id", value=fset_id, expected_type=type_hints["fset_id"])
check_type(argname="argument path", value=path, expected_type=type_hints["path"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"file_system_id": file_system_id,
"protocol_service_id": protocol_service_id,
"vpc_id": vpc_id,
"v_switch_id": v_switch_id,
}
if access_group_name is not None:
self._values["access_group_name"] = access_group_name
if description is not None:
self._values["description"] = description
if fset_id is not None:
self._values["fset_id"] = fset_id
if path is not None:
self._values["path"] = path
@builtins.property
def file_system_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: fileSystemId: File system ID.
'''
result = self._values.get("file_system_id")
assert result is not None, "Required property 'file_system_id' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def protocol_service_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: protocolServiceId: Agreement service ID.
'''
result = self._values.get("protocol_service_id")
assert result is not None, "Required property 'protocol_service_id' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def vpc_id(self) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: vpcId: Proper network ID exported by the protocol service.
'''
result = self._values.get("vpc_id")
assert result is not None, "Required property 'vpc_id' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def v_switch_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: vSwitchId: Switch ID exported by the protocol service.
'''
result = self._values.get("v_switch_id")
assert result is not None, "Required property 'v_switch_id' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def access_group_name(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
accessGroupName: The name of the permissions group.
Default value: DEFAULT_VPC_GROUP_NAME
'''
result = self._values.get("access_group_name")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def description(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
description: Description of the protocol service to export the directory.The console is displayed as the export directory name.
limit:
The length is 2 to 128 English or Chinese characters.
Start with a lowercase letter or Chinese, and you cannot start with http:// and https: //.
It can contain numbers, half-horn colon (:), down line (_) or short lines (-).
'''
result = self._values.get("description")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def fset_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
fsetId: Fileset ID needs to be exported.
limit:
The Fileset must exist.
A Fileset allows only one export directory.
Fileset and Path can only specify one.
'''
result = self._values.get("fset_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def path(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
path: The path of the CPFS directory that needs to be exported.
limit:
This directory must be existing directory on CPFS.
The same directory allows only one export.
Fileset and Path can only specify one.
Format:
The length is 1 to 1024 characters.
Use UTF-8 encoding.
It must start with the positive oblique line (/), and the root directory must be/.
'''
result = self._values.get("path")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "RosProtocolMountTargetProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class RosProtocolService(
_ros_cdk_core_7adfd82f.RosResource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-nas.RosProtocolService",
):
'''A ROS template type: ``ALIYUN::NAS::ProtocolService``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["RosProtocolServiceProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
'''Create a new ``ALIYUN::NAS::ProtocolService``.
:param scope: - scope in which this resource is defined.
:param id: - scoped id of the resource.
:param props: - resource properties.
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__359612e2039931811df30746c74c850b1e19b68b10d27c4a9136c9f6106f06c2)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@jsii.member(jsii_name="renderProperties")
def _render_properties(
self,
props: typing.Mapping[builtins.str, typing.Any],
) -> typing.Mapping[builtins.str, typing.Any]:
'''
:param props: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__e0754340e0cc98a561e71f1f32705a6162e5f041ea29da865ea33e1190289c05)
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))
@jsii.python.classproperty
@jsii.member(jsii_name="ROS_RESOURCE_TYPE_NAME")
def ROS_RESOURCE_TYPE_NAME(cls) -> builtins.str:
'''The resource type name for this resource class.'''
return typing.cast(builtins.str, jsii.sget(cls, "ROS_RESOURCE_TYPE_NAME"))
@builtins.property
@jsii.member(jsii_name="attrFileSystemId")
def attr_file_system_id(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: FileSystemId: File system ID.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrFileSystemId"))
@builtins.property
@jsii.member(jsii_name="attrProtocolServiceId")
def attr_protocol_service_id(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: ProtocolServiceId: Agreement cluster group ID.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrProtocolServiceId"))
@builtins.property
@jsii.member(jsii_name="rosProperties")
def _ros_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "rosProperties"))
@builtins.property
@jsii.member(jsii_name="enableResourcePropertyConstraint")
def enable_resource_property_constraint(self) -> builtins.bool:
return typing.cast(builtins.bool, jsii.get(self, "enableResourcePropertyConstraint"))
@enable_resource_property_constraint.setter
def enable_resource_property_constraint(self, value: builtins.bool) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__ccc4298a2d30acea3d72c264fc6bf93deffb29f85453c6a9ed02d35c03320f89)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "enableResourcePropertyConstraint", value)
@builtins.property
@jsii.member(jsii_name="fileSystemId")
def file_system_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: fileSystemId: File system ID.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "fileSystemId"))
@file_system_id.setter
def file_system_id(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__9aeee1f203323389fb7dc0a999fb841332e45548fc24932dddf22ec5bb04bcd1)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "fileSystemId", value)
@builtins.property
@jsii.member(jsii_name="protocolSpec")
def protocol_spec(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: protocolSpec: The spec of protocol service. Default: General. Values: General
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "protocolSpec"))
@protocol_spec.setter
def protocol_spec(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__2bd76c4d305655e4f93f3dfe92c522e0b83c0538c5cbac6c2baa4428ce559cc6)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "protocolSpec", value)
@builtins.property
@jsii.member(jsii_name="protocolType")
def protocol_type(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
protocolType: The protocol type of agreement service.
Ranges:
NFS: Agreement service supports NFS protocol access.
The default value: NFS.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "protocolType"))
@protocol_type.setter
def protocol_type(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__9fcfddb805a743d9fed5fcc0109b0c51cdb3dc79829d857295e727282a479237)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "protocolType", value)
@builtins.property
@jsii.member(jsii_name="vpcId")
def vpc_id(self) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: vpcId: The protocol service VPCID needs to be consistent with the file system VPC.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "vpcId"))
@vpc_id.setter
def vpc_id(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__215519c0e1f29bbc3265aa826754c3a9dbf673abdc8f930bbe8640b4e283cc92)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "vpcId", value)
@builtins.property
@jsii.member(jsii_name="vSwitchId")
def v_switch_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: vSwitchId: Agreement service vswitchid.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "vSwitchId"))
@v_switch_id.setter
def v_switch_id(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__1f01965448725c7fc785e80ca1ddca654959a26ef8f37b0c242e6a376d116840)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "vSwitchId", value)
@builtins.property
@jsii.member(jsii_name="description")
def description(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
description: Description of protocol service.The console shows the "protocol service name".
limit:
The length is 2 to 128 English or Chinese characters.
Start with a lowercase letter or Chinese, and you cannot start with http:// and https: //.
It can contain numbers, half-horn colon (:), down line (_) or short lines (-).
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "description"))
@description.setter
def description(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__f7182e4324c52f0ad444f3a980c95471e16a5f399ae84e4b0025dbcb9e246885)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "description", value)
@builtins.property
@jsii.member(jsii_name="throughput")
def throughput(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
throughput: The bandwidth of the agreement service.
Unit: MB/S.
'''
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "throughput"))
@throughput.setter
def throughput(
self,
value: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__b45559924e838a0792651613074865198186db2ea118368dbc5199fdbdb32606)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "throughput", value)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-nas.RosProtocolServiceProps",
jsii_struct_bases=[],
name_mapping={
"file_system_id": "fileSystemId",
"protocol_spec": "protocolSpec",
"protocol_type": "protocolType",
"vpc_id": "vpcId",
"v_switch_id": "vSwitchId",
"description": "description",
"throughput": "throughput",
},
)
class RosProtocolServiceProps:
def __init__(
self,
*,
file_system_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
protocol_spec: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
protocol_type: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
vpc_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
v_switch_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
description: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
throughput: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::NAS::ProtocolService``.
:param file_system_id:
:param protocol_spec:
:param protocol_type:
:param vpc_id:
:param v_switch_id:
:param description:
:param throughput:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__f8014d33a2a0632d0637a246fe46d4ca6d083fbd5a8120a15fac416c89a8e9d2)
check_type(argname="argument file_system_id", value=file_system_id, expected_type=type_hints["file_system_id"])
check_type(argname="argument protocol_spec", value=protocol_spec, expected_type=type_hints["protocol_spec"])
check_type(argname="argument protocol_type", value=protocol_type, expected_type=type_hints["protocol_type"])
check_type(argname="argument vpc_id", value=vpc_id, expected_type=type_hints["vpc_id"])
check_type(argname="argument v_switch_id", value=v_switch_id, expected_type=type_hints["v_switch_id"])
check_type(argname="argument description", value=description, expected_type=type_hints["description"])
check_type(argname="argument throughput", value=throughput, expected_type=type_hints["throughput"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"file_system_id": file_system_id,
"protocol_spec": protocol_spec,
"protocol_type": protocol_type,
"vpc_id": vpc_id,
"v_switch_id": v_switch_id,
}
if description is not None:
self._values["description"] = description
if throughput is not None:
self._values["throughput"] = throughput
@builtins.property
def file_system_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: fileSystemId: File system ID.
'''
result = self._values.get("file_system_id")
assert result is not None, "Required property 'file_system_id' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def protocol_spec(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: protocolSpec: The spec of protocol service. Default: General. Values: General
'''
result = self._values.get("protocol_spec")
assert result is not None, "Required property 'protocol_spec' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def protocol_type(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
protocolType: The protocol type of agreement service.
Ranges:
NFS: Agreement service supports NFS protocol access.
The default value: NFS.
'''
result = self._values.get("protocol_type")
assert result is not None, "Required property 'protocol_type' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def vpc_id(self) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: vpcId: The protocol service VPCID needs to be consistent with the file system VPC.
'''
result = self._values.get("vpc_id")
assert result is not None, "Required property 'vpc_id' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def v_switch_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: vSwitchId: Agreement service vswitchid.
'''
result = self._values.get("v_switch_id")
assert result is not None, "Required property 'v_switch_id' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def description(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
description: Description of protocol service.The console shows the "protocol service name".
limit:
The length is 2 to 128 English or Chinese characters.
Start with a lowercase letter or Chinese, and you cannot start with http:// and https: //.
It can contain numbers, half-horn colon (:), down line (_) or short lines (-).
'''
result = self._values.get("description")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def throughput(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
throughput: The bandwidth of the agreement service.
Unit: MB/S.
'''
result = self._values.get("throughput")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "RosProtocolServiceProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
__all__ = [
"AccessGroup",
"AccessGroupProps",
"AccessRule",
"AccessRuleProps",
"DataFlow",
"DataFlowProps",
"FileSystem",
"FileSystemProps",
"Fileset",
"FilesetProps",
"MountTarget",
"MountTargetProps",
"ProtocolMountTarget",
"ProtocolMountTargetProps",
"ProtocolService",
"ProtocolServiceProps",
"RosAccessGroup",
"RosAccessGroupProps",
"RosAccessRule",
"RosAccessRuleProps",
"RosDataFlow",
"RosDataFlowProps",
"RosFileSystem",
"RosFileSystemProps",
"RosFileset",
"RosFilesetProps",
"RosMountTarget",
"RosMountTargetProps",
"RosProtocolMountTarget",
"RosProtocolMountTargetProps",
"RosProtocolService",
"RosProtocolServiceProps",
"datasource",
]
publication.publish()
# Loading modules to ensure their types are registered with the jsii runtime library
from . import datasource
def _typecheckingstub__18f8c298f10dda5f46a5c7a0e038df9f0e230454cb630fd508bd594b6e4da1da(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[AccessGroupProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__39b9a144f1df420efd946b760447cdf23ef6e6c6fa4c30ec6ec54674f046df3f(
*,
access_group_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
access_group_type: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
description: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
file_system_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__e31eaf701123f48de8bfcc3d4279f6fb373a3227869cf26a9a34fcb407aa51f6(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[AccessRuleProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__d6b08a221352ddf828597145f5104e395a7ec07a7829c2851cdf48d1ff5b6a0f(
*,
access_group_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
file_system_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
ipv6_source_cidr_ip: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
priority: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
rw_access_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
source_cidr_ip: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
user_access_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__b5e70b6fecd551511d1921080e2464dbbb9da08550fbf8a9a3cbc2733b4ed64b(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[DataFlowProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__d9e168188f0d970a9c342231f51a2739302ab7e0cf9e2a3e1fff344592ed952d(
*,
file_system_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
fset_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
source_storage: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
throughput: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
auto_refresh_interval: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
auto_refresh_policy: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
auto_refreshs: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union[RosDataFlow.AutoRefreshsProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
description: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
source_security_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__f08e36f508bf6c26be2684e621f4c27b458de129cd7b2ed6334a675f7da67e2d(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[FileSystemProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__4b629c1ab030cee3e8346720296fc68af606d8edcd8ca2e6fddb5daf51882ef5(
*,
protocol_type: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
storage_type: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
bandwidth: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
capacity: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
charge_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
deletion_force: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
description: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
duration: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
encrypt_type: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
file_system_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
snapshot_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
tags: typing.Optional[typing.Sequence[typing.Union[RosFileSystem.TagsProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
vpc_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
v_switch_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
zone_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__d1d717ec7a00a869738ca6b33860bc335263b80fedb8a2fbebb041c6c425a226(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[FilesetProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__368024a96739c25073aecc43ab390a7634b0c29e0b3777a4bf28ff7e12d72449(
*,
file_system_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
file_system_path: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
description: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__b1f00245bc88fe214aea0f5fcf1301cb1a9de78f42632f94bc54e1db8cbe6268(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[MountTargetProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__503cdafbad0e86b5bb0ce1a4866d2baa7806ce596b11b936170eb711c72af6e2(
*,
access_group_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
file_system_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
network_type: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
enable_ipv6: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
security_group_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
status: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
vpc_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
v_switch_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__de46cad0bf38a0839321f0ea748d81797eb8445d30e5e451d56dce4e3fe8b886(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[ProtocolMountTargetProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__fedb67fd491330ac792c990726436fcf1a053ab8b8bebf4fd3b6ec19aaca0ee8(
*,
file_system_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
protocol_service_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
vpc_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
v_switch_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
access_group_name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
description: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
fset_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
path: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__c6ff8d2a67f998d4210b883c834d32c40245ef46cf04cb5df5ed174d5782a7be(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[ProtocolServiceProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__76fd55713defe391256665574c0d5061435e8faa1a9590b2ec159a6bfe7e8771(
*,
file_system_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
protocol_spec: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
protocol_type: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
vpc_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
v_switch_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
description: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
throughput: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__17d7caa04ec0f534160c6fd724465033498604c0b7b47d8ecbc263bdef694843(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[RosAccessGroupProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__260b3e9a88edd5cc45696f2a9224a6a4163b228af37d761eb0532dec42e67072(
props: typing.Mapping[builtins.str, typing.Any],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__64de9dc66d110f14e43ff2a310e24c806e063bb9c71345c982e3439dc982e530(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__3d29204d60677bb489ab4a6497e6a1dd73efb156b6b93ca283541d9f98038e5a(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__997068ffafd53ab7eca2ba5035ae391dbc877e5de4fb6ca24f26a2fd67ae34bd(
value: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__5038db951ef3e6113822ac996dd6369f1960f22cabedaae3e1ea9275d2e74849(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__2214608aae77eb4a9aa44cc8a50bf4a0c75116b81bb8bc360db32a3010fff738(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__894d86d5092e4136137947715c57558d006d0810f9d2223cd5815028c53323cf(
*,
access_group_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
access_group_type: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
description: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
file_system_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__c127ef585711a654fff848ac0fe54d2ed0a46fb75f9e8082c9f31b1a01b3481a(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[RosAccessRuleProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__c149c12fbe435f30c97ace841d85d460e72d1b3f9ca9699bcf98789dbee6d02d(
props: typing.Mapping[builtins.str, typing.Any],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__2e5a292a3a40dce89521c918c412d6026a7c0d795da6e4b8c144b4654969a815(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__44f29a4bb0ef2642c5d1bf914e831bb9736dc3ac45d6e1effc62c326ec381308(
value: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__99c7e8731b648ae4d8e93aef822910bb3cf0c398dc1cbfa3548cc1531f6ba3f6(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__1897a73cb46242cf34f507a56688529e174a36dc109c5773df12898abe515758(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__2a427490a582a571a18e1b7cb1d5963b24135ce78fc29ec89a2970b9123dfff1(
value: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__d425bc1f462fccd1532eac85ce6709d44a2f7aeb36a46ac3b7847c2b786e652b(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__7293e86f1208efaa25433115fbbad7e7956a1cf2be94c226e3f78dd67840d879(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__2e2306745096dfb9ed3f0bb2ecbc6b5cb5f1f6e8cb5287458ff063301383e740(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__168086a55681ea64a5e0c16598b5bb0e13ffacecb5e3e64c6629d01eb622ca0f(
*,
access_group_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
file_system_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
ipv6_source_cidr_ip: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
priority: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
rw_access_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
source_cidr_ip: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
user_access_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__86db75dbc818cc45f7a30541573d7761bcea29d2107bb458416ec06c025dc8ab(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[RosDataFlowProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__0e1f31fac01da09b536dc10d970b3becc86216ec8b499eef3370e1034980b917(
props: typing.Mapping[builtins.str, typing.Any],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__a0f4557a2b8d5afa65362b7c158a88a22684e46cfde4492fc46df5f0be938330(
value: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__00dd7850eae7be3c8669a88403300be5eaabe4a57bbae57d8832a5a8bd89bea3(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__39c355c7132cad9a6407a1e316dbc472c4e88bee1d2a1e6ee29fededdf98a131(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__31c74f488186bf7dc01c95cdbe314ca14fdb069b4ab23e5bedcde5463334de0f(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__7de8a6fca7223853104406b64fdead80449f5afe372c73739a1cd8295fc9df59(
value: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__b27b3a427efa9dc29327d9b6a41d39f76894946cd71254ce6772964aa0688e21(
value: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__fdb38926341d3d711fabac1a319abe5ee01602943a02b8d60e5766104dd3adf7(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__afd0b11c25b34b04165b4b17341da571c75c63388bc8eac53b7b2ad01c24d587(
value: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, RosDataFlow.AutoRefreshsProperty]]]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__c570b60a7acacafc49e043aa92b2ad5944e22ad576830748c8518454c1665622(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__4d5346b37986c85ca586f8de228a10264d859971b34be199512c897daed62387(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__d4e0677af98c37d7a598fe09b07d89bc6e1f470aeb2033a36ce2a9a33bde5d17(
*,
refresh_path: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__3003cffe28660bb9388dcaf896e791ba8082dfd544c4fbedef9ef50c05575f55(
*,
file_system_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
fset_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
source_storage: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
throughput: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
auto_refresh_interval: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
auto_refresh_policy: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
auto_refreshs: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union[RosDataFlow.AutoRefreshsProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
description: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
source_security_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__3b618ca4066169ac4c43de01db915fe3acfb35495d4f913e2f9c4505da185adb(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[RosFileSystemProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__6331cd590d51f5392a263500d440539ca7ce5e155b621832258560e912ce6523(
props: typing.Mapping[builtins.str, typing.Any],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__491659fa974dcf8a9876b7ad0f4641e1ab52cef703b04ff77166a4c74546b475(
value: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__986fb8c0115ba9fa3cdb689c121ac0c81eacc8f5fd3ed65cdb0d18c7dea46957(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__079b90dc1c3e873a456e1d10b1a17901b9485925812f4d3dcea11f976663bd41(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__acffeb47fb434a5da100ad39570bc5d470c4938aabf9f9b66690dd1f93ac43e0(
value: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__adefa2636c52a5fb546682ec9dbf959cc1a49ed51d2258a47021bdb9a6656139(
value: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__3afa4ccea73d7e8644d9a82f6234960f6be627887ee5f75455a00f213dcc4b01(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__d9a3eb4a8dd889cc13fc33ea001c63869fbff90252bbf24a638accbabbc41b83(
value: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__311911fbadef1a3e8d871675a924e86a3034e48dc5db94d0005fc0ce74f093cd(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__8898fabcadd84f065f2c2de27986ffbefa5c0e6816249c0bea79947bd06234f2(
value: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__375a0a1c36f743eb876e70d21c48c26300326839559ce27c03d7241f4e83ecc8(
value: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__f25766e5a3e80cb75ddedd7e5fb5052a6db839e86151289740b15644d0eeed0d(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__f8f56a7407cebef62811cf4cfaa5954ef8b80c008bfb7e2533b3623b158a8374(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__d68fcebb4464351798b50f8fff31aeaf57b93373be3fd4b10b7e548aead029a7(
value: typing.Optional[typing.List[RosFileSystem.TagsProperty]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__4e31c7764e731169d4c0c4f713e70587525f88df97cb2be7eb2ae7038b1508e3(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__fa65219beeec7e8e60ef1f7903c41cc31a36cb5a610531d98ab298a267399c5b(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__a100f82d73a735a0a2baacb79fe8304b52cd8fa91a4b14893364a5c5cf13b7dc(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__e81fe819d38816de57f81e94c8fb72af74e798fc88b2c5308bac62522317e6b8(
*,
key: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__ca3e192edc6072b9caac2c98038a213c68ab41d46815cf1d4ce5e5cfaba61425(
*,
protocol_type: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
storage_type: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
bandwidth: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
capacity: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
charge_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
deletion_force: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
description: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
duration: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
encrypt_type: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
file_system_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
snapshot_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
tags: typing.Optional[typing.Sequence[typing.Union[RosFileSystem.TagsProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
vpc_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
v_switch_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
zone_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__6c7c1a8d4c8feb5bbc5fec4db83194243a06c9882e12dbd796fe469e58b70e63(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[RosFilesetProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__d2e1eb4ee8d8162a7a1c812e9d514c2b27a447cfda1cbcdfae453bc6c07bb44c(
props: typing.Mapping[builtins.str, typing.Any],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__a9983841a76737ec72af797a6350d987c6f640c1414b32dbebdf0864bf977485(
value: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__28e4127e37a1d559225470dcae2f08977f76bc9dacd04269ff9c1bd15f44a25c(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__c7be1441ea70f9f9e4475ea7ce7c68552d796d480800d07c0f8cf8ca188de0a7(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__1dbe557df307980974e51809d20b5028af3e1df92e717ba74f3473589716e226(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__e66afd6f275baaa041b5d45940936d8dc4e8b2b85ea480f96e215070d874669e(
*,
file_system_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
file_system_path: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
description: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__fbaa6948b82b45f72b3219341c207fb7b5d2dad32e911f456ccd123c22b30d4d(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[RosMountTargetProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__b4b91938a2fff6d4815d4dc973571dd0e7dfa0f4562f0ef51a1d6f52d91b6a63(
props: typing.Mapping[builtins.str, typing.Any],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__4c2d0334c66c9c90b6cc03b0ca5aa26505c7dae7407e4f2a5cfaca712caa1b17(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__9543207777664059608ba9680f052fd58302a7c8879c2a2e44b5ed5bae6ea9dd(
value: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__345141c8132d575b934196721039ea9073feda9fe8e43f1fe0d45ca7a25fb449(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__c44f535881b857f02efe1e7dc2af2ade5b0689d87b163f22adcc1e8e30fd75f7(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__37b834f9a450b53b5421d5d58c0e8db3764a54caf9d1e0a6c9135825ba3bd0a5(
value: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__c0a043f8b53444874359daa03208d36c265885f4bca09fd8a82fe534cc2b39b2(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__fdc45d0bb32ef343c1fa43c8f27e41a7b12c8b3bf2f0184ea7b1b0cbc013bde0(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__1389b1b8e879e36caa6ded984bf3cbca407845e55edeac4028dc85911132a2e4(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__553b75b354f1fbfe41ebaa38a9daeea0815c4cd349005f846f293fbccf6e7307(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__8e50d045eea2d7b9dd1a6c2ecc7d6d9a43201226bb2dac2bf10a55d3d81a5ce0(
*,
access_group_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
file_system_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
network_type: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
enable_ipv6: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
security_group_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
status: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
vpc_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
v_switch_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__7181588ce75cc65cf406ca327697d88fa8368a539a5578d79169360c8e665b45(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[RosProtocolMountTargetProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__bb399a5ca06f618f627ac24a1ff0ff779c229d9d6176e933cc94d807dbe49830(
props: typing.Mapping[builtins.str, typing.Any],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__0e7ec81276d0ff5cb72f2254a7ede164e8bcd3bf1a6457e5b5c1433b46ad72f5(
value: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__be14e0a0178e89b4d1d61c6e7059f0d39329e8efe0e2465d774388b8a77f4ecb(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__1952a48f767f19de886389c10228d801cc201bcfc53a83c34c0dca19635fe3f4(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__598cf922a243c1fb57304c5727156ddee9e093f0dde5c96cfef60412a6bd3d7a(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__04db921f49b9482adfecce2b478bbfc2a9d67711f06d99ac5feaf1274a711e05(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__27481f4a06f871e0b9853ea07e7448c5c6f8617a78eaec1de5713f2dc2103cfe(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__3bbb4bb2289fd51031c1d4ce9906ed5865000b03975fa67872f02cfd6b20b694(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__f9f79402278391f41c4c25db8037b7cfad436808f9d02ffae2ab1d788a6be531(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__bd7bbfd70af43b96f5ebcb46b3ce6cd5f8ff7e2b1a31f5e096b4aabd1072e076(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__27cb04cb342c4092c8293caf1a2b5904927de7e107334df5c62a920f2f70b7c8(
*,
file_system_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
protocol_service_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
vpc_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
v_switch_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
access_group_name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
description: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
fset_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
path: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__359612e2039931811df30746c74c850b1e19b68b10d27c4a9136c9f6106f06c2(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[RosProtocolServiceProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__e0754340e0cc98a561e71f1f32705a6162e5f041ea29da865ea33e1190289c05(
props: typing.Mapping[builtins.str, typing.Any],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__ccc4298a2d30acea3d72c264fc6bf93deffb29f85453c6a9ed02d35c03320f89(
value: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__9aeee1f203323389fb7dc0a999fb841332e45548fc24932dddf22ec5bb04bcd1(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__2bd76c4d305655e4f93f3dfe92c522e0b83c0538c5cbac6c2baa4428ce559cc6(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__9fcfddb805a743d9fed5fcc0109b0c51cdb3dc79829d857295e727282a479237(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__215519c0e1f29bbc3265aa826754c3a9dbf673abdc8f930bbe8640b4e283cc92(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__1f01965448725c7fc785e80ca1ddca654959a26ef8f37b0c242e6a376d116840(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__f7182e4324c52f0ad444f3a980c95471e16a5f399ae84e4b0025dbcb9e246885(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__b45559924e838a0792651613074865198186db2ea118368dbc5199fdbdb32606(
value: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__f8014d33a2a0632d0637a246fe46d4ca6d083fbd5a8120a15fac416c89a8e9d2(
*,
file_system_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
protocol_spec: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
protocol_type: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
vpc_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
v_switch_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
description: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
throughput: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass | /ros-cdk-nas-1.0.17.tar.gz/ros-cdk-nas-1.0.17/src/ros_cdk_nas/__init__.py | 0.659953 | 0.152568 | __init__.py | pypi |
import abc
import builtins
import datetime
import enum
import typing
import jsii
import publication
import typing_extensions
from typeguard import check_type
from ._jsii import *
import ros_cdk_core as _ros_cdk_core_7adfd82f
class Dataset(
_ros_cdk_core_7adfd82f.Resource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-nlpautoml.Dataset",
):
'''A ROS resource type: ``ALIYUN::NLPAUTOML::Dataset``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["DatasetProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
'''Create a new ``ALIYUN::NLPAUTOML::Dataset``.
Param scope - scope in which this resource is defined
Param id - scoped id of the resource
Param props - resource properties
:param scope: -
:param id: -
:param props: -
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__833bc0e71bfd783904457f9f16b567fa4707e390365cb088f546b04e907ce2b3)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@builtins.property
@jsii.member(jsii_name="attrDatasetId")
def attr_dataset_id(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute DatasetId: The dataset ID.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrDatasetId"))
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-nlpautoml.DatasetProps",
jsii_struct_bases=[],
name_mapping={
"dataset_name": "datasetName",
"project_id": "projectId",
"dataset_record": "datasetRecord",
},
)
class DatasetProps:
def __init__(
self,
*,
dataset_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
project_id: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
dataset_record: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::NLPAUTOML::Dataset``.
:param dataset_name: Property datasetName: The name of dataset. Cannot start with numbers and symbols, and the length cannot be greater than 32 characters.
:param project_id: Property projectId: The ID of project. To create a dataset under a certain project, fill in the target project ID.
:param dataset_record: Property datasetRecord: Upload labeled data to the dataset.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__03d0ceb105a30b16690e9e7a39084cd0073e6d78d3800d074df70fe8484801d3)
check_type(argname="argument dataset_name", value=dataset_name, expected_type=type_hints["dataset_name"])
check_type(argname="argument project_id", value=project_id, expected_type=type_hints["project_id"])
check_type(argname="argument dataset_record", value=dataset_record, expected_type=type_hints["dataset_record"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"dataset_name": dataset_name,
"project_id": project_id,
}
if dataset_record is not None:
self._values["dataset_record"] = dataset_record
@builtins.property
def dataset_name(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property datasetName: The name of dataset.
Cannot start with numbers and symbols, and the length cannot be greater than 32 characters.
'''
result = self._values.get("dataset_name")
assert result is not None, "Required property 'dataset_name' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def project_id(
self,
) -> typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property projectId: The ID of project.
To create a dataset under a certain project, fill in the target project ID.
'''
result = self._values.get("project_id")
assert result is not None, "Required property 'project_id' is missing"
return typing.cast(typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def dataset_record(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]]:
'''Property datasetRecord: Upload labeled data to the dataset.'''
result = self._values.get("dataset_record")
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "DatasetProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class Model(
_ros_cdk_core_7adfd82f.Resource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-nlpautoml.Model",
):
'''A ROS resource type: ``ALIYUN::NLPAUTOML::Model``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["ModelProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
'''Create a new ``ALIYUN::NLPAUTOML::Model``.
Param scope - scope in which this resource is defined
Param id - scoped id of the resource
Param props - resource properties
:param scope: -
:param id: -
:param props: -
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__d9a66a6d83854eef6a1d0747ab7cd3c2d4ea1b3f67fbfac0e7412c8125557de7)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@builtins.property
@jsii.member(jsii_name="attrModelId")
def attr_model_id(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute ModelId: The ID of model.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrModelId"))
@builtins.property
@jsii.member(jsii_name="attrModelVersion")
def attr_model_version(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute ModelVersion: The version of model.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrModelVersion"))
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-nlpautoml.ModelProps",
jsii_struct_bases=[],
name_mapping={
"dataset_id_list": "datasetIdList",
"model_name": "modelName",
"model_type": "modelType",
"project_id": "projectId",
"lr": "lr",
"nepochs": "nepochs",
"test_dataset_id_list": "testDatasetIdList",
},
)
class ModelProps:
def __init__(
self,
*,
dataset_id_list: typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]],
model_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
model_type: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
project_id: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
lr: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
nepochs: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
test_dataset_id_list: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::NLPAUTOML::Model``.
:param dataset_id_list: Property datasetIdList: The uploaded dataset must be under the same project, and the total number of marked data is greater than or equal to 4.
:param model_name: Property modelName: The name of model.
:param model_type: Property modelType: The type of model. Please refer to the documentation for the parameter values corresponding to different types of models. Using the specified model type under different project, and the backend will do the verification. If the model type does not exist under the project, it will prompt that the base model is not found
:param project_id: Property projectId: The project id to which the model belongs.
:param lr: Property lr: Learning rate.
:param nepochs: Property nepochs: Number of training dataset iterations.
:param test_dataset_id_list: Property testDatasetIdList: Test set ID list. Some models under text classification support adding test set data.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__129232a95555916843987319af6fb06df7e49c5c9a854dc8e01a9fff18f96f79)
check_type(argname="argument dataset_id_list", value=dataset_id_list, expected_type=type_hints["dataset_id_list"])
check_type(argname="argument model_name", value=model_name, expected_type=type_hints["model_name"])
check_type(argname="argument model_type", value=model_type, expected_type=type_hints["model_type"])
check_type(argname="argument project_id", value=project_id, expected_type=type_hints["project_id"])
check_type(argname="argument lr", value=lr, expected_type=type_hints["lr"])
check_type(argname="argument nepochs", value=nepochs, expected_type=type_hints["nepochs"])
check_type(argname="argument test_dataset_id_list", value=test_dataset_id_list, expected_type=type_hints["test_dataset_id_list"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"dataset_id_list": dataset_id_list,
"model_name": model_name,
"model_type": model_type,
"project_id": project_id,
}
if lr is not None:
self._values["lr"] = lr
if nepochs is not None:
self._values["nepochs"] = nepochs
if test_dataset_id_list is not None:
self._values["test_dataset_id_list"] = test_dataset_id_list
@builtins.property
def dataset_id_list(
self,
) -> typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]]:
'''Property datasetIdList: The uploaded dataset must be under the same project, and the total number of marked data is greater than or equal to 4.'''
result = self._values.get("dataset_id_list")
assert result is not None, "Required property 'dataset_id_list' is missing"
return typing.cast(typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]], result)
@builtins.property
def model_name(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property modelName: The name of model.'''
result = self._values.get("model_name")
assert result is not None, "Required property 'model_name' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def model_type(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property modelType: The type of model.
Please refer to the documentation for the parameter values corresponding to different types of models.
Using the specified model type under different project, and the backend will do the verification. If the model type does not exist under the project, it will prompt that the base model is not found
'''
result = self._values.get("model_type")
assert result is not None, "Required property 'model_type' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def project_id(
self,
) -> typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property projectId: The project id to which the model belongs.'''
result = self._values.get("project_id")
assert result is not None, "Required property 'project_id' is missing"
return typing.cast(typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def lr(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property lr: Learning rate.'''
result = self._values.get("lr")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def nepochs(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property nepochs: Number of training dataset iterations.'''
result = self._values.get("nepochs")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def test_dataset_id_list(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]]]:
'''Property testDatasetIdList: Test set ID list.
Some models under text classification support adding test set data.
'''
result = self._values.get("test_dataset_id_list")
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "ModelProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class Project(
_ros_cdk_core_7adfd82f.Resource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-nlpautoml.Project",
):
'''A ROS resource type: ``ALIYUN::NLPAUTOML::Project``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["ProjectProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
'''Create a new ``ALIYUN::NLPAUTOML::Project``.
Param scope - scope in which this resource is defined
Param id - scoped id of the resource
Param props - resource properties
:param scope: -
:param id: -
:param props: -
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__1262503ccf29b49b3b4b2097c11c26dfb7869d8d4999e5b83d3aaf0e0638e44c)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@builtins.property
@jsii.member(jsii_name="attrProjectId")
def attr_project_id(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute ProjectId: The project ID.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrProjectId"))
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-nlpautoml.ProjectProps",
jsii_struct_bases=[],
name_mapping={
"project_description": "projectDescription",
"project_name": "projectName",
"project_type": "projectType",
},
)
class ProjectProps:
def __init__(
self,
*,
project_description: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
project_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
project_type: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
'''Properties for defining a ``ALIYUN::NLPAUTOML::Project``.
:param project_description: Property projectDescription: The description of project.Cannot start with numbers and symbols, and the length cannot be greater than 256 characters.
:param project_name: Property projectName: The name of project. Cannot start with numbers and symbols, and the length cannot be greater than 32 characters.
:param project_type: Property projectType: The type of nlp project. The following value is allowed: ner, textCategorybaseRelation, textMatching, sentimentAnalysis, resumeExtract, reviewAnalysis
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__f96475f81a0dffe41aa7207e6c2a14290d489aaedbada428cc090fe9112f08f6)
check_type(argname="argument project_description", value=project_description, expected_type=type_hints["project_description"])
check_type(argname="argument project_name", value=project_name, expected_type=type_hints["project_name"])
check_type(argname="argument project_type", value=project_type, expected_type=type_hints["project_type"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"project_description": project_description,
"project_name": project_name,
"project_type": project_type,
}
@builtins.property
def project_description(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property projectDescription: The description of project.Cannot start with numbers and symbols, and the length cannot be greater than 256 characters.'''
result = self._values.get("project_description")
assert result is not None, "Required property 'project_description' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def project_name(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property projectName: The name of project.
Cannot start with numbers and symbols, and the length cannot be greater than 32 characters.
'''
result = self._values.get("project_name")
assert result is not None, "Required property 'project_name' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def project_type(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property projectType: The type of nlp project.
The following value is allowed: ner, textCategorybaseRelation, textMatching, sentimentAnalysis, resumeExtract, reviewAnalysis
'''
result = self._values.get("project_type")
assert result is not None, "Required property 'project_type' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "ProjectProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class RosDataset(
_ros_cdk_core_7adfd82f.RosResource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-nlpautoml.RosDataset",
):
'''A ROS template type: ``ALIYUN::NLPAUTOML::Dataset``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["RosDatasetProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
'''Create a new ``ALIYUN::NLPAUTOML::Dataset``.
:param scope: - scope in which this resource is defined.
:param id: - scoped id of the resource.
:param props: - resource properties.
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__554e39b067e20958d7673af11e04e9e35ac09b5edabbcdee12aee49f9f3e7aca)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@jsii.member(jsii_name="renderProperties")
def _render_properties(
self,
props: typing.Mapping[builtins.str, typing.Any],
) -> typing.Mapping[builtins.str, typing.Any]:
'''
:param props: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__a1350982a935391de47724192133ff1819308c6a0706708fea01c4625f0d8375)
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))
@jsii.python.classproperty
@jsii.member(jsii_name="ROS_RESOURCE_TYPE_NAME")
def ROS_RESOURCE_TYPE_NAME(cls) -> builtins.str:
'''The resource type name for this resource class.'''
return typing.cast(builtins.str, jsii.sget(cls, "ROS_RESOURCE_TYPE_NAME"))
@builtins.property
@jsii.member(jsii_name="attrDatasetId")
def attr_dataset_id(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: DatasetId: The dataset ID.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrDatasetId"))
@builtins.property
@jsii.member(jsii_name="rosProperties")
def _ros_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "rosProperties"))
@builtins.property
@jsii.member(jsii_name="datasetName")
def dataset_name(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: datasetName: The name of dataset. Cannot start with numbers and symbols, and the length cannot be greater than 32 characters.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "datasetName"))
@dataset_name.setter
def dataset_name(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__f0bf092742c2081d1284c6bc83a48bbabb35360e1d46c298a948ab9d32290e25)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "datasetName", value)
@builtins.property
@jsii.member(jsii_name="enableResourcePropertyConstraint")
def enable_resource_property_constraint(self) -> builtins.bool:
return typing.cast(builtins.bool, jsii.get(self, "enableResourcePropertyConstraint"))
@enable_resource_property_constraint.setter
def enable_resource_property_constraint(self, value: builtins.bool) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__917a590e8ceb79c7ff91d1d5e99dd2d7bc971972f16f5e92a8c5a67ca4eb4eb2)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "enableResourcePropertyConstraint", value)
@builtins.property
@jsii.member(jsii_name="projectId")
def project_id(
self,
) -> typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: projectId: The ID of project. To create a dataset under a certain project, fill in the target project ID.
'''
return typing.cast(typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "projectId"))
@project_id.setter
def project_id(
self,
value: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__168bdbf1d2d6a2926f3787000b1199bccc46773176479cad9273f86f74919710)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "projectId", value)
@builtins.property
@jsii.member(jsii_name="datasetRecord")
def dataset_record(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]]:
'''
:Property: datasetRecord: Upload labeled data to the dataset.
'''
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]], jsii.get(self, "datasetRecord"))
@dataset_record.setter
def dataset_record(
self,
value: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__e5bd25a2e55e5a0cafe9e91d9469cf4d7fa66715da92bb3b9a683841aecbc650)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "datasetRecord", value)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-nlpautoml.RosDatasetProps",
jsii_struct_bases=[],
name_mapping={
"dataset_name": "datasetName",
"project_id": "projectId",
"dataset_record": "datasetRecord",
},
)
class RosDatasetProps:
def __init__(
self,
*,
dataset_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
project_id: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
dataset_record: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::NLPAUTOML::Dataset``.
:param dataset_name:
:param project_id:
:param dataset_record:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__21865c4bdd0f97f0fecc217ca1cb503ed74003fde8d17975a4056d5096d09f6c)
check_type(argname="argument dataset_name", value=dataset_name, expected_type=type_hints["dataset_name"])
check_type(argname="argument project_id", value=project_id, expected_type=type_hints["project_id"])
check_type(argname="argument dataset_record", value=dataset_record, expected_type=type_hints["dataset_record"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"dataset_name": dataset_name,
"project_id": project_id,
}
if dataset_record is not None:
self._values["dataset_record"] = dataset_record
@builtins.property
def dataset_name(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: datasetName: The name of dataset. Cannot start with numbers and symbols, and the length cannot be greater than 32 characters.
'''
result = self._values.get("dataset_name")
assert result is not None, "Required property 'dataset_name' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def project_id(
self,
) -> typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: projectId: The ID of project. To create a dataset under a certain project, fill in the target project ID.
'''
result = self._values.get("project_id")
assert result is not None, "Required property 'project_id' is missing"
return typing.cast(typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def dataset_record(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]]:
'''
:Property: datasetRecord: Upload labeled data to the dataset.
'''
result = self._values.get("dataset_record")
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "RosDatasetProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class RosModel(
_ros_cdk_core_7adfd82f.RosResource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-nlpautoml.RosModel",
):
'''A ROS template type: ``ALIYUN::NLPAUTOML::Model``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["RosModelProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
'''Create a new ``ALIYUN::NLPAUTOML::Model``.
:param scope: - scope in which this resource is defined.
:param id: - scoped id of the resource.
:param props: - resource properties.
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__10cf58b0ea06484c90eebc1096e5904292eb8a598f7d5a06376af4af964740ec)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@jsii.member(jsii_name="renderProperties")
def _render_properties(
self,
props: typing.Mapping[builtins.str, typing.Any],
) -> typing.Mapping[builtins.str, typing.Any]:
'''
:param props: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__7a7793430ab2aba8f48ed34131c40e1bb5f064a340170c10a8e697ba1350a481)
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))
@jsii.python.classproperty
@jsii.member(jsii_name="ROS_RESOURCE_TYPE_NAME")
def ROS_RESOURCE_TYPE_NAME(cls) -> builtins.str:
'''The resource type name for this resource class.'''
return typing.cast(builtins.str, jsii.sget(cls, "ROS_RESOURCE_TYPE_NAME"))
@builtins.property
@jsii.member(jsii_name="attrModelId")
def attr_model_id(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: ModelId: The ID of model.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrModelId"))
@builtins.property
@jsii.member(jsii_name="attrModelVersion")
def attr_model_version(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: ModelVersion: The version of model.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrModelVersion"))
@builtins.property
@jsii.member(jsii_name="rosProperties")
def _ros_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "rosProperties"))
@builtins.property
@jsii.member(jsii_name="datasetIdList")
def dataset_id_list(
self,
) -> typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]]:
'''
:Property: datasetIdList: The uploaded dataset must be under the same project, and the total number of marked data is greater than or equal to 4.
'''
return typing.cast(typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]], jsii.get(self, "datasetIdList"))
@dataset_id_list.setter
def dataset_id_list(
self,
value: typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__2990bbbee7030808e747a904d2fc199d49b4fe7f4b0f83493f92bee81499ada1)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "datasetIdList", value)
@builtins.property
@jsii.member(jsii_name="enableResourcePropertyConstraint")
def enable_resource_property_constraint(self) -> builtins.bool:
return typing.cast(builtins.bool, jsii.get(self, "enableResourcePropertyConstraint"))
@enable_resource_property_constraint.setter
def enable_resource_property_constraint(self, value: builtins.bool) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__e27607c787cfe98992b14aa5855298e6e8f86d5e4feb4ce4f5fa736c88df0272)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "enableResourcePropertyConstraint", value)
@builtins.property
@jsii.member(jsii_name="modelName")
def model_name(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: modelName: The name of model.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "modelName"))
@model_name.setter
def model_name(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__ca639e681132c9e81765c4f9949a530a2f21b4c4cb3c4a0f6fdc28c594995192)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "modelName", value)
@builtins.property
@jsii.member(jsii_name="modelType")
def model_type(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
modelType: The type of model. Please refer to the documentation for the parameter values corresponding to different types of models.
Using the specified model type under different project, and the backend will do the verification. If the model type does not exist under the project, it will prompt that the base model is not found
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "modelType"))
@model_type.setter
def model_type(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__ab5c47284f2dc6ad65994728a46971fbb5dd3a5484fc3c14ec0200a94a669101)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "modelType", value)
@builtins.property
@jsii.member(jsii_name="projectId")
def project_id(
self,
) -> typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: projectId: The project id to which the model belongs
'''
return typing.cast(typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "projectId"))
@project_id.setter
def project_id(
self,
value: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__730bfd367d7006093a46c43b8743c7b0a737f58bdbbfbd6f1238e3947cb1e663)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "projectId", value)
@builtins.property
@jsii.member(jsii_name="lr")
def lr(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: lr: Learning rate.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "lr"))
@lr.setter
def lr(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__6533d049fd8d9fffe909f7585ca397701f48c9812d2acde579811f3ce6169fab)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "lr", value)
@builtins.property
@jsii.member(jsii_name="nepochs")
def nepochs(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: nepochs: Number of training dataset iterations
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "nepochs"))
@nepochs.setter
def nepochs(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__8968bb129816dea43dad6512c0ffa952613ff5a30eab7df406fe6a4b4d99387d)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "nepochs", value)
@builtins.property
@jsii.member(jsii_name="testDatasetIdList")
def test_dataset_id_list(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]]]:
'''
:Property: testDatasetIdList: Test set ID list. Some models under text classification support adding test set data.
'''
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]]], jsii.get(self, "testDatasetIdList"))
@test_dataset_id_list.setter
def test_dataset_id_list(
self,
value: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__4930dc6e094b73ff585c6ab155aa1d4ff9bc523fccde59a39d5bd96e53d9a54c)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "testDatasetIdList", value)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-nlpautoml.RosModelProps",
jsii_struct_bases=[],
name_mapping={
"dataset_id_list": "datasetIdList",
"model_name": "modelName",
"model_type": "modelType",
"project_id": "projectId",
"lr": "lr",
"nepochs": "nepochs",
"test_dataset_id_list": "testDatasetIdList",
},
)
class RosModelProps:
def __init__(
self,
*,
dataset_id_list: typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]],
model_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
model_type: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
project_id: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
lr: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
nepochs: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
test_dataset_id_list: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::NLPAUTOML::Model``.
:param dataset_id_list:
:param model_name:
:param model_type:
:param project_id:
:param lr:
:param nepochs:
:param test_dataset_id_list:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__4a0df1c54f8bf93aad713cee827d2f44a518b8dba4b7450b7723905f1d57582e)
check_type(argname="argument dataset_id_list", value=dataset_id_list, expected_type=type_hints["dataset_id_list"])
check_type(argname="argument model_name", value=model_name, expected_type=type_hints["model_name"])
check_type(argname="argument model_type", value=model_type, expected_type=type_hints["model_type"])
check_type(argname="argument project_id", value=project_id, expected_type=type_hints["project_id"])
check_type(argname="argument lr", value=lr, expected_type=type_hints["lr"])
check_type(argname="argument nepochs", value=nepochs, expected_type=type_hints["nepochs"])
check_type(argname="argument test_dataset_id_list", value=test_dataset_id_list, expected_type=type_hints["test_dataset_id_list"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"dataset_id_list": dataset_id_list,
"model_name": model_name,
"model_type": model_type,
"project_id": project_id,
}
if lr is not None:
self._values["lr"] = lr
if nepochs is not None:
self._values["nepochs"] = nepochs
if test_dataset_id_list is not None:
self._values["test_dataset_id_list"] = test_dataset_id_list
@builtins.property
def dataset_id_list(
self,
) -> typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]]:
'''
:Property: datasetIdList: The uploaded dataset must be under the same project, and the total number of marked data is greater than or equal to 4.
'''
result = self._values.get("dataset_id_list")
assert result is not None, "Required property 'dataset_id_list' is missing"
return typing.cast(typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]], result)
@builtins.property
def model_name(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: modelName: The name of model.
'''
result = self._values.get("model_name")
assert result is not None, "Required property 'model_name' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def model_type(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
modelType: The type of model. Please refer to the documentation for the parameter values corresponding to different types of models.
Using the specified model type under different project, and the backend will do the verification. If the model type does not exist under the project, it will prompt that the base model is not found
'''
result = self._values.get("model_type")
assert result is not None, "Required property 'model_type' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def project_id(
self,
) -> typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: projectId: The project id to which the model belongs
'''
result = self._values.get("project_id")
assert result is not None, "Required property 'project_id' is missing"
return typing.cast(typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def lr(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: lr: Learning rate.
'''
result = self._values.get("lr")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def nepochs(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: nepochs: Number of training dataset iterations
'''
result = self._values.get("nepochs")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def test_dataset_id_list(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]]]:
'''
:Property: testDatasetIdList: Test set ID list. Some models under text classification support adding test set data.
'''
result = self._values.get("test_dataset_id_list")
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "RosModelProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class RosProject(
_ros_cdk_core_7adfd82f.RosResource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-nlpautoml.RosProject",
):
'''A ROS template type: ``ALIYUN::NLPAUTOML::Project``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["RosProjectProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
'''Create a new ``ALIYUN::NLPAUTOML::Project``.
:param scope: - scope in which this resource is defined.
:param id: - scoped id of the resource.
:param props: - resource properties.
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__0ca203ec17e3034432667818dfeab7608cab6a8f3580c3c2c138af8d1e410112)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@jsii.member(jsii_name="renderProperties")
def _render_properties(
self,
props: typing.Mapping[builtins.str, typing.Any],
) -> typing.Mapping[builtins.str, typing.Any]:
'''
:param props: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__4cf6633eee9ce43b29b8a546283a37a802a0f76e89280cd197e0707f52fe29e7)
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))
@jsii.python.classproperty
@jsii.member(jsii_name="ROS_RESOURCE_TYPE_NAME")
def ROS_RESOURCE_TYPE_NAME(cls) -> builtins.str:
'''The resource type name for this resource class.'''
return typing.cast(builtins.str, jsii.sget(cls, "ROS_RESOURCE_TYPE_NAME"))
@builtins.property
@jsii.member(jsii_name="attrProjectId")
def attr_project_id(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: ProjectId: The project ID
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrProjectId"))
@builtins.property
@jsii.member(jsii_name="rosProperties")
def _ros_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "rosProperties"))
@builtins.property
@jsii.member(jsii_name="enableResourcePropertyConstraint")
def enable_resource_property_constraint(self) -> builtins.bool:
return typing.cast(builtins.bool, jsii.get(self, "enableResourcePropertyConstraint"))
@enable_resource_property_constraint.setter
def enable_resource_property_constraint(self, value: builtins.bool) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__47a2fd5515b4a4859204374aa0d1a59e9c5d44afa7f80ffda57cee83968a8871)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "enableResourcePropertyConstraint", value)
@builtins.property
@jsii.member(jsii_name="projectDescription")
def project_description(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: projectDescription: The description of project.Cannot start with numbers and symbols, and the length cannot be greater than 256 characters.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "projectDescription"))
@project_description.setter
def project_description(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__d8acf624a04c0e72de0644700b53d7dc5d80ad00f9484955337f9ce8c68ea4cd)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "projectDescription", value)
@builtins.property
@jsii.member(jsii_name="projectName")
def project_name(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: projectName: The name of project. Cannot start with numbers and symbols, and the length cannot be greater than 32 characters.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "projectName"))
@project_name.setter
def project_name(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__2442f400c29f3c9337e5603a10ef8130460df566940f53b55249114d5529f430)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "projectName", value)
@builtins.property
@jsii.member(jsii_name="projectType")
def project_type(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: projectType: The type of nlp project. The following value is allowed: ner, textCategorybaseRelation, textMatching, sentimentAnalysis, resumeExtract, reviewAnalysis
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "projectType"))
@project_type.setter
def project_type(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__1253e40af5129a87f3d0bdc3f0a7357bb06389cadbabfe9895f95d153f5a1259)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "projectType", value)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-nlpautoml.RosProjectProps",
jsii_struct_bases=[],
name_mapping={
"project_description": "projectDescription",
"project_name": "projectName",
"project_type": "projectType",
},
)
class RosProjectProps:
def __init__(
self,
*,
project_description: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
project_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
project_type: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
'''Properties for defining a ``ALIYUN::NLPAUTOML::Project``.
:param project_description:
:param project_name:
:param project_type:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__b0029127d68f80da280ccb01994b4841d61e07c1b836209f799a04d61e1a7b13)
check_type(argname="argument project_description", value=project_description, expected_type=type_hints["project_description"])
check_type(argname="argument project_name", value=project_name, expected_type=type_hints["project_name"])
check_type(argname="argument project_type", value=project_type, expected_type=type_hints["project_type"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"project_description": project_description,
"project_name": project_name,
"project_type": project_type,
}
@builtins.property
def project_description(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: projectDescription: The description of project.Cannot start with numbers and symbols, and the length cannot be greater than 256 characters.
'''
result = self._values.get("project_description")
assert result is not None, "Required property 'project_description' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def project_name(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: projectName: The name of project. Cannot start with numbers and symbols, and the length cannot be greater than 32 characters.
'''
result = self._values.get("project_name")
assert result is not None, "Required property 'project_name' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def project_type(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: projectType: The type of nlp project. The following value is allowed: ner, textCategorybaseRelation, textMatching, sentimentAnalysis, resumeExtract, reviewAnalysis
'''
result = self._values.get("project_type")
assert result is not None, "Required property 'project_type' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "RosProjectProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
__all__ = [
"Dataset",
"DatasetProps",
"Model",
"ModelProps",
"Project",
"ProjectProps",
"RosDataset",
"RosDatasetProps",
"RosModel",
"RosModelProps",
"RosProject",
"RosProjectProps",
]
publication.publish()
def _typecheckingstub__833bc0e71bfd783904457f9f16b567fa4707e390365cb088f546b04e907ce2b3(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[DatasetProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__03d0ceb105a30b16690e9e7a39084cd0073e6d78d3800d074df70fe8484801d3(
*,
dataset_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
project_id: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
dataset_record: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__d9a66a6d83854eef6a1d0747ab7cd3c2d4ea1b3f67fbfac0e7412c8125557de7(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[ModelProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__129232a95555916843987319af6fb06df7e49c5c9a854dc8e01a9fff18f96f79(
*,
dataset_id_list: typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]],
model_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
model_type: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
project_id: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
lr: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
nepochs: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
test_dataset_id_list: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__1262503ccf29b49b3b4b2097c11c26dfb7869d8d4999e5b83d3aaf0e0638e44c(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[ProjectProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__f96475f81a0dffe41aa7207e6c2a14290d489aaedbada428cc090fe9112f08f6(
*,
project_description: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
project_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
project_type: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__554e39b067e20958d7673af11e04e9e35ac09b5edabbcdee12aee49f9f3e7aca(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[RosDatasetProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__a1350982a935391de47724192133ff1819308c6a0706708fea01c4625f0d8375(
props: typing.Mapping[builtins.str, typing.Any],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__f0bf092742c2081d1284c6bc83a48bbabb35360e1d46c298a948ab9d32290e25(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__917a590e8ceb79c7ff91d1d5e99dd2d7bc971972f16f5e92a8c5a67ca4eb4eb2(
value: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__168bdbf1d2d6a2926f3787000b1199bccc46773176479cad9273f86f74919710(
value: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__e5bd25a2e55e5a0cafe9e91d9469cf4d7fa66715da92bb3b9a683841aecbc650(
value: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__21865c4bdd0f97f0fecc217ca1cb503ed74003fde8d17975a4056d5096d09f6c(
*,
dataset_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
project_id: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
dataset_record: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__10cf58b0ea06484c90eebc1096e5904292eb8a598f7d5a06376af4af964740ec(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[RosModelProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__7a7793430ab2aba8f48ed34131c40e1bb5f064a340170c10a8e697ba1350a481(
props: typing.Mapping[builtins.str, typing.Any],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__2990bbbee7030808e747a904d2fc199d49b4fe7f4b0f83493f92bee81499ada1(
value: typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__e27607c787cfe98992b14aa5855298e6e8f86d5e4feb4ce4f5fa736c88df0272(
value: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__ca639e681132c9e81765c4f9949a530a2f21b4c4cb3c4a0f6fdc28c594995192(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__ab5c47284f2dc6ad65994728a46971fbb5dd3a5484fc3c14ec0200a94a669101(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__730bfd367d7006093a46c43b8743c7b0a737f58bdbbfbd6f1238e3947cb1e663(
value: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__6533d049fd8d9fffe909f7585ca397701f48c9812d2acde579811f3ce6169fab(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__8968bb129816dea43dad6512c0ffa952613ff5a30eab7df406fe6a4b4d99387d(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__4930dc6e094b73ff585c6ab155aa1d4ff9bc523fccde59a39d5bd96e53d9a54c(
value: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__4a0df1c54f8bf93aad713cee827d2f44a518b8dba4b7450b7723905f1d57582e(
*,
dataset_id_list: typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]],
model_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
model_type: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
project_id: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
lr: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
nepochs: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
test_dataset_id_list: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__0ca203ec17e3034432667818dfeab7608cab6a8f3580c3c2c138af8d1e410112(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[RosProjectProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__4cf6633eee9ce43b29b8a546283a37a802a0f76e89280cd197e0707f52fe29e7(
props: typing.Mapping[builtins.str, typing.Any],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__47a2fd5515b4a4859204374aa0d1a59e9c5d44afa7f80ffda57cee83968a8871(
value: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__d8acf624a04c0e72de0644700b53d7dc5d80ad00f9484955337f9ce8c68ea4cd(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__2442f400c29f3c9337e5603a10ef8130460df566940f53b55249114d5529f430(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__1253e40af5129a87f3d0bdc3f0a7357bb06389cadbabfe9895f95d153f5a1259(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__b0029127d68f80da280ccb01994b4841d61e07c1b836209f799a04d61e1a7b13(
*,
project_description: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
project_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
project_type: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass | /ros-cdk-nlpautoml-1.0.17.tar.gz/ros-cdk-nlpautoml-1.0.17/src/ros_cdk_nlpautoml/__init__.py | 0.65368 | 0.213521 | __init__.py | pypi |
import abc
import builtins
import datetime
import enum
import typing
import jsii
import publication
import typing_extensions
from typeguard import check_type
from .._jsii import *
import ros_cdk_core as _ros_cdk_core_7adfd82f
class Buckets(
_ros_cdk_core_7adfd82f.Resource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-oss.datasource.Buckets",
):
'''A ROS resource type: ``DATASOURCE::OSS::Buckets``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Optional[typing.Union["BucketsProps", typing.Dict[builtins.str, typing.Any]]] = None,
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
'''Create a new ``DATASOURCE::OSS::Buckets``.
Param scope - scope in which this resource is defined
Param id - scoped id of the resource
Param props - resource properties
:param scope: -
:param id: -
:param props: -
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__3696a81047d1e89e2381552d25b73ccb260719952ad3a1b5353ca2e4df677516)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@builtins.property
@jsii.member(jsii_name="attrBucketNames")
def attr_bucket_names(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute BucketNames: The list of bucket names.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrBucketNames"))
@builtins.property
@jsii.member(jsii_name="attrBuckets")
def attr_buckets(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute Buckets: The list of buckets.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrBuckets"))
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-oss.datasource.BucketsProps",
jsii_struct_bases=[],
name_mapping={},
)
class BucketsProps:
def __init__(self) -> None:
'''Properties for defining a ``DATASOURCE::OSS::Buckets``.'''
self._values: typing.Dict[builtins.str, typing.Any] = {}
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "BucketsProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class RosBuckets(
_ros_cdk_core_7adfd82f.RosResource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-oss.datasource.RosBuckets",
):
'''A ROS template type: ``DATASOURCE::OSS::Buckets``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["RosBucketsProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
'''Create a new ``DATASOURCE::OSS::Buckets``.
:param scope: - scope in which this resource is defined.
:param id: - scoped id of the resource.
:param props: - resource properties.
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__320996d2301d2110ea5198aaa206f3e5f36c412c6115e8748b6c759bec521e9d)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@jsii.member(jsii_name="renderProperties")
def _render_properties(
self,
props: typing.Mapping[builtins.str, typing.Any],
) -> typing.Mapping[builtins.str, typing.Any]:
'''
:param props: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__55ac892e57c2672b2d0bf72318f157de08cfca0fe19cb8ff43d15066e19c0996)
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))
@jsii.python.classproperty
@jsii.member(jsii_name="ROS_RESOURCE_TYPE_NAME")
def ROS_RESOURCE_TYPE_NAME(cls) -> builtins.str:
'''The resource type name for this resource class.'''
return typing.cast(builtins.str, jsii.sget(cls, "ROS_RESOURCE_TYPE_NAME"))
@builtins.property
@jsii.member(jsii_name="attrBucketNames")
def attr_bucket_names(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: BucketNames: The list of bucket names.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrBucketNames"))
@builtins.property
@jsii.member(jsii_name="attrBuckets")
def attr_buckets(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: Buckets: The list of buckets.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrBuckets"))
@builtins.property
@jsii.member(jsii_name="rosProperties")
def _ros_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "rosProperties"))
@builtins.property
@jsii.member(jsii_name="enableResourcePropertyConstraint")
def enable_resource_property_constraint(self) -> builtins.bool:
return typing.cast(builtins.bool, jsii.get(self, "enableResourcePropertyConstraint"))
@enable_resource_property_constraint.setter
def enable_resource_property_constraint(self, value: builtins.bool) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__50fcbd39783ed83622a002f567381dab9c4ba0e48b1a4e21d3a18298fa212d8d)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "enableResourcePropertyConstraint", value)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-oss.datasource.RosBucketsProps",
jsii_struct_bases=[],
name_mapping={},
)
class RosBucketsProps:
def __init__(self) -> None:
'''Properties for defining a ``DATASOURCE::OSS::Buckets``.'''
self._values: typing.Dict[builtins.str, typing.Any] = {}
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "RosBucketsProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
__all__ = [
"Buckets",
"BucketsProps",
"RosBuckets",
"RosBucketsProps",
]
publication.publish()
def _typecheckingstub__3696a81047d1e89e2381552d25b73ccb260719952ad3a1b5353ca2e4df677516(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Optional[typing.Union[BucketsProps, typing.Dict[builtins.str, typing.Any]]] = None,
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__320996d2301d2110ea5198aaa206f3e5f36c412c6115e8748b6c759bec521e9d(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[RosBucketsProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__55ac892e57c2672b2d0bf72318f157de08cfca0fe19cb8ff43d15066e19c0996(
props: typing.Mapping[builtins.str, typing.Any],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__50fcbd39783ed83622a002f567381dab9c4ba0e48b1a4e21d3a18298fa212d8d(
value: builtins.bool,
) -> None:
"""Type checking stubs"""
pass | /ros-cdk-oss-1.0.17.tar.gz/ros-cdk-oss-1.0.17/src/ros_cdk_oss/datasource/__init__.py | 0.65368 | 0.169543 | __init__.py | pypi |
import abc
import builtins
import datetime
import enum
import typing
import jsii
import publication
import typing_extensions
from typeguard import check_type
from .._jsii import *
import ros_cdk_core as _ros_cdk_core_7adfd82f
class Instances(
_ros_cdk_core_7adfd82f.Resource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-ots.datasource.Instances",
):
'''A ROS resource type: ``DATASOURCE::OTS::Instances``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Optional[typing.Union["InstancesProps", typing.Dict[builtins.str, typing.Any]]] = None,
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
'''Create a new ``DATASOURCE::OTS::Instances``.
Param scope - scope in which this resource is defined
Param id - scoped id of the resource
Param props - resource properties
:param scope: -
:param id: -
:param props: -
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__7412c5e44a515a938cf8ad0bbb1e5d99b34cd2df50e86a6fd83927f44ced9e41)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@builtins.property
@jsii.member(jsii_name="attrInstanceNames")
def attr_instance_names(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute InstanceNames: The list of instance names.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrInstanceNames"))
@builtins.property
@jsii.member(jsii_name="attrInstances")
def attr_instances(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute Instances: The list of instances.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrInstances"))
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-ots.datasource.InstancesProps",
jsii_struct_bases=[],
name_mapping={"instance_name": "instanceName", "status": "status"},
)
class InstancesProps:
def __init__(
self,
*,
instance_name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
status: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``DATASOURCE::OTS::Instances``.
:param instance_name: Property instanceName: The name of instance.
:param status: Property status: The status of instance.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__e8bb41ae1caab6226ecc01879f202107140c927e3b8aa1c2d029acc1ecb49c52)
check_type(argname="argument instance_name", value=instance_name, expected_type=type_hints["instance_name"])
check_type(argname="argument status", value=status, expected_type=type_hints["status"])
self._values: typing.Dict[builtins.str, typing.Any] = {}
if instance_name is not None:
self._values["instance_name"] = instance_name
if status is not None:
self._values["status"] = status
@builtins.property
def instance_name(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property instanceName: The name of instance.'''
result = self._values.get("instance_name")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def status(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property status: The status of instance.'''
result = self._values.get("status")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "InstancesProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class RosInstances(
_ros_cdk_core_7adfd82f.RosResource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-ots.datasource.RosInstances",
):
'''A ROS template type: ``DATASOURCE::OTS::Instances``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["RosInstancesProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
'''Create a new ``DATASOURCE::OTS::Instances``.
:param scope: - scope in which this resource is defined.
:param id: - scoped id of the resource.
:param props: - resource properties.
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__2da198d681d1a4457797517c483c3d8e25329a796210a499b41c3da4a8d89edc)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@jsii.member(jsii_name="renderProperties")
def _render_properties(
self,
props: typing.Mapping[builtins.str, typing.Any],
) -> typing.Mapping[builtins.str, typing.Any]:
'''
:param props: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__d0f1116f9c13a80b2bf6fde23ac4cdc20ed9f52fe08812ef83df28f0e96e9884)
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))
@jsii.python.classproperty
@jsii.member(jsii_name="ROS_RESOURCE_TYPE_NAME")
def ROS_RESOURCE_TYPE_NAME(cls) -> builtins.str:
'''The resource type name for this resource class.'''
return typing.cast(builtins.str, jsii.sget(cls, "ROS_RESOURCE_TYPE_NAME"))
@builtins.property
@jsii.member(jsii_name="attrInstanceNames")
def attr_instance_names(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: InstanceNames: The list of instance names.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrInstanceNames"))
@builtins.property
@jsii.member(jsii_name="attrInstances")
def attr_instances(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: Instances: The list of instances.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrInstances"))
@builtins.property
@jsii.member(jsii_name="rosProperties")
def _ros_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "rosProperties"))
@builtins.property
@jsii.member(jsii_name="enableResourcePropertyConstraint")
def enable_resource_property_constraint(self) -> builtins.bool:
return typing.cast(builtins.bool, jsii.get(self, "enableResourcePropertyConstraint"))
@enable_resource_property_constraint.setter
def enable_resource_property_constraint(self, value: builtins.bool) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__cd05a8c0f551d70e9995cf241d69ca0c559dad1ed365bec25c62e8c93b10e90f)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "enableResourcePropertyConstraint", value)
@builtins.property
@jsii.member(jsii_name="instanceName")
def instance_name(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: instanceName: The name of instance.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "instanceName"))
@instance_name.setter
def instance_name(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__38f0b6bf792731fd884e3a85115bc8cc27b414a87d900c37e7f983808f3df5ea)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "instanceName", value)
@builtins.property
@jsii.member(jsii_name="status")
def status(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: status: The status of instance.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "status"))
@status.setter
def status(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__873f68954cf4a081cbdcbcad99e5889cc21abe044cfea240057d7ea132071074)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "status", value)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-ots.datasource.RosInstancesProps",
jsii_struct_bases=[],
name_mapping={"instance_name": "instanceName", "status": "status"},
)
class RosInstancesProps:
def __init__(
self,
*,
instance_name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
status: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``DATASOURCE::OTS::Instances``.
:param instance_name:
:param status:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__2b6a07b1e4c91fef45dbcc0381d98471958993c2075fc325bb0dabfa025448f4)
check_type(argname="argument instance_name", value=instance_name, expected_type=type_hints["instance_name"])
check_type(argname="argument status", value=status, expected_type=type_hints["status"])
self._values: typing.Dict[builtins.str, typing.Any] = {}
if instance_name is not None:
self._values["instance_name"] = instance_name
if status is not None:
self._values["status"] = status
@builtins.property
def instance_name(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: instanceName: The name of instance.
'''
result = self._values.get("instance_name")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def status(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: status: The status of instance.
'''
result = self._values.get("status")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "RosInstancesProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class RosTables(
_ros_cdk_core_7adfd82f.RosResource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-ots.datasource.RosTables",
):
'''A ROS template type: ``DATASOURCE::OTS::Tables``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["RosTablesProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
'''Create a new ``DATASOURCE::OTS::Tables``.
:param scope: - scope in which this resource is defined.
:param id: - scoped id of the resource.
:param props: - resource properties.
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__96cc8f6fbcb723bfd511d3d49f8e3f883fe0450adf2be5405a467fd4698f5089)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@jsii.member(jsii_name="renderProperties")
def _render_properties(
self,
props: typing.Mapping[builtins.str, typing.Any],
) -> typing.Mapping[builtins.str, typing.Any]:
'''
:param props: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__ff98cbdbbd7a003908e39433a8be6f2f01810ccfa75e3641dd747674afe7febf)
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))
@jsii.python.classproperty
@jsii.member(jsii_name="ROS_RESOURCE_TYPE_NAME")
def ROS_RESOURCE_TYPE_NAME(cls) -> builtins.str:
'''The resource type name for this resource class.'''
return typing.cast(builtins.str, jsii.sget(cls, "ROS_RESOURCE_TYPE_NAME"))
@builtins.property
@jsii.member(jsii_name="attrTableNames")
def attr_table_names(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: TableNames: The list of table names.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrTableNames"))
@builtins.property
@jsii.member(jsii_name="attrTables")
def attr_tables(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: Tables: The list of tables.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrTables"))
@builtins.property
@jsii.member(jsii_name="rosProperties")
def _ros_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "rosProperties"))
@builtins.property
@jsii.member(jsii_name="enableResourcePropertyConstraint")
def enable_resource_property_constraint(self) -> builtins.bool:
return typing.cast(builtins.bool, jsii.get(self, "enableResourcePropertyConstraint"))
@enable_resource_property_constraint.setter
def enable_resource_property_constraint(self, value: builtins.bool) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__70bf3e08b9001c7c65466166782bfd405b9d09ed9be310ac89c2acdc0aebfed6)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "enableResourcePropertyConstraint", value)
@builtins.property
@jsii.member(jsii_name="instanceName")
def instance_name(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: instanceName: The name of the instance to which the table belongs.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "instanceName"))
@instance_name.setter
def instance_name(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__1c69f033603ee40e87adb5aedd0fcc411326321d7a133fee53881e1b9a4036c7)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "instanceName", value)
@builtins.property
@jsii.member(jsii_name="tableName")
def table_name(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: tableName: The name of table.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "tableName"))
@table_name.setter
def table_name(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__fa1140fee53e4428764320085d6e535ed116510348f47b67525f447b17fd34f4)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "tableName", value)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-ots.datasource.RosTablesProps",
jsii_struct_bases=[],
name_mapping={"instance_name": "instanceName", "table_name": "tableName"},
)
class RosTablesProps:
def __init__(
self,
*,
instance_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
table_name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``DATASOURCE::OTS::Tables``.
:param instance_name:
:param table_name:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__934cdd3ac38f0c4cf2fe61055f64d21ac8a2d1a289bb87b1b33c0e5f19854480)
check_type(argname="argument instance_name", value=instance_name, expected_type=type_hints["instance_name"])
check_type(argname="argument table_name", value=table_name, expected_type=type_hints["table_name"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"instance_name": instance_name,
}
if table_name is not None:
self._values["table_name"] = table_name
@builtins.property
def instance_name(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: instanceName: The name of the instance to which the table belongs.
'''
result = self._values.get("instance_name")
assert result is not None, "Required property 'instance_name' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def table_name(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: tableName: The name of table.
'''
result = self._values.get("table_name")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "RosTablesProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class Tables(
_ros_cdk_core_7adfd82f.Resource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-ots.datasource.Tables",
):
'''A ROS resource type: ``DATASOURCE::OTS::Tables``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["TablesProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
'''Create a new ``DATASOURCE::OTS::Tables``.
Param scope - scope in which this resource is defined
Param id - scoped id of the resource
Param props - resource properties
:param scope: -
:param id: -
:param props: -
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__89eb428d50285a7e85589c5cfe78f3896eedb75327b48b59541bb6bbd2fe9833)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@builtins.property
@jsii.member(jsii_name="attrTableNames")
def attr_table_names(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute TableNames: The list of table names.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrTableNames"))
@builtins.property
@jsii.member(jsii_name="attrTables")
def attr_tables(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute Tables: The list of tables.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrTables"))
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-ots.datasource.TablesProps",
jsii_struct_bases=[],
name_mapping={"instance_name": "instanceName", "table_name": "tableName"},
)
class TablesProps:
def __init__(
self,
*,
instance_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
table_name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``DATASOURCE::OTS::Tables``.
:param instance_name: Property instanceName: The name of the instance to which the table belongs.
:param table_name: Property tableName: The name of table.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__1ffadf74ca851fa20153afd893e525c0224959ccc22e8dec92ed71d3b108b04a)
check_type(argname="argument instance_name", value=instance_name, expected_type=type_hints["instance_name"])
check_type(argname="argument table_name", value=table_name, expected_type=type_hints["table_name"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"instance_name": instance_name,
}
if table_name is not None:
self._values["table_name"] = table_name
@builtins.property
def instance_name(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property instanceName: The name of the instance to which the table belongs.'''
result = self._values.get("instance_name")
assert result is not None, "Required property 'instance_name' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def table_name(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property tableName: The name of table.'''
result = self._values.get("table_name")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "TablesProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
__all__ = [
"Instances",
"InstancesProps",
"RosInstances",
"RosInstancesProps",
"RosTables",
"RosTablesProps",
"Tables",
"TablesProps",
]
publication.publish()
def _typecheckingstub__7412c5e44a515a938cf8ad0bbb1e5d99b34cd2df50e86a6fd83927f44ced9e41(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Optional[typing.Union[InstancesProps, typing.Dict[builtins.str, typing.Any]]] = None,
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__e8bb41ae1caab6226ecc01879f202107140c927e3b8aa1c2d029acc1ecb49c52(
*,
instance_name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
status: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__2da198d681d1a4457797517c483c3d8e25329a796210a499b41c3da4a8d89edc(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[RosInstancesProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__d0f1116f9c13a80b2bf6fde23ac4cdc20ed9f52fe08812ef83df28f0e96e9884(
props: typing.Mapping[builtins.str, typing.Any],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__cd05a8c0f551d70e9995cf241d69ca0c559dad1ed365bec25c62e8c93b10e90f(
value: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__38f0b6bf792731fd884e3a85115bc8cc27b414a87d900c37e7f983808f3df5ea(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__873f68954cf4a081cbdcbcad99e5889cc21abe044cfea240057d7ea132071074(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__2b6a07b1e4c91fef45dbcc0381d98471958993c2075fc325bb0dabfa025448f4(
*,
instance_name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
status: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__96cc8f6fbcb723bfd511d3d49f8e3f883fe0450adf2be5405a467fd4698f5089(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[RosTablesProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__ff98cbdbbd7a003908e39433a8be6f2f01810ccfa75e3641dd747674afe7febf(
props: typing.Mapping[builtins.str, typing.Any],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__70bf3e08b9001c7c65466166782bfd405b9d09ed9be310ac89c2acdc0aebfed6(
value: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__1c69f033603ee40e87adb5aedd0fcc411326321d7a133fee53881e1b9a4036c7(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__fa1140fee53e4428764320085d6e535ed116510348f47b67525f447b17fd34f4(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__934cdd3ac38f0c4cf2fe61055f64d21ac8a2d1a289bb87b1b33c0e5f19854480(
*,
instance_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
table_name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__89eb428d50285a7e85589c5cfe78f3896eedb75327b48b59541bb6bbd2fe9833(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[TablesProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__1ffadf74ca851fa20153afd893e525c0224959ccc22e8dec92ed71d3b108b04a(
*,
instance_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
table_name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass | /ros-cdk-ots-1.0.17.tar.gz/ros-cdk-ots-1.0.17/src/ros_cdk_ots/datasource/__init__.py | 0.641085 | 0.162446 | __init__.py | pypi |
import abc
import builtins
import datetime
import enum
import typing
import jsii
import publication
import typing_extensions
from typeguard import check_type
from .._jsii import *
import ros_cdk_core as _ros_cdk_core_7adfd82f
class Datasets(
_ros_cdk_core_7adfd82f.Resource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-pai.datasource.Datasets",
):
'''A ROS resource type: ``DATASOURCE::PAI::Datasets``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["DatasetsProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
'''Create a new ``DATASOURCE::PAI::Datasets``.
Param scope - scope in which this resource is defined
Param id - scoped id of the resource
Param props - resource properties
:param scope: -
:param id: -
:param props: -
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__d1df24f8a5b9d4a798dff17fc6a369509d696d69de8d49fca8d96ad8c383b8ef)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@builtins.property
@jsii.member(jsii_name="attrDatasetIds")
def attr_dataset_ids(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute DatasetIds: The list of dataset IDs.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrDatasetIds"))
@builtins.property
@jsii.member(jsii_name="attrDatasets")
def attr_datasets(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute Datasets: The list of datasets.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrDatasets"))
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-pai.datasource.DatasetsProps",
jsii_struct_bases=[],
name_mapping={"workspace_id": "workspaceId", "source_id": "sourceId"},
)
class DatasetsProps:
def __init__(
self,
*,
workspace_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
source_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``DATASOURCE::PAI::Datasets``.
:param workspace_id: Property workspaceId: The ID of the workspace where the dataset is located. For details about how to obtain the workspace ID, see [ListWorkspaces](~~ 449124 ~~). If this parameter is not configured, the default workspace is used. If the default workspace does not exist, an error is reported.
:param source_id: Property sourceId: The data source ID. - When the SourceType is USER, SourceId can be customized. - When SourceType is ITAG, that is, when the iTAG module labels the data set generated by the result, SourceId is the task ID of ITAG. - When SourceType is PAI_PUBLIC_DATASET, that is, a dataset created using PAI public datasets, SourceId is empty by default.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__d92a5f4e6bc20790fd88ecb4dd061e148610f1a8c9e77642d7626df309835526)
check_type(argname="argument workspace_id", value=workspace_id, expected_type=type_hints["workspace_id"])
check_type(argname="argument source_id", value=source_id, expected_type=type_hints["source_id"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"workspace_id": workspace_id,
}
if source_id is not None:
self._values["source_id"] = source_id
@builtins.property
def workspace_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property workspaceId: The ID of the workspace where the dataset is located.
For details about how to obtain the workspace ID, see [ListWorkspaces](~~ 449124 ~~).
If this parameter is not configured, the default workspace is used. If the default workspace does not exist, an error is reported.
'''
result = self._values.get("workspace_id")
assert result is not None, "Required property 'workspace_id' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def source_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property sourceId: The data source ID.
- When the SourceType is USER, SourceId can be customized.
- When SourceType is ITAG, that is, when the iTAG module labels the data set generated by the result, SourceId is the task ID of ITAG.
- When SourceType is PAI_PUBLIC_DATASET, that is, a dataset created using PAI public datasets, SourceId is empty by default.
'''
result = self._values.get("source_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "DatasetsProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class RosDatasets(
_ros_cdk_core_7adfd82f.RosResource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-pai.datasource.RosDatasets",
):
'''A ROS template type: ``DATASOURCE::PAI::Datasets``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["RosDatasetsProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
'''Create a new ``DATASOURCE::PAI::Datasets``.
:param scope: - scope in which this resource is defined.
:param id: - scoped id of the resource.
:param props: - resource properties.
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__e041c29c7a8e48b52d63cc5d6daea7cef0b0ffcd1af89ca7fb0d3ae2c4cf220a)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@jsii.member(jsii_name="renderProperties")
def _render_properties(
self,
props: typing.Mapping[builtins.str, typing.Any],
) -> typing.Mapping[builtins.str, typing.Any]:
'''
:param props: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__6768ee4501d1e23d09e2db18e3a97be62ed91ca16f2dfbc792e6bdbdc7b72abe)
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))
@jsii.python.classproperty
@jsii.member(jsii_name="ROS_RESOURCE_TYPE_NAME")
def ROS_RESOURCE_TYPE_NAME(cls) -> builtins.str:
'''The resource type name for this resource class.'''
return typing.cast(builtins.str, jsii.sget(cls, "ROS_RESOURCE_TYPE_NAME"))
@builtins.property
@jsii.member(jsii_name="attrDatasetIds")
def attr_dataset_ids(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: DatasetIds: The list of dataset IDs.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrDatasetIds"))
@builtins.property
@jsii.member(jsii_name="attrDatasets")
def attr_datasets(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: Datasets: The list of datasets.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrDatasets"))
@builtins.property
@jsii.member(jsii_name="rosProperties")
def _ros_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "rosProperties"))
@builtins.property
@jsii.member(jsii_name="enableResourcePropertyConstraint")
def enable_resource_property_constraint(self) -> builtins.bool:
return typing.cast(builtins.bool, jsii.get(self, "enableResourcePropertyConstraint"))
@enable_resource_property_constraint.setter
def enable_resource_property_constraint(self, value: builtins.bool) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__8ea40bd11f80f33c53418c190a03a7aba5d0038f33124a0d361c8850f0274f3e)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "enableResourcePropertyConstraint", value)
@builtins.property
@jsii.member(jsii_name="workspaceId")
def workspace_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
workspaceId: The ID of the workspace where the dataset is located. For details about how to obtain the workspace ID, see [ListWorkspaces](~~ 449124 ~~).
If this parameter is not configured, the default workspace is used. If the default workspace does not exist, an error is reported.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "workspaceId"))
@workspace_id.setter
def workspace_id(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__541d419df250a871e8c25c98f11ef8cdbe15ae17775411a3778c91f48d3988cb)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "workspaceId", value)
@builtins.property
@jsii.member(jsii_name="sourceId")
def source_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
sourceId: The data source ID.
- When the SourceType is USER, SourceId can be customized.
- When SourceType is ITAG, that is, when the iTAG module labels the data set generated by the result, SourceId is the task ID of ITAG.
- When SourceType is PAI_PUBLIC_DATASET, that is, a dataset created using PAI public datasets, SourceId is empty by default.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "sourceId"))
@source_id.setter
def source_id(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__41b0b618fbe2fe4b29e198220c81a9bc61feeea6aab2c64543f5c999c98f20a0)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "sourceId", value)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-pai.datasource.RosDatasetsProps",
jsii_struct_bases=[],
name_mapping={"workspace_id": "workspaceId", "source_id": "sourceId"},
)
class RosDatasetsProps:
def __init__(
self,
*,
workspace_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
source_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``DATASOURCE::PAI::Datasets``.
:param workspace_id:
:param source_id:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__de7ba74d972983299e2f45c070da2882c2783c6b9ebefcf1db8ba3a3cf45a49b)
check_type(argname="argument workspace_id", value=workspace_id, expected_type=type_hints["workspace_id"])
check_type(argname="argument source_id", value=source_id, expected_type=type_hints["source_id"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"workspace_id": workspace_id,
}
if source_id is not None:
self._values["source_id"] = source_id
@builtins.property
def workspace_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
workspaceId: The ID of the workspace where the dataset is located. For details about how to obtain the workspace ID, see [ListWorkspaces](~~ 449124 ~~).
If this parameter is not configured, the default workspace is used. If the default workspace does not exist, an error is reported.
'''
result = self._values.get("workspace_id")
assert result is not None, "Required property 'workspace_id' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def source_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
sourceId: The data source ID.
- When the SourceType is USER, SourceId can be customized.
- When SourceType is ITAG, that is, when the iTAG module labels the data set generated by the result, SourceId is the task ID of ITAG.
- When SourceType is PAI_PUBLIC_DATASET, that is, a dataset created using PAI public datasets, SourceId is empty by default.
'''
result = self._values.get("source_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "RosDatasetsProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class RosServices(
_ros_cdk_core_7adfd82f.RosResource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-pai.datasource.RosServices",
):
'''A ROS template type: ``DATASOURCE::PAI::Services``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["RosServicesProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
'''Create a new ``DATASOURCE::PAI::Services``.
:param scope: - scope in which this resource is defined.
:param id: - scoped id of the resource.
:param props: - resource properties.
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__8e2c1b1e14dbc8d731b7b7c212be91d56afce260c982e82a7063db232a254bfc)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@jsii.member(jsii_name="renderProperties")
def _render_properties(
self,
props: typing.Mapping[builtins.str, typing.Any],
) -> typing.Mapping[builtins.str, typing.Any]:
'''
:param props: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__147b4352ad22b1ef600141d2b4703df154a6e78ee85b103d0d3baf872df69381)
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))
@jsii.python.classproperty
@jsii.member(jsii_name="ROS_RESOURCE_TYPE_NAME")
def ROS_RESOURCE_TYPE_NAME(cls) -> builtins.str:
'''The resource type name for this resource class.'''
return typing.cast(builtins.str, jsii.sget(cls, "ROS_RESOURCE_TYPE_NAME"))
@builtins.property
@jsii.member(jsii_name="attrServiceNames")
def attr_service_names(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: ServiceNames: The list of service names.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrServiceNames"))
@builtins.property
@jsii.member(jsii_name="attrServices")
def attr_services(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: Services: The list of services.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrServices"))
@builtins.property
@jsii.member(jsii_name="rosProperties")
def _ros_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "rosProperties"))
@builtins.property
@jsii.member(jsii_name="enableResourcePropertyConstraint")
def enable_resource_property_constraint(self) -> builtins.bool:
return typing.cast(builtins.bool, jsii.get(self, "enableResourcePropertyConstraint"))
@enable_resource_property_constraint.setter
def enable_resource_property_constraint(self, value: builtins.bool) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__1031544b263fc82885ec4104e06284a7511a94005257f2f8b79adc8ffc6d5427)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "enableResourcePropertyConstraint", value)
@builtins.property
@jsii.member(jsii_name="labels")
def labels(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]]:
'''
:Property: labels: Service Tag.
'''
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]], jsii.get(self, "labels"))
@labels.setter
def labels(
self,
value: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__d7dcaada7d939d9a02d7c8c81f2a066bc479a9dcdfc5d744078b00e256f7c5dc)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "labels", value)
@builtins.property
@jsii.member(jsii_name="serviceName")
def service_name(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: serviceName: Service Name.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "serviceName"))
@service_name.setter
def service_name(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__13a08cad11de83b2267998102186707cc7fd23bc017c34d4f21b7f5731d5eb03)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "serviceName", value)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-pai.datasource.RosServicesProps",
jsii_struct_bases=[],
name_mapping={"labels": "labels", "service_name": "serviceName"},
)
class RosServicesProps:
def __init__(
self,
*,
labels: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]] = None,
service_name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``DATASOURCE::PAI::Services``.
:param labels:
:param service_name:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__2609da1a6495816c6f7bca69ff9043cff4655dc07009e23cdb83540c9c4b5a7e)
check_type(argname="argument labels", value=labels, expected_type=type_hints["labels"])
check_type(argname="argument service_name", value=service_name, expected_type=type_hints["service_name"])
self._values: typing.Dict[builtins.str, typing.Any] = {}
if labels is not None:
self._values["labels"] = labels
if service_name is not None:
self._values["service_name"] = service_name
@builtins.property
def labels(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]]:
'''
:Property: labels: Service Tag.
'''
result = self._values.get("labels")
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]], result)
@builtins.property
def service_name(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: serviceName: Service Name.
'''
result = self._values.get("service_name")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "RosServicesProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class RosWorkspaces(
_ros_cdk_core_7adfd82f.RosResource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-pai.datasource.RosWorkspaces",
):
'''A ROS template type: ``DATASOURCE::PAI::Workspaces``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["RosWorkspacesProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
'''Create a new ``DATASOURCE::PAI::Workspaces``.
:param scope: - scope in which this resource is defined.
:param id: - scoped id of the resource.
:param props: - resource properties.
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__93a8a755c2fb094427b9c642c27b73a9447c1616f1cbca3a5f07170e34faeff8)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@jsii.member(jsii_name="renderProperties")
def _render_properties(
self,
props: typing.Mapping[builtins.str, typing.Any],
) -> typing.Mapping[builtins.str, typing.Any]:
'''
:param props: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__774ebd18e3b3fde7ed93f1f83ac324d332074d80ce1730845c4ea4dc54e3da1f)
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))
@jsii.python.classproperty
@jsii.member(jsii_name="ROS_RESOURCE_TYPE_NAME")
def ROS_RESOURCE_TYPE_NAME(cls) -> builtins.str:
'''The resource type name for this resource class.'''
return typing.cast(builtins.str, jsii.sget(cls, "ROS_RESOURCE_TYPE_NAME"))
@builtins.property
@jsii.member(jsii_name="attrWorkspaceIds")
def attr_workspace_ids(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: WorkspaceIds: The list of workspace IDs.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrWorkspaceIds"))
@builtins.property
@jsii.member(jsii_name="attrWorkspaces")
def attr_workspaces(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: Workspaces: The list of workspaces.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrWorkspaces"))
@builtins.property
@jsii.member(jsii_name="rosProperties")
def _ros_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "rosProperties"))
@builtins.property
@jsii.member(jsii_name="enableResourcePropertyConstraint")
def enable_resource_property_constraint(self) -> builtins.bool:
return typing.cast(builtins.bool, jsii.get(self, "enableResourcePropertyConstraint"))
@enable_resource_property_constraint.setter
def enable_resource_property_constraint(self, value: builtins.bool) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__38b8022d62a3379ee28a290a17c35a67ff749bbca95891082d8311627827d78f)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "enableResourcePropertyConstraint", value)
@builtins.property
@jsii.member(jsii_name="workspaceId")
def workspace_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: workspaceId: The ID of the workspace.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "workspaceId"))
@workspace_id.setter
def workspace_id(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__81af7cc3d3f24e0b15434743c279ec53b375b5d314f6b66ad6c9c8b20d33b5a1)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "workspaceId", value)
@builtins.property
@jsii.member(jsii_name="workspaceName")
def workspace_name(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
workspaceName: The workspace name. The format is as follows:
- 3 to 23 characters in length and can contain letters, underscores, or numbers.
- Must start with a large or small letter.
- Unique in the current region.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "workspaceName"))
@workspace_name.setter
def workspace_name(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__2f27f88a51cf0b512d4f725202430583914c512660f89e697701daa11c7434f7)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "workspaceName", value)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-pai.datasource.RosWorkspacesProps",
jsii_struct_bases=[],
name_mapping={"workspace_id": "workspaceId", "workspace_name": "workspaceName"},
)
class RosWorkspacesProps:
def __init__(
self,
*,
workspace_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
workspace_name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``DATASOURCE::PAI::Workspaces``.
:param workspace_id:
:param workspace_name:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__0d760d97c9c602f9e62fe51dc6dbb2272f59e699c16fbe749e3425198c698c1a)
check_type(argname="argument workspace_id", value=workspace_id, expected_type=type_hints["workspace_id"])
check_type(argname="argument workspace_name", value=workspace_name, expected_type=type_hints["workspace_name"])
self._values: typing.Dict[builtins.str, typing.Any] = {}
if workspace_id is not None:
self._values["workspace_id"] = workspace_id
if workspace_name is not None:
self._values["workspace_name"] = workspace_name
@builtins.property
def workspace_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: workspaceId: The ID of the workspace.
'''
result = self._values.get("workspace_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def workspace_name(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
workspaceName: The workspace name. The format is as follows:
- 3 to 23 characters in length and can contain letters, underscores, or numbers.
- Must start with a large or small letter.
- Unique in the current region.
'''
result = self._values.get("workspace_name")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "RosWorkspacesProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class Services(
_ros_cdk_core_7adfd82f.Resource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-pai.datasource.Services",
):
'''A ROS resource type: ``DATASOURCE::PAI::Services``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Optional[typing.Union["ServicesProps", typing.Dict[builtins.str, typing.Any]]] = None,
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
'''Create a new ``DATASOURCE::PAI::Services``.
Param scope - scope in which this resource is defined
Param id - scoped id of the resource
Param props - resource properties
:param scope: -
:param id: -
:param props: -
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__7dfdc8bd7471ecd1c6af8f392089c76d36999259a20ee449fb4918f0518351a2)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@builtins.property
@jsii.member(jsii_name="attrServiceNames")
def attr_service_names(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute ServiceNames: The list of service names.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrServiceNames"))
@builtins.property
@jsii.member(jsii_name="attrServices")
def attr_services(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute Services: The list of services.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrServices"))
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-pai.datasource.ServicesProps",
jsii_struct_bases=[],
name_mapping={"labels": "labels", "service_name": "serviceName"},
)
class ServicesProps:
def __init__(
self,
*,
labels: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]] = None,
service_name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``DATASOURCE::PAI::Services``.
:param labels: Property labels: Service Tag.
:param service_name: Property serviceName: Service Name.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__49237c3ccc446959a39aa651ee95898e86a68b3f16e79adee304064a2007d49d)
check_type(argname="argument labels", value=labels, expected_type=type_hints["labels"])
check_type(argname="argument service_name", value=service_name, expected_type=type_hints["service_name"])
self._values: typing.Dict[builtins.str, typing.Any] = {}
if labels is not None:
self._values["labels"] = labels
if service_name is not None:
self._values["service_name"] = service_name
@builtins.property
def labels(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]]:
'''Property labels: Service Tag.'''
result = self._values.get("labels")
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]], result)
@builtins.property
def service_name(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property serviceName: Service Name.'''
result = self._values.get("service_name")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "ServicesProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class Workspaces(
_ros_cdk_core_7adfd82f.Resource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-pai.datasource.Workspaces",
):
'''A ROS resource type: ``DATASOURCE::PAI::Workspaces``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Optional[typing.Union["WorkspacesProps", typing.Dict[builtins.str, typing.Any]]] = None,
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
'''Create a new ``DATASOURCE::PAI::Workspaces``.
Param scope - scope in which this resource is defined
Param id - scoped id of the resource
Param props - resource properties
:param scope: -
:param id: -
:param props: -
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__ac3f7d621923c2d6e729f6ed707e8e2d725e62d59a5df3e896f57475a71b9bb9)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@builtins.property
@jsii.member(jsii_name="attrWorkspaceIds")
def attr_workspace_ids(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute WorkspaceIds: The list of workspace IDs.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrWorkspaceIds"))
@builtins.property
@jsii.member(jsii_name="attrWorkspaces")
def attr_workspaces(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute Workspaces: The list of workspaces.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrWorkspaces"))
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-pai.datasource.WorkspacesProps",
jsii_struct_bases=[],
name_mapping={"workspace_id": "workspaceId", "workspace_name": "workspaceName"},
)
class WorkspacesProps:
def __init__(
self,
*,
workspace_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
workspace_name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``DATASOURCE::PAI::Workspaces``.
:param workspace_id: Property workspaceId: The ID of the workspace.
:param workspace_name: Property workspaceName: The workspace name. The format is as follows: - 3 to 23 characters in length and can contain letters, underscores, or numbers. - Must start with a large or small letter. - Unique in the current region.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__4cdc744a1f128053ab6f1a26fd22319350ff92eb9c95dff0f360a2df634fc123)
check_type(argname="argument workspace_id", value=workspace_id, expected_type=type_hints["workspace_id"])
check_type(argname="argument workspace_name", value=workspace_name, expected_type=type_hints["workspace_name"])
self._values: typing.Dict[builtins.str, typing.Any] = {}
if workspace_id is not None:
self._values["workspace_id"] = workspace_id
if workspace_name is not None:
self._values["workspace_name"] = workspace_name
@builtins.property
def workspace_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property workspaceId: The ID of the workspace.'''
result = self._values.get("workspace_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def workspace_name(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property workspaceName: The workspace name.
The format is as follows:
- 3 to 23 characters in length and can contain letters, underscores, or numbers.
- Must start with a large or small letter.
- Unique in the current region.
'''
result = self._values.get("workspace_name")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "WorkspacesProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
__all__ = [
"Datasets",
"DatasetsProps",
"RosDatasets",
"RosDatasetsProps",
"RosServices",
"RosServicesProps",
"RosWorkspaces",
"RosWorkspacesProps",
"Services",
"ServicesProps",
"Workspaces",
"WorkspacesProps",
]
publication.publish()
def _typecheckingstub__d1df24f8a5b9d4a798dff17fc6a369509d696d69de8d49fca8d96ad8c383b8ef(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[DatasetsProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__d92a5f4e6bc20790fd88ecb4dd061e148610f1a8c9e77642d7626df309835526(
*,
workspace_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
source_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__e041c29c7a8e48b52d63cc5d6daea7cef0b0ffcd1af89ca7fb0d3ae2c4cf220a(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[RosDatasetsProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__6768ee4501d1e23d09e2db18e3a97be62ed91ca16f2dfbc792e6bdbdc7b72abe(
props: typing.Mapping[builtins.str, typing.Any],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__8ea40bd11f80f33c53418c190a03a7aba5d0038f33124a0d361c8850f0274f3e(
value: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__541d419df250a871e8c25c98f11ef8cdbe15ae17775411a3778c91f48d3988cb(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__41b0b618fbe2fe4b29e198220c81a9bc61feeea6aab2c64543f5c999c98f20a0(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__de7ba74d972983299e2f45c070da2882c2783c6b9ebefcf1db8ba3a3cf45a49b(
*,
workspace_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
source_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__8e2c1b1e14dbc8d731b7b7c212be91d56afce260c982e82a7063db232a254bfc(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[RosServicesProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__147b4352ad22b1ef600141d2b4703df154a6e78ee85b103d0d3baf872df69381(
props: typing.Mapping[builtins.str, typing.Any],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__1031544b263fc82885ec4104e06284a7511a94005257f2f8b79adc8ffc6d5427(
value: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__d7dcaada7d939d9a02d7c8c81f2a066bc479a9dcdfc5d744078b00e256f7c5dc(
value: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__13a08cad11de83b2267998102186707cc7fd23bc017c34d4f21b7f5731d5eb03(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__2609da1a6495816c6f7bca69ff9043cff4655dc07009e23cdb83540c9c4b5a7e(
*,
labels: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]] = None,
service_name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__93a8a755c2fb094427b9c642c27b73a9447c1616f1cbca3a5f07170e34faeff8(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[RosWorkspacesProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__774ebd18e3b3fde7ed93f1f83ac324d332074d80ce1730845c4ea4dc54e3da1f(
props: typing.Mapping[builtins.str, typing.Any],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__38b8022d62a3379ee28a290a17c35a67ff749bbca95891082d8311627827d78f(
value: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__81af7cc3d3f24e0b15434743c279ec53b375b5d314f6b66ad6c9c8b20d33b5a1(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__2f27f88a51cf0b512d4f725202430583914c512660f89e697701daa11c7434f7(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__0d760d97c9c602f9e62fe51dc6dbb2272f59e699c16fbe749e3425198c698c1a(
*,
workspace_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
workspace_name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__7dfdc8bd7471ecd1c6af8f392089c76d36999259a20ee449fb4918f0518351a2(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Optional[typing.Union[ServicesProps, typing.Dict[builtins.str, typing.Any]]] = None,
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__49237c3ccc446959a39aa651ee95898e86a68b3f16e79adee304064a2007d49d(
*,
labels: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]] = None,
service_name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__ac3f7d621923c2d6e729f6ed707e8e2d725e62d59a5df3e896f57475a71b9bb9(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Optional[typing.Union[WorkspacesProps, typing.Dict[builtins.str, typing.Any]]] = None,
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__4cdc744a1f128053ab6f1a26fd22319350ff92eb9c95dff0f360a2df634fc123(
*,
workspace_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
workspace_name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass | /ros-cdk-pai-1.0.17.tar.gz/ros-cdk-pai-1.0.17/src/ros_cdk_pai/datasource/__init__.py | 0.672869 | 0.218763 | __init__.py | pypi |
import abc
import builtins
import datetime
import enum
import typing
import jsii
import publication
import typing_extensions
from typeguard import check_type
from .._jsii import *
import ros_cdk_core as _ros_cdk_core_7adfd82f
class Instances(
_ros_cdk_core_7adfd82f.Resource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-paidswapi.datasource.Instances",
):
'''A ROS resource type: ``DATASOURCE::PaiDswApi::Instances``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Optional[typing.Union["InstancesProps", typing.Dict[builtins.str, typing.Any]]] = None,
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
'''Create a new ``DATASOURCE::PaiDswApi::Instances``.
Param scope - scope in which this resource is defined
Param id - scoped id of the resource
Param props - resource properties
:param scope: -
:param id: -
:param props: -
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__dcfc81baaa29ca9fca167d106ce999dabec23a90547835647472b04d05d617bb)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@builtins.property
@jsii.member(jsii_name="attrInstanceIds")
def attr_instance_ids(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute InstanceIds: The list of instance IDs.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrInstanceIds"))
@builtins.property
@jsii.member(jsii_name="attrInstances")
def attr_instances(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute Instances: The list of instances.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrInstances"))
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-paidswapi.datasource.InstancesProps",
jsii_struct_bases=[],
name_mapping={
"accessibility": "accessibility",
"instance_id": "instanceId",
"instance_name": "instanceName",
"workspace_id": "workspaceId",
},
)
class InstancesProps:
def __init__(
self,
*,
accessibility: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
instance_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
instance_name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
workspace_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``DATASOURCE::PaiDswApi::Instances``.
:param accessibility: Property accessibility: Whether the workspace is visible to others.
:param instance_id: Property instanceId: The first ID of the resource.
:param instance_name: Property instanceName: The instance name.
:param workspace_id: Property workspaceId: The Id of the workspace.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__16d4d40fa9a56fa0a4f22e3f3f62e5a6123e52bc0b20763feb77b2dcc33467f9)
check_type(argname="argument accessibility", value=accessibility, expected_type=type_hints["accessibility"])
check_type(argname="argument instance_id", value=instance_id, expected_type=type_hints["instance_id"])
check_type(argname="argument instance_name", value=instance_name, expected_type=type_hints["instance_name"])
check_type(argname="argument workspace_id", value=workspace_id, expected_type=type_hints["workspace_id"])
self._values: typing.Dict[builtins.str, typing.Any] = {}
if accessibility is not None:
self._values["accessibility"] = accessibility
if instance_id is not None:
self._values["instance_id"] = instance_id
if instance_name is not None:
self._values["instance_name"] = instance_name
if workspace_id is not None:
self._values["workspace_id"] = workspace_id
@builtins.property
def accessibility(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property accessibility: Whether the workspace is visible to others.'''
result = self._values.get("accessibility")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def instance_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property instanceId: The first ID of the resource.'''
result = self._values.get("instance_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def instance_name(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property instanceName: The instance name.'''
result = self._values.get("instance_name")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def workspace_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property workspaceId: The Id of the workspace.'''
result = self._values.get("workspace_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "InstancesProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class RosInstances(
_ros_cdk_core_7adfd82f.RosResource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-paidswapi.datasource.RosInstances",
):
'''A ROS template type: ``DATASOURCE::PaiDswApi::Instances``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["RosInstancesProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
'''Create a new ``DATASOURCE::PaiDswApi::Instances``.
:param scope: - scope in which this resource is defined.
:param id: - scoped id of the resource.
:param props: - resource properties.
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__0d862e58b8b8b927f95968a9db5bd60ed6d482be73ae2f06ce1f557dc9dcc648)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@jsii.member(jsii_name="renderProperties")
def _render_properties(
self,
props: typing.Mapping[builtins.str, typing.Any],
) -> typing.Mapping[builtins.str, typing.Any]:
'''
:param props: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__a09f9b029b212386836896f10919253454308f1b6fc52366f64df42638688d8e)
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))
@jsii.python.classproperty
@jsii.member(jsii_name="ROS_RESOURCE_TYPE_NAME")
def ROS_RESOURCE_TYPE_NAME(cls) -> builtins.str:
'''The resource type name for this resource class.'''
return typing.cast(builtins.str, jsii.sget(cls, "ROS_RESOURCE_TYPE_NAME"))
@builtins.property
@jsii.member(jsii_name="attrInstanceIds")
def attr_instance_ids(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: InstanceIds: The list of instance IDs.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrInstanceIds"))
@builtins.property
@jsii.member(jsii_name="attrInstances")
def attr_instances(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: Instances: The list of instances.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrInstances"))
@builtins.property
@jsii.member(jsii_name="rosProperties")
def _ros_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "rosProperties"))
@builtins.property
@jsii.member(jsii_name="enableResourcePropertyConstraint")
def enable_resource_property_constraint(self) -> builtins.bool:
return typing.cast(builtins.bool, jsii.get(self, "enableResourcePropertyConstraint"))
@enable_resource_property_constraint.setter
def enable_resource_property_constraint(self, value: builtins.bool) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__76f2f6b5e37676c539780b6f0f4a4742d9a1184a39f9cb6817a3787c9bb85ded)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "enableResourcePropertyConstraint", value)
@builtins.property
@jsii.member(jsii_name="accessibility")
def accessibility(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: accessibility: Whether the workspace is visible to others.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "accessibility"))
@accessibility.setter
def accessibility(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__9cb17eebb32c32b9d08fc66489f24bd8c56f49463818b70bcfb83e2e232819cb)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "accessibility", value)
@builtins.property
@jsii.member(jsii_name="instanceId")
def instance_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: instanceId: The first ID of the resource.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "instanceId"))
@instance_id.setter
def instance_id(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__44419752219e0135c53d30b7100b8d8f3b4b0088806c4c81121567f97662c399)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "instanceId", value)
@builtins.property
@jsii.member(jsii_name="instanceName")
def instance_name(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: instanceName: The instance name.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "instanceName"))
@instance_name.setter
def instance_name(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__d9b90cf45f21bf60b55f99e255222e86a5ccf0414ecd3cae2f60c12c9804e79a)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "instanceName", value)
@builtins.property
@jsii.member(jsii_name="workspaceId")
def workspace_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: workspaceId: The Id of the workspace.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "workspaceId"))
@workspace_id.setter
def workspace_id(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__57f6216af20ff36f59d10a2b63528baf39b556e6fdcf8818d5fff37e86d50c4a)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "workspaceId", value)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-paidswapi.datasource.RosInstancesProps",
jsii_struct_bases=[],
name_mapping={
"accessibility": "accessibility",
"instance_id": "instanceId",
"instance_name": "instanceName",
"workspace_id": "workspaceId",
},
)
class RosInstancesProps:
def __init__(
self,
*,
accessibility: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
instance_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
instance_name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
workspace_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``DATASOURCE::PaiDswApi::Instances``.
:param accessibility:
:param instance_id:
:param instance_name:
:param workspace_id:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__c891543697d38d639547e7b6c90c682bf1fdda0fd4a92b95abc07ff801d29a92)
check_type(argname="argument accessibility", value=accessibility, expected_type=type_hints["accessibility"])
check_type(argname="argument instance_id", value=instance_id, expected_type=type_hints["instance_id"])
check_type(argname="argument instance_name", value=instance_name, expected_type=type_hints["instance_name"])
check_type(argname="argument workspace_id", value=workspace_id, expected_type=type_hints["workspace_id"])
self._values: typing.Dict[builtins.str, typing.Any] = {}
if accessibility is not None:
self._values["accessibility"] = accessibility
if instance_id is not None:
self._values["instance_id"] = instance_id
if instance_name is not None:
self._values["instance_name"] = instance_name
if workspace_id is not None:
self._values["workspace_id"] = workspace_id
@builtins.property
def accessibility(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: accessibility: Whether the workspace is visible to others.
'''
result = self._values.get("accessibility")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def instance_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: instanceId: The first ID of the resource.
'''
result = self._values.get("instance_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def instance_name(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: instanceName: The instance name.
'''
result = self._values.get("instance_name")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def workspace_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: workspaceId: The Id of the workspace.
'''
result = self._values.get("workspace_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "RosInstancesProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
__all__ = [
"Instances",
"InstancesProps",
"RosInstances",
"RosInstancesProps",
]
publication.publish()
def _typecheckingstub__dcfc81baaa29ca9fca167d106ce999dabec23a90547835647472b04d05d617bb(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Optional[typing.Union[InstancesProps, typing.Dict[builtins.str, typing.Any]]] = None,
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__16d4d40fa9a56fa0a4f22e3f3f62e5a6123e52bc0b20763feb77b2dcc33467f9(
*,
accessibility: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
instance_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
instance_name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
workspace_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__0d862e58b8b8b927f95968a9db5bd60ed6d482be73ae2f06ce1f557dc9dcc648(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[RosInstancesProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__a09f9b029b212386836896f10919253454308f1b6fc52366f64df42638688d8e(
props: typing.Mapping[builtins.str, typing.Any],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__76f2f6b5e37676c539780b6f0f4a4742d9a1184a39f9cb6817a3787c9bb85ded(
value: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__9cb17eebb32c32b9d08fc66489f24bd8c56f49463818b70bcfb83e2e232819cb(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__44419752219e0135c53d30b7100b8d8f3b4b0088806c4c81121567f97662c399(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__d9b90cf45f21bf60b55f99e255222e86a5ccf0414ecd3cae2f60c12c9804e79a(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__57f6216af20ff36f59d10a2b63528baf39b556e6fdcf8818d5fff37e86d50c4a(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__c891543697d38d639547e7b6c90c682bf1fdda0fd4a92b95abc07ff801d29a92(
*,
accessibility: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
instance_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
instance_name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
workspace_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass | /ros-cdk-paidswapi-1.0.17.tar.gz/ros-cdk-paidswapi-1.0.17/src/ros_cdk_paidswapi/datasource/__init__.py | 0.646683 | 0.153454 | __init__.py | pypi |
import abc
import builtins
import datetime
import enum
import typing
import jsii
import publication
import typing_extensions
from typeguard import check_type
from .._jsii import *
import ros_cdk_core as _ros_cdk_core_7adfd82f
class RosRules(
_ros_cdk_core_7adfd82f.RosResource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-pvtz.datasource.RosRules",
):
'''A ROS template type: ``DATASOURCE::PVTZ::Rules``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["RosRulesProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
'''Create a new ``DATASOURCE::PVTZ::Rules``.
:param scope: - scope in which this resource is defined.
:param id: - scoped id of the resource.
:param props: - resource properties.
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__2eb232575e1a1535b7b430a72734ddb69f0608c724c13541b4f12a4a7ea25ffa)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@jsii.member(jsii_name="renderProperties")
def _render_properties(
self,
props: typing.Mapping[builtins.str, typing.Any],
) -> typing.Mapping[builtins.str, typing.Any]:
'''
:param props: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__ebb9300fb4c75c1f7c7b5e609e328092c8e962d02afbc6c0799b8936547f3ab6)
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))
@jsii.python.classproperty
@jsii.member(jsii_name="ROS_RESOURCE_TYPE_NAME")
def ROS_RESOURCE_TYPE_NAME(cls) -> builtins.str:
'''The resource type name for this resource class.'''
return typing.cast(builtins.str, jsii.sget(cls, "ROS_RESOURCE_TYPE_NAME"))
@builtins.property
@jsii.member(jsii_name="attrRuleIds")
def attr_rule_ids(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: RuleIds: The list of rule IDs.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrRuleIds"))
@builtins.property
@jsii.member(jsii_name="attrRules")
def attr_rules(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: Rules: The list of rules.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrRules"))
@builtins.property
@jsii.member(jsii_name="rosProperties")
def _ros_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "rosProperties"))
@builtins.property
@jsii.member(jsii_name="enableResourcePropertyConstraint")
def enable_resource_property_constraint(self) -> builtins.bool:
return typing.cast(builtins.bool, jsii.get(self, "enableResourcePropertyConstraint"))
@enable_resource_property_constraint.setter
def enable_resource_property_constraint(self, value: builtins.bool) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__16ddc5983a241a853d856720bd25dee2b273f6bdd33c96be62e5264d781919bd)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "enableResourcePropertyConstraint", value)
@builtins.property
@jsii.member(jsii_name="endpointId")
def endpoint_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: endpointId: EndpointId
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "endpointId"))
@endpoint_id.setter
def endpoint_id(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__f65e4ae79da24d0ad0a66f480b6ccc33576c419bb7ff016d7184820484d6eb02)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "endpointId", value)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-pvtz.datasource.RosRulesProps",
jsii_struct_bases=[],
name_mapping={"endpoint_id": "endpointId"},
)
class RosRulesProps:
def __init__(
self,
*,
endpoint_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``DATASOURCE::PVTZ::Rules``.
:param endpoint_id:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__f2cf582c5a025c58d8fbde718ae5a43b28bf167925e2331f05a70b20c4d55ae0)
check_type(argname="argument endpoint_id", value=endpoint_id, expected_type=type_hints["endpoint_id"])
self._values: typing.Dict[builtins.str, typing.Any] = {}
if endpoint_id is not None:
self._values["endpoint_id"] = endpoint_id
@builtins.property
def endpoint_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: endpointId: EndpointId
'''
result = self._values.get("endpoint_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "RosRulesProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class RosZones(
_ros_cdk_core_7adfd82f.RosResource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-pvtz.datasource.RosZones",
):
'''A ROS template type: ``DATASOURCE::PVTZ::Zones``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["RosZonesProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
'''Create a new ``DATASOURCE::PVTZ::Zones``.
:param scope: - scope in which this resource is defined.
:param id: - scoped id of the resource.
:param props: - resource properties.
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__187ac7c90086012f201092d5315dc76fd4536bd65d684daa319dff8780623151)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@jsii.member(jsii_name="renderProperties")
def _render_properties(
self,
props: typing.Mapping[builtins.str, typing.Any],
) -> typing.Mapping[builtins.str, typing.Any]:
'''
:param props: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__3ad3666d76e9e4acba756629933b989882e74b58c111390506221c803fe85eb7)
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))
@jsii.python.classproperty
@jsii.member(jsii_name="ROS_RESOURCE_TYPE_NAME")
def ROS_RESOURCE_TYPE_NAME(cls) -> builtins.str:
'''The resource type name for this resource class.'''
return typing.cast(builtins.str, jsii.sget(cls, "ROS_RESOURCE_TYPE_NAME"))
@builtins.property
@jsii.member(jsii_name="attrZoneIds")
def attr_zone_ids(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: ZoneIds: The list of zone IDs.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrZoneIds"))
@builtins.property
@jsii.member(jsii_name="attrZones")
def attr_zones(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: Zones: The list of zones.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrZones"))
@builtins.property
@jsii.member(jsii_name="rosProperties")
def _ros_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "rosProperties"))
@builtins.property
@jsii.member(jsii_name="enableResourcePropertyConstraint")
def enable_resource_property_constraint(self) -> builtins.bool:
return typing.cast(builtins.bool, jsii.get(self, "enableResourcePropertyConstraint"))
@enable_resource_property_constraint.setter
def enable_resource_property_constraint(self, value: builtins.bool) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__ad9bb8a3eb9d1fa8ff6437acc09600d1583f4cb369c25794a08e64ef03c5ed52)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "enableResourcePropertyConstraint", value)
@builtins.property
@jsii.member(jsii_name="resourceGroupId")
def resource_group_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: resourceGroupId: ResourceGroupId
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "resourceGroupId"))
@resource_group_id.setter
def resource_group_id(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__fede0e4732f016a5ea27fcc1d264604fd4ccbe339fdad020e53ceadd207e0263)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "resourceGroupId", value)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-pvtz.datasource.RosZonesProps",
jsii_struct_bases=[],
name_mapping={"resource_group_id": "resourceGroupId"},
)
class RosZonesProps:
def __init__(
self,
*,
resource_group_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``DATASOURCE::PVTZ::Zones``.
:param resource_group_id:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__cdc77d31e64e80f26b1f30064266e84feaa18b4ea09ed634acbccca4c6b24644)
check_type(argname="argument resource_group_id", value=resource_group_id, expected_type=type_hints["resource_group_id"])
self._values: typing.Dict[builtins.str, typing.Any] = {}
if resource_group_id is not None:
self._values["resource_group_id"] = resource_group_id
@builtins.property
def resource_group_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: resourceGroupId: ResourceGroupId
'''
result = self._values.get("resource_group_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "RosZonesProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class Rules(
_ros_cdk_core_7adfd82f.Resource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-pvtz.datasource.Rules",
):
'''A ROS resource type: ``DATASOURCE::PVTZ::Rules``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Optional[typing.Union["RulesProps", typing.Dict[builtins.str, typing.Any]]] = None,
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
'''Create a new ``DATASOURCE::PVTZ::Rules``.
Param scope - scope in which this resource is defined
Param id - scoped id of the resource
Param props - resource properties
:param scope: -
:param id: -
:param props: -
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__794d41ba4f315f705bd16f2c2193b0f354139c0359bf2eef8097172d5f1095ad)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@builtins.property
@jsii.member(jsii_name="attrRuleIds")
def attr_rule_ids(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute RuleIds: The list of rule IDs.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrRuleIds"))
@builtins.property
@jsii.member(jsii_name="attrRules")
def attr_rules(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute Rules: The list of rules.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrRules"))
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-pvtz.datasource.RulesProps",
jsii_struct_bases=[],
name_mapping={"endpoint_id": "endpointId"},
)
class RulesProps:
def __init__(
self,
*,
endpoint_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``DATASOURCE::PVTZ::Rules``.
:param endpoint_id: Property endpointId: EndpointId.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__4681dcc30d21eb15fdc6ccd884ed9cca9b015eee5a3abdd5f61ae4f97f946ad5)
check_type(argname="argument endpoint_id", value=endpoint_id, expected_type=type_hints["endpoint_id"])
self._values: typing.Dict[builtins.str, typing.Any] = {}
if endpoint_id is not None:
self._values["endpoint_id"] = endpoint_id
@builtins.property
def endpoint_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property endpointId: EndpointId.'''
result = self._values.get("endpoint_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "RulesProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class Zones(
_ros_cdk_core_7adfd82f.Resource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-pvtz.datasource.Zones",
):
'''A ROS resource type: ``DATASOURCE::PVTZ::Zones``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Optional[typing.Union["ZonesProps", typing.Dict[builtins.str, typing.Any]]] = None,
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
'''Create a new ``DATASOURCE::PVTZ::Zones``.
Param scope - scope in which this resource is defined
Param id - scoped id of the resource
Param props - resource properties
:param scope: -
:param id: -
:param props: -
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__03092c6a592ad0747bbf40c71f0fbebb60e567faeb257040abf259e54b070f0d)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@builtins.property
@jsii.member(jsii_name="attrZoneIds")
def attr_zone_ids(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute ZoneIds: The list of zone IDs.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrZoneIds"))
@builtins.property
@jsii.member(jsii_name="attrZones")
def attr_zones(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute Zones: The list of zones.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrZones"))
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-pvtz.datasource.ZonesProps",
jsii_struct_bases=[],
name_mapping={"resource_group_id": "resourceGroupId"},
)
class ZonesProps:
def __init__(
self,
*,
resource_group_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``DATASOURCE::PVTZ::Zones``.
:param resource_group_id: Property resourceGroupId: ResourceGroupId.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__a71ef3a88d24fb5ca41d6cd3ae5d6128829dc84b231e1fe328474675fa153042)
check_type(argname="argument resource_group_id", value=resource_group_id, expected_type=type_hints["resource_group_id"])
self._values: typing.Dict[builtins.str, typing.Any] = {}
if resource_group_id is not None:
self._values["resource_group_id"] = resource_group_id
@builtins.property
def resource_group_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property resourceGroupId: ResourceGroupId.'''
result = self._values.get("resource_group_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "ZonesProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
__all__ = [
"RosRules",
"RosRulesProps",
"RosZones",
"RosZonesProps",
"Rules",
"RulesProps",
"Zones",
"ZonesProps",
]
publication.publish()
def _typecheckingstub__2eb232575e1a1535b7b430a72734ddb69f0608c724c13541b4f12a4a7ea25ffa(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[RosRulesProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__ebb9300fb4c75c1f7c7b5e609e328092c8e962d02afbc6c0799b8936547f3ab6(
props: typing.Mapping[builtins.str, typing.Any],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__16ddc5983a241a853d856720bd25dee2b273f6bdd33c96be62e5264d781919bd(
value: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__f65e4ae79da24d0ad0a66f480b6ccc33576c419bb7ff016d7184820484d6eb02(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__f2cf582c5a025c58d8fbde718ae5a43b28bf167925e2331f05a70b20c4d55ae0(
*,
endpoint_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__187ac7c90086012f201092d5315dc76fd4536bd65d684daa319dff8780623151(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[RosZonesProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__3ad3666d76e9e4acba756629933b989882e74b58c111390506221c803fe85eb7(
props: typing.Mapping[builtins.str, typing.Any],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__ad9bb8a3eb9d1fa8ff6437acc09600d1583f4cb369c25794a08e64ef03c5ed52(
value: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__fede0e4732f016a5ea27fcc1d264604fd4ccbe339fdad020e53ceadd207e0263(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__cdc77d31e64e80f26b1f30064266e84feaa18b4ea09ed634acbccca4c6b24644(
*,
resource_group_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__794d41ba4f315f705bd16f2c2193b0f354139c0359bf2eef8097172d5f1095ad(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Optional[typing.Union[RulesProps, typing.Dict[builtins.str, typing.Any]]] = None,
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__4681dcc30d21eb15fdc6ccd884ed9cca9b015eee5a3abdd5f61ae4f97f946ad5(
*,
endpoint_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__03092c6a592ad0747bbf40c71f0fbebb60e567faeb257040abf259e54b070f0d(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Optional[typing.Union[ZonesProps, typing.Dict[builtins.str, typing.Any]]] = None,
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__a71ef3a88d24fb5ca41d6cd3ae5d6128829dc84b231e1fe328474675fa153042(
*,
resource_group_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass | /ros-cdk-pvtz-1.0.17.tar.gz/ros-cdk-pvtz-1.0.17/src/ros_cdk_pvtz/datasource/__init__.py | 0.577614 | 0.153137 | __init__.py | pypi |
import abc
import builtins
import datetime
import enum
import typing
import jsii
import publication
import typing_extensions
from typeguard import check_type
from .._jsii import *
import ros_cdk_core as _ros_cdk_core_7adfd82f
class Accounts(
_ros_cdk_core_7adfd82f.Resource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-rds.datasource.Accounts",
):
'''A ROS resource type: ``DATASOURCE::RDS::Accounts``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["AccountsProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
'''Create a new ``DATASOURCE::RDS::Accounts``.
Param scope - scope in which this resource is defined
Param id - scoped id of the resource
Param props - resource properties
:param scope: -
:param id: -
:param props: -
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__95dd19288d1fb07c44dfcdad60894614316ceb698204df838f1ca1215160d3c2)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@builtins.property
@jsii.member(jsii_name="attrAccountNames")
def attr_account_names(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute AccountNames: The list of The RDS account names.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrAccountNames"))
@builtins.property
@jsii.member(jsii_name="attrAccounts")
def attr_accounts(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute Accounts: The list of The RDS accounts.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrAccounts"))
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-rds.datasource.AccountsProps",
jsii_struct_bases=[],
name_mapping={"db_instance_id": "dbInstanceId", "account_name": "accountName"},
)
class AccountsProps:
def __init__(
self,
*,
db_instance_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
account_name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``DATASOURCE::RDS::Accounts``.
:param db_instance_id: Property dbInstanceId: The ID of the RDS instance.
:param account_name: Property accountName: The name of the RDS account.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__1f962f50ad4f9cf1d7d6fd6cd87a930fc0f522df76f98c027c9df725124e1353)
check_type(argname="argument db_instance_id", value=db_instance_id, expected_type=type_hints["db_instance_id"])
check_type(argname="argument account_name", value=account_name, expected_type=type_hints["account_name"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"db_instance_id": db_instance_id,
}
if account_name is not None:
self._values["account_name"] = account_name
@builtins.property
def db_instance_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property dbInstanceId: The ID of the RDS instance.'''
result = self._values.get("db_instance_id")
assert result is not None, "Required property 'db_instance_id' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def account_name(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property accountName: The name of the RDS account.'''
result = self._values.get("account_name")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "AccountsProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class DBInstances(
_ros_cdk_core_7adfd82f.Resource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-rds.datasource.DBInstances",
):
'''A ROS resource type: ``DATASOURCE::RDS::DBInstances``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Optional[typing.Union["DBInstancesProps", typing.Dict[builtins.str, typing.Any]]] = None,
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
'''Create a new ``DATASOURCE::RDS::DBInstances``.
Param scope - scope in which this resource is defined
Param id - scoped id of the resource
Param props - resource properties
:param scope: -
:param id: -
:param props: -
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__f09ed459dce499ec4d06cf0fec5e00cfb28949ffc462caa87c87f5495e4d3e57)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@builtins.property
@jsii.member(jsii_name="attrDbInstanceIds")
def attr_db_instance_ids(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute DBInstanceIds: The list of The RDS Database instance Ids.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrDbInstanceIds"))
@builtins.property
@jsii.member(jsii_name="attrDbInstances")
def attr_db_instances(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute DBInstances: The list of The RDS Database instances.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrDbInstances"))
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-rds.datasource.DBInstancesProps",
jsii_struct_bases=[],
name_mapping={
"connection_mode": "connectionMode",
"connection_string": "connectionString",
"db_instance_class": "dbInstanceClass",
"db_instance_id": "dbInstanceId",
"db_instance_status": "dbInstanceStatus",
"db_instance_type": "dbInstanceType",
"dedicated_host_group_id": "dedicatedHostGroupId",
"dedicated_host_id": "dedicatedHostId",
"engine": "engine",
"engine_version": "engineVersion",
"expired": "expired",
"instance_level": "instanceLevel",
"instance_network_type": "instanceNetworkType",
"pay_type": "payType",
"proxy_id": "proxyId",
"resource_group_id": "resourceGroupId",
"search_key": "searchKey",
"vpc_id": "vpcId",
"v_switch_id": "vSwitchId",
"zone_id": "zoneId",
},
)
class DBInstancesProps:
def __init__(
self,
*,
connection_mode: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
connection_string: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
db_instance_class: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
db_instance_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
db_instance_status: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
db_instance_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
dedicated_host_group_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
dedicated_host_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
engine: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
engine_version: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
expired: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
instance_level: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
instance_network_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
pay_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
proxy_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
resource_group_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
search_key: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
vpc_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
v_switch_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
zone_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``DATASOURCE::RDS::DBInstances``.
:param connection_mode: Property connectionMode: The connection mode of the instance.
:param connection_string: Property connectionString: The endpoint of the instance.
:param db_instance_class: Property dbInstanceClass: The instance type of the instances.
:param db_instance_id: Property dbInstanceId: The ID of the instance.
:param db_instance_status: Property dbInstanceStatus: The status of the instances.
:param db_instance_type: Property dbInstanceType: The role of the instances.
:param dedicated_host_group_id: Property dedicatedHostGroupId: The ID of the dedicated cluster to which the instances belong.
:param dedicated_host_id: Property dedicatedHostId: The ID of the host to which the instances belong in the specified dedicated cluster.
:param engine: Property engine: The database engine that is run by the instances.
:param engine_version: Property engineVersion: The version of the database engine that is run by the instances.
:param expired: Property expired: Specifies whether the instances have expired.
:param instance_level: Property instanceLevel: Specifies whether to return the RDS editions of the instances by using the Category parameter.
:param instance_network_type: Property instanceNetworkType: The network type of the instances.
:param pay_type: Property payType: The billing method of the instances.
:param proxy_id: Property proxyId: The ID of the proxy mode.
:param resource_group_id: Property resourceGroupId: The ID of the resource group to which the instances belong.
:param search_key: Property searchKey: The keywords that are contained in the IDs or descriptions of the instances.
:param vpc_id: Property vpcId: The ID of the virtual private cloud (VPC) to which the instances belong.
:param v_switch_id: Property vSwitchId: The ID of the vSwitch that is associated with the specified VPC.
:param zone_id: Property zoneId: The ID of the zone to which the instances belong.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__c1d3e543666aca4b1c633978aec2f1fb5d2fc096ac0c13b6aa201864cb7e6490)
check_type(argname="argument connection_mode", value=connection_mode, expected_type=type_hints["connection_mode"])
check_type(argname="argument connection_string", value=connection_string, expected_type=type_hints["connection_string"])
check_type(argname="argument db_instance_class", value=db_instance_class, expected_type=type_hints["db_instance_class"])
check_type(argname="argument db_instance_id", value=db_instance_id, expected_type=type_hints["db_instance_id"])
check_type(argname="argument db_instance_status", value=db_instance_status, expected_type=type_hints["db_instance_status"])
check_type(argname="argument db_instance_type", value=db_instance_type, expected_type=type_hints["db_instance_type"])
check_type(argname="argument dedicated_host_group_id", value=dedicated_host_group_id, expected_type=type_hints["dedicated_host_group_id"])
check_type(argname="argument dedicated_host_id", value=dedicated_host_id, expected_type=type_hints["dedicated_host_id"])
check_type(argname="argument engine", value=engine, expected_type=type_hints["engine"])
check_type(argname="argument engine_version", value=engine_version, expected_type=type_hints["engine_version"])
check_type(argname="argument expired", value=expired, expected_type=type_hints["expired"])
check_type(argname="argument instance_level", value=instance_level, expected_type=type_hints["instance_level"])
check_type(argname="argument instance_network_type", value=instance_network_type, expected_type=type_hints["instance_network_type"])
check_type(argname="argument pay_type", value=pay_type, expected_type=type_hints["pay_type"])
check_type(argname="argument proxy_id", value=proxy_id, expected_type=type_hints["proxy_id"])
check_type(argname="argument resource_group_id", value=resource_group_id, expected_type=type_hints["resource_group_id"])
check_type(argname="argument search_key", value=search_key, expected_type=type_hints["search_key"])
check_type(argname="argument vpc_id", value=vpc_id, expected_type=type_hints["vpc_id"])
check_type(argname="argument v_switch_id", value=v_switch_id, expected_type=type_hints["v_switch_id"])
check_type(argname="argument zone_id", value=zone_id, expected_type=type_hints["zone_id"])
self._values: typing.Dict[builtins.str, typing.Any] = {}
if connection_mode is not None:
self._values["connection_mode"] = connection_mode
if connection_string is not None:
self._values["connection_string"] = connection_string
if db_instance_class is not None:
self._values["db_instance_class"] = db_instance_class
if db_instance_id is not None:
self._values["db_instance_id"] = db_instance_id
if db_instance_status is not None:
self._values["db_instance_status"] = db_instance_status
if db_instance_type is not None:
self._values["db_instance_type"] = db_instance_type
if dedicated_host_group_id is not None:
self._values["dedicated_host_group_id"] = dedicated_host_group_id
if dedicated_host_id is not None:
self._values["dedicated_host_id"] = dedicated_host_id
if engine is not None:
self._values["engine"] = engine
if engine_version is not None:
self._values["engine_version"] = engine_version
if expired is not None:
self._values["expired"] = expired
if instance_level is not None:
self._values["instance_level"] = instance_level
if instance_network_type is not None:
self._values["instance_network_type"] = instance_network_type
if pay_type is not None:
self._values["pay_type"] = pay_type
if proxy_id is not None:
self._values["proxy_id"] = proxy_id
if resource_group_id is not None:
self._values["resource_group_id"] = resource_group_id
if search_key is not None:
self._values["search_key"] = search_key
if vpc_id is not None:
self._values["vpc_id"] = vpc_id
if v_switch_id is not None:
self._values["v_switch_id"] = v_switch_id
if zone_id is not None:
self._values["zone_id"] = zone_id
@builtins.property
def connection_mode(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property connectionMode: The connection mode of the instance.'''
result = self._values.get("connection_mode")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def connection_string(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property connectionString: The endpoint of the instance.'''
result = self._values.get("connection_string")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def db_instance_class(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property dbInstanceClass: The instance type of the instances.'''
result = self._values.get("db_instance_class")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def db_instance_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property dbInstanceId: The ID of the instance.'''
result = self._values.get("db_instance_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def db_instance_status(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property dbInstanceStatus: The status of the instances.'''
result = self._values.get("db_instance_status")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def db_instance_type(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property dbInstanceType: The role of the instances.'''
result = self._values.get("db_instance_type")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def dedicated_host_group_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property dedicatedHostGroupId: The ID of the dedicated cluster to which the instances belong.'''
result = self._values.get("dedicated_host_group_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def dedicated_host_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property dedicatedHostId: The ID of the host to which the instances belong in the specified dedicated cluster.'''
result = self._values.get("dedicated_host_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def engine(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property engine: The database engine that is run by the instances.'''
result = self._values.get("engine")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def engine_version(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property engineVersion: The version of the database engine that is run by the instances.'''
result = self._values.get("engine_version")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def expired(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property expired: Specifies whether the instances have expired.'''
result = self._values.get("expired")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def instance_level(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property instanceLevel: Specifies whether to return the RDS editions of the instances by using the Category parameter.'''
result = self._values.get("instance_level")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def instance_network_type(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property instanceNetworkType: The network type of the instances.'''
result = self._values.get("instance_network_type")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def pay_type(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property payType: The billing method of the instances.'''
result = self._values.get("pay_type")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def proxy_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property proxyId: The ID of the proxy mode.'''
result = self._values.get("proxy_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def resource_group_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property resourceGroupId: The ID of the resource group to which the instances belong.'''
result = self._values.get("resource_group_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def search_key(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property searchKey: The keywords that are contained in the IDs or descriptions of the instances.'''
result = self._values.get("search_key")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def vpc_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property vpcId: The ID of the virtual private cloud (VPC) to which the instances belong.'''
result = self._values.get("vpc_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def v_switch_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property vSwitchId: The ID of the vSwitch that is associated with the specified VPC.'''
result = self._values.get("v_switch_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def zone_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property zoneId: The ID of the zone to which the instances belong.'''
result = self._values.get("zone_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "DBInstancesProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class Databases(
_ros_cdk_core_7adfd82f.Resource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-rds.datasource.Databases",
):
'''A ROS resource type: ``DATASOURCE::RDS::Databases``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["DatabasesProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
'''Create a new ``DATASOURCE::RDS::Databases``.
Param scope - scope in which this resource is defined
Param id - scoped id of the resource
Param props - resource properties
:param scope: -
:param id: -
:param props: -
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__095546846bb6c1d643ffe24a42650823ccb30dade7d00fc1121edcef2cd54b60)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@builtins.property
@jsii.member(jsii_name="attrDatabases")
def attr_databases(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute Databases: The list of The RDS databases.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrDatabases"))
@builtins.property
@jsii.member(jsii_name="attrDbNames")
def attr_db_names(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute DBNames: The list of The RDS database names.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrDbNames"))
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-rds.datasource.DatabasesProps",
jsii_struct_bases=[],
name_mapping={
"db_instance_id": "dbInstanceId",
"db_name": "dbName",
"db_status": "dbStatus",
},
)
class DatabasesProps:
def __init__(
self,
*,
db_instance_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
db_name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
db_status: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``DATASOURCE::RDS::Databases``.
:param db_instance_id: Property dbInstanceId: The ID of the RDS instance.
:param db_name: Property dbName: The names of the databases whose information you want to query.
:param db_status: Property dbStatus: The status of the databases whose information you want to query.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__5c0ed223ef2a3b3a2ee99a78bf47098de3a785588cb6b0a6c713df0af35163bc)
check_type(argname="argument db_instance_id", value=db_instance_id, expected_type=type_hints["db_instance_id"])
check_type(argname="argument db_name", value=db_name, expected_type=type_hints["db_name"])
check_type(argname="argument db_status", value=db_status, expected_type=type_hints["db_status"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"db_instance_id": db_instance_id,
}
if db_name is not None:
self._values["db_name"] = db_name
if db_status is not None:
self._values["db_status"] = db_status
@builtins.property
def db_instance_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property dbInstanceId: The ID of the RDS instance.'''
result = self._values.get("db_instance_id")
assert result is not None, "Required property 'db_instance_id' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def db_name(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property dbName: The names of the databases whose information you want to query.'''
result = self._values.get("db_name")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def db_status(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property dbStatus: The status of the databases whose information you want to query.'''
result = self._values.get("db_status")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "DatabasesProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class RosAccounts(
_ros_cdk_core_7adfd82f.RosResource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-rds.datasource.RosAccounts",
):
'''A ROS template type: ``DATASOURCE::RDS::Accounts``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["RosAccountsProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
'''Create a new ``DATASOURCE::RDS::Accounts``.
:param scope: - scope in which this resource is defined.
:param id: - scoped id of the resource.
:param props: - resource properties.
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__6403a60a492995dae9e4c1213db98dc4125f9a185d74fc62e5de394874aee3f3)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@jsii.member(jsii_name="renderProperties")
def _render_properties(
self,
props: typing.Mapping[builtins.str, typing.Any],
) -> typing.Mapping[builtins.str, typing.Any]:
'''
:param props: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__6d68198122df3f2d8393cd194889e9059c0829c6cd929f193c88bc500bb42028)
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))
@jsii.python.classproperty
@jsii.member(jsii_name="ROS_RESOURCE_TYPE_NAME")
def ROS_RESOURCE_TYPE_NAME(cls) -> builtins.str:
'''The resource type name for this resource class.'''
return typing.cast(builtins.str, jsii.sget(cls, "ROS_RESOURCE_TYPE_NAME"))
@builtins.property
@jsii.member(jsii_name="attrAccountNames")
def attr_account_names(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: AccountNames: The list of The RDS account names.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrAccountNames"))
@builtins.property
@jsii.member(jsii_name="attrAccounts")
def attr_accounts(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: Accounts: The list of The RDS accounts.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrAccounts"))
@builtins.property
@jsii.member(jsii_name="rosProperties")
def _ros_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "rosProperties"))
@builtins.property
@jsii.member(jsii_name="dbInstanceId")
def db_instance_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: dbInstanceId: The ID of the RDS instance.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "dbInstanceId"))
@db_instance_id.setter
def db_instance_id(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__0592db2389438f88a69781fa2cbeb169837bd6e10e406281e17546e932ff0619)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "dbInstanceId", value)
@builtins.property
@jsii.member(jsii_name="enableResourcePropertyConstraint")
def enable_resource_property_constraint(self) -> builtins.bool:
return typing.cast(builtins.bool, jsii.get(self, "enableResourcePropertyConstraint"))
@enable_resource_property_constraint.setter
def enable_resource_property_constraint(self, value: builtins.bool) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__4097358e6b8e592193f73aa14bbd663b9c1cb1f7f94216b4085277170f171f0c)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "enableResourcePropertyConstraint", value)
@builtins.property
@jsii.member(jsii_name="accountName")
def account_name(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: accountName: The name of the RDS account.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "accountName"))
@account_name.setter
def account_name(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__c56e06ae040832706ea6022b4961dce08de2255016096619cd6f06738921ce52)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "accountName", value)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-rds.datasource.RosAccountsProps",
jsii_struct_bases=[],
name_mapping={"db_instance_id": "dbInstanceId", "account_name": "accountName"},
)
class RosAccountsProps:
def __init__(
self,
*,
db_instance_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
account_name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``DATASOURCE::RDS::Accounts``.
:param db_instance_id:
:param account_name:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__011008303007edb6dfde9f809cd3a812c87c605e379629843ab22fea0a4cef44)
check_type(argname="argument db_instance_id", value=db_instance_id, expected_type=type_hints["db_instance_id"])
check_type(argname="argument account_name", value=account_name, expected_type=type_hints["account_name"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"db_instance_id": db_instance_id,
}
if account_name is not None:
self._values["account_name"] = account_name
@builtins.property
def db_instance_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: dbInstanceId: The ID of the RDS instance.
'''
result = self._values.get("db_instance_id")
assert result is not None, "Required property 'db_instance_id' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def account_name(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: accountName: The name of the RDS account.
'''
result = self._values.get("account_name")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "RosAccountsProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class RosDBInstances(
_ros_cdk_core_7adfd82f.RosResource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-rds.datasource.RosDBInstances",
):
'''A ROS template type: ``DATASOURCE::RDS::DBInstances``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["RosDBInstancesProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
'''Create a new ``DATASOURCE::RDS::DBInstances``.
:param scope: - scope in which this resource is defined.
:param id: - scoped id of the resource.
:param props: - resource properties.
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__e022a870a09e1ed87c61bec5400b1612ae4d7fae0de68f51a2a463c4ce3a5d91)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@jsii.member(jsii_name="renderProperties")
def _render_properties(
self,
props: typing.Mapping[builtins.str, typing.Any],
) -> typing.Mapping[builtins.str, typing.Any]:
'''
:param props: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__3097560f91b88ec03a69e187429a221dbb89af49bd866b4a362b01eb9184e1f0)
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))
@jsii.python.classproperty
@jsii.member(jsii_name="ROS_RESOURCE_TYPE_NAME")
def ROS_RESOURCE_TYPE_NAME(cls) -> builtins.str:
'''The resource type name for this resource class.'''
return typing.cast(builtins.str, jsii.sget(cls, "ROS_RESOURCE_TYPE_NAME"))
@builtins.property
@jsii.member(jsii_name="attrDbInstanceIds")
def attr_db_instance_ids(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: DBInstanceIds: The list of The RDS Database instance Ids.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrDbInstanceIds"))
@builtins.property
@jsii.member(jsii_name="attrDbInstances")
def attr_db_instances(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: DBInstances: The list of The RDS Database instances.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrDbInstances"))
@builtins.property
@jsii.member(jsii_name="rosProperties")
def _ros_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "rosProperties"))
@builtins.property
@jsii.member(jsii_name="enableResourcePropertyConstraint")
def enable_resource_property_constraint(self) -> builtins.bool:
return typing.cast(builtins.bool, jsii.get(self, "enableResourcePropertyConstraint"))
@enable_resource_property_constraint.setter
def enable_resource_property_constraint(self, value: builtins.bool) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__5367f25e2aedbb0336fac2182ed4156421619539c3035bc1fafad880d43949a3)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "enableResourcePropertyConstraint", value)
@builtins.property
@jsii.member(jsii_name="connectionMode")
def connection_mode(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: connectionMode: The connection mode of the instance.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "connectionMode"))
@connection_mode.setter
def connection_mode(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__d079027b78a89496f9f89fc0b4b27c33c6f89208a6c3140492631c682aa951e7)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "connectionMode", value)
@builtins.property
@jsii.member(jsii_name="connectionString")
def connection_string(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: connectionString: The endpoint of the instance.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "connectionString"))
@connection_string.setter
def connection_string(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__1a844f993d2df02648e26aa83acc3537f0f05ab7aaeafdad8b81095b2175c9c6)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "connectionString", value)
@builtins.property
@jsii.member(jsii_name="dbInstanceClass")
def db_instance_class(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: dbInstanceClass: The instance type of the instances.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "dbInstanceClass"))
@db_instance_class.setter
def db_instance_class(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__cdab30874814eb1eb740b3c336218a3e01d9c5d0333837dd74e6db833f4e2390)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "dbInstanceClass", value)
@builtins.property
@jsii.member(jsii_name="dbInstanceId")
def db_instance_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: dbInstanceId: The ID of the instance.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "dbInstanceId"))
@db_instance_id.setter
def db_instance_id(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__f44e46dd912588b9b2994241da8f8ccd385c508167cee51c70542752e366fdeb)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "dbInstanceId", value)
@builtins.property
@jsii.member(jsii_name="dbInstanceStatus")
def db_instance_status(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: dbInstanceStatus: The status of the instances.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "dbInstanceStatus"))
@db_instance_status.setter
def db_instance_status(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__d501744eefd3cfa3b59e5f4dd9dacd91962d79b532139effdfd3fa4ba17ce9be)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "dbInstanceStatus", value)
@builtins.property
@jsii.member(jsii_name="dbInstanceType")
def db_instance_type(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: dbInstanceType: The role of the instances.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "dbInstanceType"))
@db_instance_type.setter
def db_instance_type(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__2b4b52d9cae4ab68ea90ab5670f188f9829cb8eab344cdb123c24753f8b10541)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "dbInstanceType", value)
@builtins.property
@jsii.member(jsii_name="dedicatedHostGroupId")
def dedicated_host_group_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: dedicatedHostGroupId: The ID of the dedicated cluster to which the instances belong.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "dedicatedHostGroupId"))
@dedicated_host_group_id.setter
def dedicated_host_group_id(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__05a74a6411efe579b26c20a4ab9589ebc0d792d78e289d9a2f9a7194d8e699cd)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "dedicatedHostGroupId", value)
@builtins.property
@jsii.member(jsii_name="dedicatedHostId")
def dedicated_host_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: dedicatedHostId: The ID of the host to which the instances belong in the specified dedicated cluster.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "dedicatedHostId"))
@dedicated_host_id.setter
def dedicated_host_id(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__b911b3dd52dc6033892ab71cec030d2893259be3b0b4060260fd66f7e0022c8d)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "dedicatedHostId", value)
@builtins.property
@jsii.member(jsii_name="engine")
def engine(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: engine: The database engine that is run by the instances.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "engine"))
@engine.setter
def engine(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__6ae2577191f1791fea08f86432febe88ea8bba879c405e260ac5f6d9da8d598e)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "engine", value)
@builtins.property
@jsii.member(jsii_name="engineVersion")
def engine_version(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: engineVersion: The version of the database engine that is run by the instances.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "engineVersion"))
@engine_version.setter
def engine_version(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__dcf468fcc929e462dde7cd30faafbab52d0e7ce648a44f4aab390603b8cb0405)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "engineVersion", value)
@builtins.property
@jsii.member(jsii_name="expired")
def expired(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: expired: Specifies whether the instances have expired.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "expired"))
@expired.setter
def expired(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__23753d99e221e47a1ae8d2b39dc27f09359d99c7ac0ef25c340299d1deeb5d4a)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "expired", value)
@builtins.property
@jsii.member(jsii_name="instanceLevel")
def instance_level(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: instanceLevel: Specifies whether to return the RDS editions of the instances by using the Category parameter.
'''
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "instanceLevel"))
@instance_level.setter
def instance_level(
self,
value: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__3f60c462b246f9672e3416089378248998fdb2fa7740f1a7f513ff3f93b48ad6)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "instanceLevel", value)
@builtins.property
@jsii.member(jsii_name="instanceNetworkType")
def instance_network_type(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: instanceNetworkType: The network type of the instances.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "instanceNetworkType"))
@instance_network_type.setter
def instance_network_type(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__8a635dbb58762f4c0470968cb1d7a5481a4ff69c091f1405a92b1a20ff84c52c)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "instanceNetworkType", value)
@builtins.property
@jsii.member(jsii_name="payType")
def pay_type(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: payType: The billing method of the instances.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "payType"))
@pay_type.setter
def pay_type(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__d063a2a0198eb06eafaa0464b7f5429c15cac84369c18f77a009702844f25585)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "payType", value)
@builtins.property
@jsii.member(jsii_name="proxyId")
def proxy_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: proxyId: The ID of the proxy mode.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "proxyId"))
@proxy_id.setter
def proxy_id(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__a6426bc878ad32cb5f153252be3da7c9e9c95cae8a2ecdaf02cc01a9fb3bfd00)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "proxyId", value)
@builtins.property
@jsii.member(jsii_name="resourceGroupId")
def resource_group_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: resourceGroupId: The ID of the resource group to which the instances belong.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "resourceGroupId"))
@resource_group_id.setter
def resource_group_id(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__c71900502692688cb2547a2de956ca6c75c4a55ec0522152ac10d74405c4a228)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "resourceGroupId", value)
@builtins.property
@jsii.member(jsii_name="searchKey")
def search_key(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: searchKey: The keywords that are contained in the IDs or descriptions of the instances.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "searchKey"))
@search_key.setter
def search_key(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__2ceed69a17dbc386dac268fb1bb940b5437c5489dd6837c90d787044bc245150)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "searchKey", value)
@builtins.property
@jsii.member(jsii_name="vpcId")
def vpc_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: vpcId: The ID of the virtual private cloud (VPC) to which the instances belong.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "vpcId"))
@vpc_id.setter
def vpc_id(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__1465ed6f4cb30b1c985df03b04dd841d46dcab09f98987f0a04d861cff692b1e)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "vpcId", value)
@builtins.property
@jsii.member(jsii_name="vSwitchId")
def v_switch_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: vSwitchId: The ID of the vSwitch that is associated with the specified VPC.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "vSwitchId"))
@v_switch_id.setter
def v_switch_id(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__49ce89cb9bc52dd45b6db182350492de7a5b5e032c887618280cc5f01a2d362e)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "vSwitchId", value)
@builtins.property
@jsii.member(jsii_name="zoneId")
def zone_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: zoneId: The ID of the zone to which the instances belong
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "zoneId"))
@zone_id.setter
def zone_id(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__64ace5e86c8ed91232add743877e39979809fc6b1e3e5e7ee14302a8c63f12e1)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "zoneId", value)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-rds.datasource.RosDBInstancesProps",
jsii_struct_bases=[],
name_mapping={
"connection_mode": "connectionMode",
"connection_string": "connectionString",
"db_instance_class": "dbInstanceClass",
"db_instance_id": "dbInstanceId",
"db_instance_status": "dbInstanceStatus",
"db_instance_type": "dbInstanceType",
"dedicated_host_group_id": "dedicatedHostGroupId",
"dedicated_host_id": "dedicatedHostId",
"engine": "engine",
"engine_version": "engineVersion",
"expired": "expired",
"instance_level": "instanceLevel",
"instance_network_type": "instanceNetworkType",
"pay_type": "payType",
"proxy_id": "proxyId",
"resource_group_id": "resourceGroupId",
"search_key": "searchKey",
"vpc_id": "vpcId",
"v_switch_id": "vSwitchId",
"zone_id": "zoneId",
},
)
class RosDBInstancesProps:
def __init__(
self,
*,
connection_mode: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
connection_string: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
db_instance_class: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
db_instance_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
db_instance_status: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
db_instance_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
dedicated_host_group_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
dedicated_host_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
engine: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
engine_version: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
expired: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
instance_level: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
instance_network_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
pay_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
proxy_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
resource_group_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
search_key: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
vpc_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
v_switch_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
zone_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``DATASOURCE::RDS::DBInstances``.
:param connection_mode:
:param connection_string:
:param db_instance_class:
:param db_instance_id:
:param db_instance_status:
:param db_instance_type:
:param dedicated_host_group_id:
:param dedicated_host_id:
:param engine:
:param engine_version:
:param expired:
:param instance_level:
:param instance_network_type:
:param pay_type:
:param proxy_id:
:param resource_group_id:
:param search_key:
:param vpc_id:
:param v_switch_id:
:param zone_id:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__e3d6887a5625d0c58c5f817ea828aa5960a39d7d4249dc962ec387e8358d6928)
check_type(argname="argument connection_mode", value=connection_mode, expected_type=type_hints["connection_mode"])
check_type(argname="argument connection_string", value=connection_string, expected_type=type_hints["connection_string"])
check_type(argname="argument db_instance_class", value=db_instance_class, expected_type=type_hints["db_instance_class"])
check_type(argname="argument db_instance_id", value=db_instance_id, expected_type=type_hints["db_instance_id"])
check_type(argname="argument db_instance_status", value=db_instance_status, expected_type=type_hints["db_instance_status"])
check_type(argname="argument db_instance_type", value=db_instance_type, expected_type=type_hints["db_instance_type"])
check_type(argname="argument dedicated_host_group_id", value=dedicated_host_group_id, expected_type=type_hints["dedicated_host_group_id"])
check_type(argname="argument dedicated_host_id", value=dedicated_host_id, expected_type=type_hints["dedicated_host_id"])
check_type(argname="argument engine", value=engine, expected_type=type_hints["engine"])
check_type(argname="argument engine_version", value=engine_version, expected_type=type_hints["engine_version"])
check_type(argname="argument expired", value=expired, expected_type=type_hints["expired"])
check_type(argname="argument instance_level", value=instance_level, expected_type=type_hints["instance_level"])
check_type(argname="argument instance_network_type", value=instance_network_type, expected_type=type_hints["instance_network_type"])
check_type(argname="argument pay_type", value=pay_type, expected_type=type_hints["pay_type"])
check_type(argname="argument proxy_id", value=proxy_id, expected_type=type_hints["proxy_id"])
check_type(argname="argument resource_group_id", value=resource_group_id, expected_type=type_hints["resource_group_id"])
check_type(argname="argument search_key", value=search_key, expected_type=type_hints["search_key"])
check_type(argname="argument vpc_id", value=vpc_id, expected_type=type_hints["vpc_id"])
check_type(argname="argument v_switch_id", value=v_switch_id, expected_type=type_hints["v_switch_id"])
check_type(argname="argument zone_id", value=zone_id, expected_type=type_hints["zone_id"])
self._values: typing.Dict[builtins.str, typing.Any] = {}
if connection_mode is not None:
self._values["connection_mode"] = connection_mode
if connection_string is not None:
self._values["connection_string"] = connection_string
if db_instance_class is not None:
self._values["db_instance_class"] = db_instance_class
if db_instance_id is not None:
self._values["db_instance_id"] = db_instance_id
if db_instance_status is not None:
self._values["db_instance_status"] = db_instance_status
if db_instance_type is not None:
self._values["db_instance_type"] = db_instance_type
if dedicated_host_group_id is not None:
self._values["dedicated_host_group_id"] = dedicated_host_group_id
if dedicated_host_id is not None:
self._values["dedicated_host_id"] = dedicated_host_id
if engine is not None:
self._values["engine"] = engine
if engine_version is not None:
self._values["engine_version"] = engine_version
if expired is not None:
self._values["expired"] = expired
if instance_level is not None:
self._values["instance_level"] = instance_level
if instance_network_type is not None:
self._values["instance_network_type"] = instance_network_type
if pay_type is not None:
self._values["pay_type"] = pay_type
if proxy_id is not None:
self._values["proxy_id"] = proxy_id
if resource_group_id is not None:
self._values["resource_group_id"] = resource_group_id
if search_key is not None:
self._values["search_key"] = search_key
if vpc_id is not None:
self._values["vpc_id"] = vpc_id
if v_switch_id is not None:
self._values["v_switch_id"] = v_switch_id
if zone_id is not None:
self._values["zone_id"] = zone_id
@builtins.property
def connection_mode(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: connectionMode: The connection mode of the instance.
'''
result = self._values.get("connection_mode")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def connection_string(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: connectionString: The endpoint of the instance.
'''
result = self._values.get("connection_string")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def db_instance_class(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: dbInstanceClass: The instance type of the instances.
'''
result = self._values.get("db_instance_class")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def db_instance_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: dbInstanceId: The ID of the instance.
'''
result = self._values.get("db_instance_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def db_instance_status(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: dbInstanceStatus: The status of the instances.
'''
result = self._values.get("db_instance_status")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def db_instance_type(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: dbInstanceType: The role of the instances.
'''
result = self._values.get("db_instance_type")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def dedicated_host_group_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: dedicatedHostGroupId: The ID of the dedicated cluster to which the instances belong.
'''
result = self._values.get("dedicated_host_group_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def dedicated_host_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: dedicatedHostId: The ID of the host to which the instances belong in the specified dedicated cluster.
'''
result = self._values.get("dedicated_host_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def engine(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: engine: The database engine that is run by the instances.
'''
result = self._values.get("engine")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def engine_version(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: engineVersion: The version of the database engine that is run by the instances.
'''
result = self._values.get("engine_version")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def expired(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: expired: Specifies whether the instances have expired.
'''
result = self._values.get("expired")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def instance_level(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: instanceLevel: Specifies whether to return the RDS editions of the instances by using the Category parameter.
'''
result = self._values.get("instance_level")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def instance_network_type(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: instanceNetworkType: The network type of the instances.
'''
result = self._values.get("instance_network_type")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def pay_type(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: payType: The billing method of the instances.
'''
result = self._values.get("pay_type")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def proxy_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: proxyId: The ID of the proxy mode.
'''
result = self._values.get("proxy_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def resource_group_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: resourceGroupId: The ID of the resource group to which the instances belong.
'''
result = self._values.get("resource_group_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def search_key(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: searchKey: The keywords that are contained in the IDs or descriptions of the instances.
'''
result = self._values.get("search_key")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def vpc_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: vpcId: The ID of the virtual private cloud (VPC) to which the instances belong.
'''
result = self._values.get("vpc_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def v_switch_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: vSwitchId: The ID of the vSwitch that is associated with the specified VPC.
'''
result = self._values.get("v_switch_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def zone_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: zoneId: The ID of the zone to which the instances belong
'''
result = self._values.get("zone_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "RosDBInstancesProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class RosDatabases(
_ros_cdk_core_7adfd82f.RosResource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-rds.datasource.RosDatabases",
):
'''A ROS template type: ``DATASOURCE::RDS::Databases``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["RosDatabasesProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
'''Create a new ``DATASOURCE::RDS::Databases``.
:param scope: - scope in which this resource is defined.
:param id: - scoped id of the resource.
:param props: - resource properties.
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__ab3a11e1eb36bb6b73465acd4d7bcf4a9cb487b3f783b5753ae92b08867386b5)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@jsii.member(jsii_name="renderProperties")
def _render_properties(
self,
props: typing.Mapping[builtins.str, typing.Any],
) -> typing.Mapping[builtins.str, typing.Any]:
'''
:param props: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__191dd8c75186d709b2929d8bef4132040683c7c03edffed40f66a05c3cfdb944)
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))
@jsii.python.classproperty
@jsii.member(jsii_name="ROS_RESOURCE_TYPE_NAME")
def ROS_RESOURCE_TYPE_NAME(cls) -> builtins.str:
'''The resource type name for this resource class.'''
return typing.cast(builtins.str, jsii.sget(cls, "ROS_RESOURCE_TYPE_NAME"))
@builtins.property
@jsii.member(jsii_name="attrDatabases")
def attr_databases(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: Databases: The list of The RDS databases.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrDatabases"))
@builtins.property
@jsii.member(jsii_name="attrDbNames")
def attr_db_names(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: DBNames: The list of The RDS database names.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrDbNames"))
@builtins.property
@jsii.member(jsii_name="rosProperties")
def _ros_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "rosProperties"))
@builtins.property
@jsii.member(jsii_name="dbInstanceId")
def db_instance_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: dbInstanceId: The ID of the RDS instance.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "dbInstanceId"))
@db_instance_id.setter
def db_instance_id(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__e5965645b934aa2aadd4bd51b27c68859642268b80e444e8b0d3d83400302ae6)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "dbInstanceId", value)
@builtins.property
@jsii.member(jsii_name="enableResourcePropertyConstraint")
def enable_resource_property_constraint(self) -> builtins.bool:
return typing.cast(builtins.bool, jsii.get(self, "enableResourcePropertyConstraint"))
@enable_resource_property_constraint.setter
def enable_resource_property_constraint(self, value: builtins.bool) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__b557aaf4a7d0cabb2134aea0ea7e350805bbcd64fa190b176d8b599aefeb82db)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "enableResourcePropertyConstraint", value)
@builtins.property
@jsii.member(jsii_name="dbName")
def db_name(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: dbName: The names of the databases whose information you want to query.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "dbName"))
@db_name.setter
def db_name(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__b3453762179e68dabce6bac907149c280996a25f0aedf281e1da065b5ebf2d1e)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "dbName", value)
@builtins.property
@jsii.member(jsii_name="dbStatus")
def db_status(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: dbStatus: The status of the databases whose information you want to query.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "dbStatus"))
@db_status.setter
def db_status(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__0f80bbcec45a7b636c227e35a70d39845543c64fd1cc209026206619447e0d9f)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "dbStatus", value)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-rds.datasource.RosDatabasesProps",
jsii_struct_bases=[],
name_mapping={
"db_instance_id": "dbInstanceId",
"db_name": "dbName",
"db_status": "dbStatus",
},
)
class RosDatabasesProps:
def __init__(
self,
*,
db_instance_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
db_name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
db_status: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``DATASOURCE::RDS::Databases``.
:param db_instance_id:
:param db_name:
:param db_status:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__e711614d7229c1a4d4a6bfdeb6a241fe84fda06a4c3e078b94e141814d36d926)
check_type(argname="argument db_instance_id", value=db_instance_id, expected_type=type_hints["db_instance_id"])
check_type(argname="argument db_name", value=db_name, expected_type=type_hints["db_name"])
check_type(argname="argument db_status", value=db_status, expected_type=type_hints["db_status"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"db_instance_id": db_instance_id,
}
if db_name is not None:
self._values["db_name"] = db_name
if db_status is not None:
self._values["db_status"] = db_status
@builtins.property
def db_instance_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: dbInstanceId: The ID of the RDS instance.
'''
result = self._values.get("db_instance_id")
assert result is not None, "Required property 'db_instance_id' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def db_name(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: dbName: The names of the databases whose information you want to query.
'''
result = self._values.get("db_name")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def db_status(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: dbStatus: The status of the databases whose information you want to query.
'''
result = self._values.get("db_status")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "RosDatabasesProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class RosZones(
_ros_cdk_core_7adfd82f.RosResource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-rds.datasource.RosZones",
):
'''A ROS template type: ``DATASOURCE::RDS::Zones``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["RosZonesProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
'''Create a new ``DATASOURCE::RDS::Zones``.
:param scope: - scope in which this resource is defined.
:param id: - scoped id of the resource.
:param props: - resource properties.
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__3342df28272fd8a764ed9d9b544a7be62e45230fd21efa8c3fc85d2aeee1a356)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@jsii.member(jsii_name="renderProperties")
def _render_properties(
self,
props: typing.Mapping[builtins.str, typing.Any],
) -> typing.Mapping[builtins.str, typing.Any]:
'''
:param props: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__8566c11e86edf3ca6989528188a36af823b298c297b6f5cf21507efade23419e)
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))
@jsii.python.classproperty
@jsii.member(jsii_name="ROS_RESOURCE_TYPE_NAME")
def ROS_RESOURCE_TYPE_NAME(cls) -> builtins.str:
'''The resource type name for this resource class.'''
return typing.cast(builtins.str, jsii.sget(cls, "ROS_RESOURCE_TYPE_NAME"))
@builtins.property
@jsii.member(jsii_name="attrZoneIds")
def attr_zone_ids(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: ZoneIds: The list of zone IDs.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrZoneIds"))
@builtins.property
@jsii.member(jsii_name="attrZones")
def attr_zones(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: Zones: The list of The Zones.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrZones"))
@builtins.property
@jsii.member(jsii_name="rosProperties")
def _ros_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "rosProperties"))
@builtins.property
@jsii.member(jsii_name="enableResourcePropertyConstraint")
def enable_resource_property_constraint(self) -> builtins.bool:
return typing.cast(builtins.bool, jsii.get(self, "enableResourcePropertyConstraint"))
@enable_resource_property_constraint.setter
def enable_resource_property_constraint(self, value: builtins.bool) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__b42492fe13f9cbeca2e19f2f610ea458634180b2470c839c6628f4ec59203b19)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "enableResourcePropertyConstraint", value)
@builtins.property
@jsii.member(jsii_name="engine")
def engine(self) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: engine: The database engine that is run by the instance.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "engine"))
@engine.setter
def engine(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__8a3e87ff17ea4165492955b3bfd0f35197633a0785d39ea1b0aed8f116ca80a2)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "engine", value)
@builtins.property
@jsii.member(jsii_name="category")
def category(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
category: The RDS edition of the instance. Valid values:
Basic: RDS Basic Edition
HighAvailability: RDS High-availability Edition
AlwaysOn: RDS Cluster Edition
Finance: RDS Enterprise Edition
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "category"))
@category.setter
def category(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__2b9859c0a33d79e15201ec304796cc41fc96f7f9248d4d2ff57b0735ba5b2dd4)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "category", value)
@builtins.property
@jsii.member(jsii_name="commodityCode")
def commodity_code(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: commodityCode: The commodity code of the instance.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "commodityCode"))
@commodity_code.setter
def commodity_code(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__e1276b1353642d142ce307a1399b8bf55389f6a505347acf8eebddc1b8583619)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "commodityCode", value)
@builtins.property
@jsii.member(jsii_name="dispenseMode")
def dispense_mode(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
dispenseMode: Specifies whether to return the zones in which the single-zone deployment method is supported. Valid values:
1: returns the zones.
0: does not return the zones.
Default value: 0.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "dispenseMode"))
@dispense_mode.setter
def dispense_mode(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__10d754e75dc37827f4f3ba67cec91e626497c81c3ce79307d85e2e4cf4ce61f0)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "dispenseMode", value)
@builtins.property
@jsii.member(jsii_name="engineVersion")
def engine_version(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: engineVersion: The version of the database engine that is run by the instance.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "engineVersion"))
@engine_version.setter
def engine_version(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__ea47ef18721d13018258816edac0a907acad1a992644231ca041eeb05cc83f07)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "engineVersion", value)
@builtins.property
@jsii.member(jsii_name="zoneId")
def zone_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
zoneId: The ID of the zone in which the instance is located.
If the instance spans more than one zone, the value of this parameter contains an MAZ part,such as cn-hangzhou-MAZ6(b,f) and cn-hangzhou-MAZ5(b,e,f)
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "zoneId"))
@zone_id.setter
def zone_id(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__0e932e6e81de5b4949983d22014f7c72eefca39a7d3d41af502f426f8b7d96f6)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "zoneId", value)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-rds.datasource.RosZonesProps",
jsii_struct_bases=[],
name_mapping={
"engine": "engine",
"category": "category",
"commodity_code": "commodityCode",
"dispense_mode": "dispenseMode",
"engine_version": "engineVersion",
"zone_id": "zoneId",
},
)
class RosZonesProps:
def __init__(
self,
*,
engine: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
category: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
commodity_code: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
dispense_mode: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
engine_version: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
zone_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``DATASOURCE::RDS::Zones``.
:param engine:
:param category:
:param commodity_code:
:param dispense_mode:
:param engine_version:
:param zone_id:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__4b9202487b6c0873ba88a5e22c5b60aea7172c1c5561c87fe03d9bd8ab645d51)
check_type(argname="argument engine", value=engine, expected_type=type_hints["engine"])
check_type(argname="argument category", value=category, expected_type=type_hints["category"])
check_type(argname="argument commodity_code", value=commodity_code, expected_type=type_hints["commodity_code"])
check_type(argname="argument dispense_mode", value=dispense_mode, expected_type=type_hints["dispense_mode"])
check_type(argname="argument engine_version", value=engine_version, expected_type=type_hints["engine_version"])
check_type(argname="argument zone_id", value=zone_id, expected_type=type_hints["zone_id"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"engine": engine,
}
if category is not None:
self._values["category"] = category
if commodity_code is not None:
self._values["commodity_code"] = commodity_code
if dispense_mode is not None:
self._values["dispense_mode"] = dispense_mode
if engine_version is not None:
self._values["engine_version"] = engine_version
if zone_id is not None:
self._values["zone_id"] = zone_id
@builtins.property
def engine(self) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: engine: The database engine that is run by the instance.
'''
result = self._values.get("engine")
assert result is not None, "Required property 'engine' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def category(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
category: The RDS edition of the instance. Valid values:
Basic: RDS Basic Edition
HighAvailability: RDS High-availability Edition
AlwaysOn: RDS Cluster Edition
Finance: RDS Enterprise Edition
'''
result = self._values.get("category")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def commodity_code(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: commodityCode: The commodity code of the instance.
'''
result = self._values.get("commodity_code")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def dispense_mode(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
dispenseMode: Specifies whether to return the zones in which the single-zone deployment method is supported. Valid values:
1: returns the zones.
0: does not return the zones.
Default value: 0.
'''
result = self._values.get("dispense_mode")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def engine_version(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: engineVersion: The version of the database engine that is run by the instance.
'''
result = self._values.get("engine_version")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def zone_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
zoneId: The ID of the zone in which the instance is located.
If the instance spans more than one zone, the value of this parameter contains an MAZ part,such as cn-hangzhou-MAZ6(b,f) and cn-hangzhou-MAZ5(b,e,f)
'''
result = self._values.get("zone_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "RosZonesProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class Zones(
_ros_cdk_core_7adfd82f.Resource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-rds.datasource.Zones",
):
'''A ROS resource type: ``DATASOURCE::RDS::Zones``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["ZonesProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
'''Create a new ``DATASOURCE::RDS::Zones``.
Param scope - scope in which this resource is defined
Param id - scoped id of the resource
Param props - resource properties
:param scope: -
:param id: -
:param props: -
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__69c3f2d88b2e6826e4c2a107f458c4c4f7e638f8c623d2a96da017fe0c4cca09)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@builtins.property
@jsii.member(jsii_name="attrZoneIds")
def attr_zone_ids(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute ZoneIds: The list of zone IDs.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrZoneIds"))
@builtins.property
@jsii.member(jsii_name="attrZones")
def attr_zones(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute Zones: The list of The Zones.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrZones"))
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-rds.datasource.ZonesProps",
jsii_struct_bases=[],
name_mapping={
"engine": "engine",
"category": "category",
"commodity_code": "commodityCode",
"dispense_mode": "dispenseMode",
"engine_version": "engineVersion",
"zone_id": "zoneId",
},
)
class ZonesProps:
def __init__(
self,
*,
engine: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
category: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
commodity_code: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
dispense_mode: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
engine_version: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
zone_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``DATASOURCE::RDS::Zones``.
:param engine: Property engine: The database engine that is run by the instance.
:param category: Property category: The RDS edition of the instance. Valid values: Basic: RDS Basic Edition HighAvailability: RDS High-availability Edition AlwaysOn: RDS Cluster Edition Finance: RDS Enterprise Edition
:param commodity_code: Property commodityCode: The commodity code of the instance.
:param dispense_mode: Property dispenseMode: Specifies whether to return the zones in which the single-zone deployment method is supported. Valid values: 1: returns the zones. 0: does not return the zones. Default value: 0.
:param engine_version: Property engineVersion: The version of the database engine that is run by the instance.
:param zone_id: Property zoneId: The ID of the zone in which the instance is located. If the instance spans more than one zone, the value of this parameter contains an MAZ part,such as cn-hangzhou-MAZ6(b,f) and cn-hangzhou-MAZ5(b,e,f)
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__b865630716bb670d189dc901ce5b87039c74ddd66ebcf848734a34a0b31ecec5)
check_type(argname="argument engine", value=engine, expected_type=type_hints["engine"])
check_type(argname="argument category", value=category, expected_type=type_hints["category"])
check_type(argname="argument commodity_code", value=commodity_code, expected_type=type_hints["commodity_code"])
check_type(argname="argument dispense_mode", value=dispense_mode, expected_type=type_hints["dispense_mode"])
check_type(argname="argument engine_version", value=engine_version, expected_type=type_hints["engine_version"])
check_type(argname="argument zone_id", value=zone_id, expected_type=type_hints["zone_id"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"engine": engine,
}
if category is not None:
self._values["category"] = category
if commodity_code is not None:
self._values["commodity_code"] = commodity_code
if dispense_mode is not None:
self._values["dispense_mode"] = dispense_mode
if engine_version is not None:
self._values["engine_version"] = engine_version
if zone_id is not None:
self._values["zone_id"] = zone_id
@builtins.property
def engine(self) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property engine: The database engine that is run by the instance.'''
result = self._values.get("engine")
assert result is not None, "Required property 'engine' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def category(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property category: The RDS edition of the instance.
Valid values:
Basic: RDS Basic Edition
HighAvailability: RDS High-availability Edition
AlwaysOn: RDS Cluster Edition
Finance: RDS Enterprise Edition
'''
result = self._values.get("category")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def commodity_code(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property commodityCode: The commodity code of the instance.'''
result = self._values.get("commodity_code")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def dispense_mode(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property dispenseMode: Specifies whether to return the zones in which the single-zone deployment method is supported.
Valid values:
1: returns the zones.
0: does not return the zones.
Default value: 0.
'''
result = self._values.get("dispense_mode")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def engine_version(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property engineVersion: The version of the database engine that is run by the instance.'''
result = self._values.get("engine_version")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def zone_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property zoneId: The ID of the zone in which the instance is located.
If the instance spans more than one zone, the value of this parameter contains an MAZ part,such as cn-hangzhou-MAZ6(b,f) and cn-hangzhou-MAZ5(b,e,f)
'''
result = self._values.get("zone_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "ZonesProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
__all__ = [
"Accounts",
"AccountsProps",
"DBInstances",
"DBInstancesProps",
"Databases",
"DatabasesProps",
"RosAccounts",
"RosAccountsProps",
"RosDBInstances",
"RosDBInstancesProps",
"RosDatabases",
"RosDatabasesProps",
"RosZones",
"RosZonesProps",
"Zones",
"ZonesProps",
]
publication.publish()
def _typecheckingstub__95dd19288d1fb07c44dfcdad60894614316ceb698204df838f1ca1215160d3c2(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[AccountsProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__1f962f50ad4f9cf1d7d6fd6cd87a930fc0f522df76f98c027c9df725124e1353(
*,
db_instance_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
account_name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__f09ed459dce499ec4d06cf0fec5e00cfb28949ffc462caa87c87f5495e4d3e57(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Optional[typing.Union[DBInstancesProps, typing.Dict[builtins.str, typing.Any]]] = None,
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__c1d3e543666aca4b1c633978aec2f1fb5d2fc096ac0c13b6aa201864cb7e6490(
*,
connection_mode: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
connection_string: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
db_instance_class: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
db_instance_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
db_instance_status: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
db_instance_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
dedicated_host_group_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
dedicated_host_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
engine: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
engine_version: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
expired: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
instance_level: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
instance_network_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
pay_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
proxy_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
resource_group_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
search_key: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
vpc_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
v_switch_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
zone_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__095546846bb6c1d643ffe24a42650823ccb30dade7d00fc1121edcef2cd54b60(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[DatabasesProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__5c0ed223ef2a3b3a2ee99a78bf47098de3a785588cb6b0a6c713df0af35163bc(
*,
db_instance_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
db_name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
db_status: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__6403a60a492995dae9e4c1213db98dc4125f9a185d74fc62e5de394874aee3f3(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[RosAccountsProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__6d68198122df3f2d8393cd194889e9059c0829c6cd929f193c88bc500bb42028(
props: typing.Mapping[builtins.str, typing.Any],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__0592db2389438f88a69781fa2cbeb169837bd6e10e406281e17546e932ff0619(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__4097358e6b8e592193f73aa14bbd663b9c1cb1f7f94216b4085277170f171f0c(
value: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__c56e06ae040832706ea6022b4961dce08de2255016096619cd6f06738921ce52(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__011008303007edb6dfde9f809cd3a812c87c605e379629843ab22fea0a4cef44(
*,
db_instance_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
account_name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__e022a870a09e1ed87c61bec5400b1612ae4d7fae0de68f51a2a463c4ce3a5d91(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[RosDBInstancesProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__3097560f91b88ec03a69e187429a221dbb89af49bd866b4a362b01eb9184e1f0(
props: typing.Mapping[builtins.str, typing.Any],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__5367f25e2aedbb0336fac2182ed4156421619539c3035bc1fafad880d43949a3(
value: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__d079027b78a89496f9f89fc0b4b27c33c6f89208a6c3140492631c682aa951e7(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__1a844f993d2df02648e26aa83acc3537f0f05ab7aaeafdad8b81095b2175c9c6(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__cdab30874814eb1eb740b3c336218a3e01d9c5d0333837dd74e6db833f4e2390(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__f44e46dd912588b9b2994241da8f8ccd385c508167cee51c70542752e366fdeb(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__d501744eefd3cfa3b59e5f4dd9dacd91962d79b532139effdfd3fa4ba17ce9be(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__2b4b52d9cae4ab68ea90ab5670f188f9829cb8eab344cdb123c24753f8b10541(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__05a74a6411efe579b26c20a4ab9589ebc0d792d78e289d9a2f9a7194d8e699cd(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__b911b3dd52dc6033892ab71cec030d2893259be3b0b4060260fd66f7e0022c8d(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__6ae2577191f1791fea08f86432febe88ea8bba879c405e260ac5f6d9da8d598e(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__dcf468fcc929e462dde7cd30faafbab52d0e7ce648a44f4aab390603b8cb0405(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__23753d99e221e47a1ae8d2b39dc27f09359d99c7ac0ef25c340299d1deeb5d4a(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__3f60c462b246f9672e3416089378248998fdb2fa7740f1a7f513ff3f93b48ad6(
value: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__8a635dbb58762f4c0470968cb1d7a5481a4ff69c091f1405a92b1a20ff84c52c(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__d063a2a0198eb06eafaa0464b7f5429c15cac84369c18f77a009702844f25585(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__a6426bc878ad32cb5f153252be3da7c9e9c95cae8a2ecdaf02cc01a9fb3bfd00(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__c71900502692688cb2547a2de956ca6c75c4a55ec0522152ac10d74405c4a228(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__2ceed69a17dbc386dac268fb1bb940b5437c5489dd6837c90d787044bc245150(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__1465ed6f4cb30b1c985df03b04dd841d46dcab09f98987f0a04d861cff692b1e(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__49ce89cb9bc52dd45b6db182350492de7a5b5e032c887618280cc5f01a2d362e(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__64ace5e86c8ed91232add743877e39979809fc6b1e3e5e7ee14302a8c63f12e1(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__e3d6887a5625d0c58c5f817ea828aa5960a39d7d4249dc962ec387e8358d6928(
*,
connection_mode: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
connection_string: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
db_instance_class: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
db_instance_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
db_instance_status: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
db_instance_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
dedicated_host_group_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
dedicated_host_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
engine: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
engine_version: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
expired: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
instance_level: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
instance_network_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
pay_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
proxy_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
resource_group_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
search_key: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
vpc_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
v_switch_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
zone_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__ab3a11e1eb36bb6b73465acd4d7bcf4a9cb487b3f783b5753ae92b08867386b5(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[RosDatabasesProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__191dd8c75186d709b2929d8bef4132040683c7c03edffed40f66a05c3cfdb944(
props: typing.Mapping[builtins.str, typing.Any],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__e5965645b934aa2aadd4bd51b27c68859642268b80e444e8b0d3d83400302ae6(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__b557aaf4a7d0cabb2134aea0ea7e350805bbcd64fa190b176d8b599aefeb82db(
value: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__b3453762179e68dabce6bac907149c280996a25f0aedf281e1da065b5ebf2d1e(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__0f80bbcec45a7b636c227e35a70d39845543c64fd1cc209026206619447e0d9f(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__e711614d7229c1a4d4a6bfdeb6a241fe84fda06a4c3e078b94e141814d36d926(
*,
db_instance_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
db_name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
db_status: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__3342df28272fd8a764ed9d9b544a7be62e45230fd21efa8c3fc85d2aeee1a356(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[RosZonesProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__8566c11e86edf3ca6989528188a36af823b298c297b6f5cf21507efade23419e(
props: typing.Mapping[builtins.str, typing.Any],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__b42492fe13f9cbeca2e19f2f610ea458634180b2470c839c6628f4ec59203b19(
value: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__8a3e87ff17ea4165492955b3bfd0f35197633a0785d39ea1b0aed8f116ca80a2(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__2b9859c0a33d79e15201ec304796cc41fc96f7f9248d4d2ff57b0735ba5b2dd4(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__e1276b1353642d142ce307a1399b8bf55389f6a505347acf8eebddc1b8583619(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__10d754e75dc37827f4f3ba67cec91e626497c81c3ce79307d85e2e4cf4ce61f0(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__ea47ef18721d13018258816edac0a907acad1a992644231ca041eeb05cc83f07(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__0e932e6e81de5b4949983d22014f7c72eefca39a7d3d41af502f426f8b7d96f6(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__4b9202487b6c0873ba88a5e22c5b60aea7172c1c5561c87fe03d9bd8ab645d51(
*,
engine: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
category: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
commodity_code: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
dispense_mode: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
engine_version: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
zone_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__69c3f2d88b2e6826e4c2a107f458c4c4f7e638f8c623d2a96da017fe0c4cca09(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[ZonesProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__b865630716bb670d189dc901ce5b87039c74ddd66ebcf848734a34a0b31ecec5(
*,
engine: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
category: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
commodity_code: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
dispense_mode: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
engine_version: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
zone_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass | /ros-cdk-rds-1.0.17.tar.gz/ros-cdk-rds-1.0.17/src/ros_cdk_rds/datasource/__init__.py | 0.626353 | 0.153867 | __init__.py | pypi |
import abc
import builtins
import datetime
import enum
import typing
import jsii
import publication
import typing_extensions
from typeguard import check_type
from ._jsii import *
import ros_cdk_core as _ros_cdk_core_7adfd82f
class AutoEnableService(
_ros_cdk_core_7adfd82f.Resource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-ros.AutoEnableService",
):
'''A ROS resource type: ``ALIYUN::ROS::AutoEnableService``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["AutoEnableServiceProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
'''Create a new ``ALIYUN::ROS::AutoEnableService``.
Param scope - scope in which this resource is defined
Param id - scoped id of the resource
Param props - resource properties
:param scope: -
:param id: -
:param props: -
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__2d8a8c9fa5b38272cd4d19c32f93b096a09834e4e35cd4e2a08af4596d2dbf65)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-ros.AutoEnableServiceProps",
jsii_struct_bases=[],
name_mapping={"service_name": "serviceName"},
)
class AutoEnableServiceProps:
def __init__(
self,
*,
service_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
'''Properties for defining a ``ALIYUN::ROS::AutoEnableService``.
:param service_name: Property serviceName: Which service to enable. Valid values: AHAS: Application High Availability Service ARMS: Realtime Monitoring Service ApiGateway: API Gateway BatchCompute: Batch Compute BrainIndustrial: Brain Industrial CloudStorageGateway: Cloud Storage Gateway CMS: Cloud Monitor Service CR: Container Registry CS: Container Service DataHub: Data Hub DataWorks: DataWorks DCDN: Dynamic Route for CDN EDAS: Enterprise Distributed Application Service EMAS: Enterprise Mobile Application Studio FC: Function Compute FNF: Serverless Workflow MaxCompute: MaxCompute NAS: Network Attached Storage MNS: Message Service (MNS) HBR: Hybrid Backup Recovery IMM: Intelligent Media Management IOT: IoT Platform KMS: Key Management Service NLP: Natural Language Processing OSS: Object Storage Service OTS: Table Store PrivateLink: Private Link PrivateZone: Private Zone RocketMQ: RocketMQ SAE: Serverless App Engine SLS: Log Service TrafficMirror: VPC Traffic Mirroring VS: Video Surveillance Xtrace: Tracing Anlaysis
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__30ea77db475c0f5824b0ba7b97667bc253cd8842e5f24b57a3a63b7e1007ad06)
check_type(argname="argument service_name", value=service_name, expected_type=type_hints["service_name"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"service_name": service_name,
}
@builtins.property
def service_name(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property serviceName: Which service to enable.
Valid values:
AHAS: Application High Availability Service
ARMS: Realtime Monitoring Service
ApiGateway: API Gateway
BatchCompute: Batch Compute
BrainIndustrial: Brain Industrial
CloudStorageGateway: Cloud Storage Gateway
CMS: Cloud Monitor Service
CR: Container Registry
CS: Container Service
DataHub: Data Hub
DataWorks: DataWorks
DCDN: Dynamic Route for CDN
EDAS: Enterprise Distributed Application Service
EMAS: Enterprise Mobile Application Studio
FC: Function Compute
FNF: Serverless Workflow
MaxCompute: MaxCompute
NAS: Network Attached Storage
MNS: Message Service (MNS)
HBR: Hybrid Backup Recovery
IMM: Intelligent Media Management
IOT: IoT Platform
KMS: Key Management Service
NLP: Natural Language Processing
OSS: Object Storage Service
OTS: Table Store
PrivateLink: Private Link
PrivateZone: Private Zone
RocketMQ: RocketMQ
SAE: Serverless App Engine
SLS: Log Service
TrafficMirror: VPC Traffic Mirroring
VS: Video Surveillance
Xtrace: Tracing Anlaysis
'''
result = self._values.get("service_name")
assert result is not None, "Required property 'service_name' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "AutoEnableServiceProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class CustomResource(
_ros_cdk_core_7adfd82f.Resource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-ros.CustomResource",
):
'''A ROS resource type: ``ALIYUN::ROS::CustomResource``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["CustomResourceProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
'''Create a new ``ALIYUN::ROS::CustomResource``.
Param scope - scope in which this resource is defined
Param id - scoped id of the resource
Param props - resource properties
:param scope: -
:param id: -
:param props: -
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__2d6f9e5b9f81f49e4166358718dae3297fbabc9b345e8bd677d5b922267e3a29)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@builtins.property
@jsii.member(jsii_name="attrOutputs")
def attr_outputs(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute Outputs: Output data received from service provider.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrOutputs"))
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-ros.CustomResourceProps",
jsii_struct_bases=[],
name_mapping={
"service_token": "serviceToken",
"timeout": "timeout",
"http_config": "httpConfig",
"parameters": "parameters",
},
)
class CustomResourceProps:
def __init__(
self,
*,
service_token: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
timeout: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
http_config: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union["RosCustomResource.HttpConfigProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
parameters: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::ROS::CustomResource``.
:param service_token: Property serviceToken: The service token that was given to the template developer by the service provider to access the service. Allowed values: - Function Compute: acs:fc:<region_id>:<account_id>:services/<service_name>/functions/<function_name> - MNS Queue: acs:mns:<region_id>:<account_id>:queues/<queue_name> or acs:mns:<region_id>:<account_id>:/queues/<queue_name> - MNS Topic: acs:mns:<region_id>:<account_id>:topics/<topic_name> or acs:mns:<region_id>:<account_id>:/topics/<topic_name> - HTTP&HTTPS: web[options]: Two options are supported: - sync: sync HTTP&HTTPS request. - idempotent: indicates that the Create request is idempotent. Update and Delete requests should be always idempotent. Examples: - acs:fc:cn-hangzhou:123456789:services/test-service/functions/test-function - acs:mns:cn-hangzhou:123456789:queues/test-queue - acs:mns:cn-hangzhou:123456789:/queues/test-queue - acs:mns:cn-hangzhou:123456789:topics/test-topic - acs:mns:cn-hangzhou:123456789:/topics/test-topic - web:https://abc.com - web[sync]:http://abc.com - web[sync,idempotent]:https://abc.com
:param timeout: Property timeout: Timeout seconds before service provider responses. It takes effects only if the type of ServiceToken is Function Compute, MNS Queue, MNS Topic or async HTTP&HTTPS request. Timeout seconds are always 10 for sync HTTP&HTTPS request.
:param http_config: Property httpConfig: Config for HTTP&HTTPS service provider.
:param parameters: Property parameters: Parameters to be passed to service provider.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__9129cec239b0558cab530c370a4abf7bb62e688591667aa286ba2ebbe348281f)
check_type(argname="argument service_token", value=service_token, expected_type=type_hints["service_token"])
check_type(argname="argument timeout", value=timeout, expected_type=type_hints["timeout"])
check_type(argname="argument http_config", value=http_config, expected_type=type_hints["http_config"])
check_type(argname="argument parameters", value=parameters, expected_type=type_hints["parameters"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"service_token": service_token,
"timeout": timeout,
}
if http_config is not None:
self._values["http_config"] = http_config
if parameters is not None:
self._values["parameters"] = parameters
@builtins.property
def service_token(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property serviceToken: The service token that was given to the template developer by the service provider to access the service.
Allowed values:
- Function Compute: acs:fc:<region_id>:<account_id>:services/<service_name>/functions/<function_name>
- MNS Queue: acs:mns:<region_id>:<account_id>:queues/<queue_name> or acs:mns:<region_id>:<account_id>:/queues/<queue_name>
- MNS Topic: acs:mns:<region_id>:<account_id>:topics/<topic_name> or acs:mns:<region_id>:<account_id>:/topics/<topic_name>
- HTTP&HTTPS: web[options]:
Two options are supported:
- sync: sync HTTP&HTTPS request.
- idempotent: indicates that the Create request is idempotent. Update and Delete requests should be always idempotent.
Examples:
- acs:fc:cn-hangzhou:123456789:services/test-service/functions/test-function
- acs:mns:cn-hangzhou:123456789:queues/test-queue
- acs:mns:cn-hangzhou:123456789:/queues/test-queue
- acs:mns:cn-hangzhou:123456789:topics/test-topic
- acs:mns:cn-hangzhou:123456789:/topics/test-topic
- web:https://abc.com
- web[sync]:http://abc.com
- web[sync,idempotent]:https://abc.com
'''
result = self._values.get("service_token")
assert result is not None, "Required property 'service_token' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def timeout(self) -> typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property timeout: Timeout seconds before service provider responses.
It takes effects only if the type of ServiceToken is Function Compute, MNS Queue, MNS Topic or async HTTP&HTTPS request.
Timeout seconds are always 10 for sync HTTP&HTTPS request.
'''
result = self._values.get("timeout")
assert result is not None, "Required property 'timeout' is missing"
return typing.cast(typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def http_config(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosCustomResource.HttpConfigProperty"]]:
'''Property httpConfig: Config for HTTP&HTTPS service provider.'''
result = self._values.get("http_config")
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosCustomResource.HttpConfigProperty"]], result)
@builtins.property
def parameters(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]]:
'''Property parameters: Parameters to be passed to service provider.'''
result = self._values.get("parameters")
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "CustomResourceProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class ResourceCleaner(
_ros_cdk_core_7adfd82f.Resource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-ros.ResourceCleaner",
):
'''A ROS resource type: ``ALIYUN::ROS::ResourceCleaner``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["ResourceCleanerProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
'''Create a new ``ALIYUN::ROS::ResourceCleaner``.
Param scope - scope in which this resource is defined
Param id - scoped id of the resource
Param props - resource properties
:param scope: -
:param id: -
:param props: -
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__5417e52208987ab69f690c256a7f3060b239f571e5c38afd6989a89ea685499c)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@builtins.property
@jsii.member(jsii_name="attrCleanResult")
def attr_clean_result(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute CleanResult: The cleanup result.
Valid values:
- Success: All resources are cleaned up successfully.
- ResourceFailure: Partial resources fail to clean up.
- Timeout: Timeout to clean up.
- CheckFailure: Pre check of cleanup fails.
- UnknownFailure: Unexpected failure.
- UserCancelled: Cleanup is cancelled by user.
- None: Cleanup is not triggered.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrCleanResult"))
@builtins.property
@jsii.member(jsii_name="attrNoCleanupResourceDetails")
def attr_no_cleanup_resource_details(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute NoCleanupResourceDetails: The details of the resources that are scanned but filtered.
Only resources with the resource types ResourceCleaner supports and the regions not filtered are scanned.
The format is the same as ResourceDetails.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrNoCleanupResourceDetails"))
@builtins.property
@jsii.member(jsii_name="attrNoCleanupResourcePartialDetails")
def attr_no_cleanup_resource_partial_details(
self,
) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute NoCleanupResourcePartialDetails: The partial details of the resources that are scanned but filtered.
Only resources with the resource types ResourceCleaner supports and the regions not filtered are scanned.
The format is the same as ResourcePartialDetails.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrNoCleanupResourcePartialDetails"))
@builtins.property
@jsii.member(jsii_name="attrResourceDetails")
def attr_resource_details(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute ResourceDetails: The details of resources to be cleaned up.
The value is a list of dict. The dict contains the fields below:
- ResourceType: Resource type of the resource.
- RegionId: Region ID of the resource.
- ResourceId: ID of the resource.
- ResourceName: Name of the resource.
- CleanupType: Cleanup type of the resource. Valid values:
- Normal: The resource can be deleted normally.
- DeleteWithInstance: The resource will be deleted with the resource it belongs to. If the resource it belongs to is filtered or excluded, the deletion probably fails. CleanupTypeReasons give more information.
- UnableToDelete: Unable to delete the resource. CleanupTypeReasons give more information.
- CleanupTypeReasons: The information of the related CleanupType.
- ResourceStatus: Status of the resource. Valid values:
- Deleting: The resource is deleting.
- Failure: The deletion of the resource failed.
- Success: The resource is deleted.
- Skipped: The deletion of the resource is skipped.
- Pending: The deletion of the resource is not started.
- ResourceStatusReason: The information of the related ResourceStatus.
- Dependencies: The resources that need to be deleted before the deletion of the resource. The value is a list of dict. The dict contains the fields below:
- ResourceType: Resource type of the dependency resource.
- RegionId: Region ID of the dependency resource.
- ResourceId: ID of the dependency resource.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrResourceDetails"))
@builtins.property
@jsii.member(jsii_name="attrResourcePartialDetails")
def attr_resource_partial_details(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute ResourcePartialDetails: The partial details of resources to be cleaned up.
The value is a list of dict. The dict contains the fields below:
- ResourceType: Resource type of the resource.
- RegionId: Region ID of the resource.
- ResourceId: ID of the resource.
- ResourceName: Name of the resource.
- ResourceStatus: Status of the resource. Valid values:
- Deleting: The resource is deleting.
- Failure: The deletion of the resource failed.
- Success: The resource is deleted.
- Skipped: The deletion of the resource is skipped.
- Pending: The deletion of the resource is not started.
- ResourceStatusReason: The information of the related ResourceStatus.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrResourcePartialDetails"))
@builtins.property
@jsii.member(jsii_name="attrResourceSummary")
def attr_resource_summary(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute ResourceSummary: The details of resources to be cleaned up.
The value is a list of dict. The dict contains the fields below:
- ResourceType: Resource type of the resources.
- DeletingCount: Number of deleting resources of the resource type.
- SuccessCount: Number of deleted resources of the resource type.
- FailureCount: Number of resources that failed to delete of the resource type.
- SkippedCount: Number of skipped resources of the resource type.
- PendingCount: Number of resources that have not been deleted of the resource type.
- OtherCount: Number of other resources of the resource type.
- TotalCount: Number of total resources of the resource type.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrResourceSummary"))
@builtins.property
@jsii.member(jsii_name="attrScanErrors")
def attr_scan_errors(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute ScanErrors: The scan errors.
It takes effect only when property Mode is Loose.
The value is a list of dict. The dict contains the fields below:
- ResourceType: Resource type for scanning.
- RegionId: Region ID for scanning.
- ErrorMessage: Error message of scanning with specified resource type and region ID.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrScanErrors"))
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-ros.ResourceCleanerProps",
jsii_struct_bases=[],
name_mapping={
"action": "action",
"clean_up_algorithm": "cleanUpAlgorithm",
"clean_up_retry_count": "cleanUpRetryCount",
"clean_up_timeout": "cleanUpTimeout",
"disabled_side_effects": "disabledSideEffects",
"excluded_resources": "excludedResources",
"failure_option": "failureOption",
"mode": "mode",
"resource_filters": "resourceFilters",
"resources": "resources",
"resource_type_order": "resourceTypeOrder",
},
)
class ResourceCleanerProps:
def __init__(
self,
*,
action: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
clean_up_algorithm: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
clean_up_retry_count: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
clean_up_timeout: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
disabled_side_effects: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]] = None,
excluded_resources: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union["RosResourceCleaner.ExcludedResourcesProperty", typing.Dict[builtins.str, typing.Any]]]]]] = None,
failure_option: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
mode: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
resource_filters: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union["RosResourceCleaner.ResourceFiltersProperty", typing.Dict[builtins.str, typing.Any]]]]]] = None,
resources: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union["RosResourceCleaner.ResourcesProperty", typing.Dict[builtins.str, typing.Any]]]]]] = None,
resource_type_order: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::ROS::ResourceCleaner``.
:param action: Property action: Resource cleaner actions: - Scan: Scanning phase. Scan out the resources to be cleaned up. - CleanUp: Cleanup phase. Clean up the scanned resources. It it not allowed for resource creation. - Scan+CleanUp: Scan first, then CleanUp. - ScanWhenCreatingAndUpdating+CleanUpWhenDeleting: Scan when creating or updating resource, and CleanUp when deleting stack.
:param clean_up_algorithm: Property cleanUpAlgorithm: The cleanup algorithm of cleanup phase: - ResourceDependency: Clean up by resource dependency tree. - ResourceTypeOrder: Clean up by resource type order. Property ResourceTypeOrder can be used to specify resource type order. If it is not specified, a default order will be used. Default to ResourceDependency.
:param clean_up_retry_count: Property cleanUpRetryCount: The maximum number of executions of cleanup phase. Default to 1, which means no retry. Conditions that trigger a retry: (the relationship is or) 1.There are resources which fail to be cleaned up. 2.The cleanup is timeout.
:param clean_up_timeout: Property cleanUpTimeout: The timeout seconds of executions of cleanup phase. Default to 1 hour.
:param disabled_side_effects: Property disabledSideEffects: Side effects to be disabled. Cleaning up some resources will cause some side effects. If is not expected, use the property to disable them. The side effects can be found in response(ResourceCleaner) of API GetFeatureDetails.
:param excluded_resources: Property excludedResources: Exclude parts from resources to be cleaned up.
:param failure_option: Property failureOption: The failure option of cleanup phase: - Normal: Resource failure does not affect the resources that depend on it. - Fast: Resource failure causes all resources that depend on it to fail. Default to Normal.
:param mode: Property mode: The result mode of resource cleaner: - Strict: Any scanning or cleanup failure leads to the failure of the cleaner. - Loose: Only a little scanning and cleanup failures lead to the failure of the cleaner. Most scanning failures will be ignored, failure messages can be found in ScanErrors or ResourceDetails. Most cleanup failures will be ignored, failure messages can be found in ResourceDetails. Default to Loose.
:param resource_filters: Property resourceFilters: Resource filters that ResourceCleaner uses to filter out the resources to be cleaned up during scanning. Only one of ResourceFilters and Resources can be specified. There are two filtering behaviors(Effect): Allow and Deny. The filters work as below: 1.Any resource denied by any Deny filter will not be cleaned up. 2.Only resources allowed by some Allow filter and not denied by any Deny filter will be cleaned up. If filters are changed during resource update, ResourceCleaner requires to rescan. And if Action equals CleanUp, an error occurs.
:param resources: Property resources: Resources to be cleaned up. Only one of Resources and ResourceFilters can be specified.
:param resource_type_order: Property resourceTypeOrder: This property takes effect only when property CleanUpAlgorithm is ResourceTypeOrder. If it takes effect: - Resources will be cleaned up in order from front to back. - Resource with resource type not specified in this property will not be cleaned up.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__0331866add02443ec8b42c3f37daeae5168b155c40af69d959ef0fabb58d5178)
check_type(argname="argument action", value=action, expected_type=type_hints["action"])
check_type(argname="argument clean_up_algorithm", value=clean_up_algorithm, expected_type=type_hints["clean_up_algorithm"])
check_type(argname="argument clean_up_retry_count", value=clean_up_retry_count, expected_type=type_hints["clean_up_retry_count"])
check_type(argname="argument clean_up_timeout", value=clean_up_timeout, expected_type=type_hints["clean_up_timeout"])
check_type(argname="argument disabled_side_effects", value=disabled_side_effects, expected_type=type_hints["disabled_side_effects"])
check_type(argname="argument excluded_resources", value=excluded_resources, expected_type=type_hints["excluded_resources"])
check_type(argname="argument failure_option", value=failure_option, expected_type=type_hints["failure_option"])
check_type(argname="argument mode", value=mode, expected_type=type_hints["mode"])
check_type(argname="argument resource_filters", value=resource_filters, expected_type=type_hints["resource_filters"])
check_type(argname="argument resources", value=resources, expected_type=type_hints["resources"])
check_type(argname="argument resource_type_order", value=resource_type_order, expected_type=type_hints["resource_type_order"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"action": action,
}
if clean_up_algorithm is not None:
self._values["clean_up_algorithm"] = clean_up_algorithm
if clean_up_retry_count is not None:
self._values["clean_up_retry_count"] = clean_up_retry_count
if clean_up_timeout is not None:
self._values["clean_up_timeout"] = clean_up_timeout
if disabled_side_effects is not None:
self._values["disabled_side_effects"] = disabled_side_effects
if excluded_resources is not None:
self._values["excluded_resources"] = excluded_resources
if failure_option is not None:
self._values["failure_option"] = failure_option
if mode is not None:
self._values["mode"] = mode
if resource_filters is not None:
self._values["resource_filters"] = resource_filters
if resources is not None:
self._values["resources"] = resources
if resource_type_order is not None:
self._values["resource_type_order"] = resource_type_order
@builtins.property
def action(self) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property action: Resource cleaner actions: - Scan: Scanning phase.
Scan out the resources to be cleaned up.
- CleanUp: Cleanup phase. Clean up the scanned resources. It it not allowed for resource creation.
- Scan+CleanUp: Scan first, then CleanUp.
- ScanWhenCreatingAndUpdating+CleanUpWhenDeleting: Scan when creating or updating resource, and CleanUp when deleting stack.
'''
result = self._values.get("action")
assert result is not None, "Required property 'action' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def clean_up_algorithm(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property cleanUpAlgorithm: The cleanup algorithm of cleanup phase: - ResourceDependency: Clean up by resource dependency tree.
- ResourceTypeOrder: Clean up by resource type order. Property ResourceTypeOrder can be used to specify resource type order. If it is not specified, a default order will be used.
Default to ResourceDependency.
'''
result = self._values.get("clean_up_algorithm")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def clean_up_retry_count(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property cleanUpRetryCount: The maximum number of executions of cleanup phase.
Default to 1, which means no retry.
Conditions that trigger a retry: (the relationship is or)
1.There are resources which fail to be cleaned up.
2.The cleanup is timeout.
'''
result = self._values.get("clean_up_retry_count")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def clean_up_timeout(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property cleanUpTimeout: The timeout seconds of executions of cleanup phase.
Default to 1 hour.
'''
result = self._values.get("clean_up_timeout")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def disabled_side_effects(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]]:
'''Property disabledSideEffects: Side effects to be disabled.
Cleaning up some resources will cause some side effects. If is not expected, use the property to disable them.
The side effects can be found in response(ResourceCleaner) of API GetFeatureDetails.
'''
result = self._values.get("disabled_side_effects")
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]], result)
@builtins.property
def excluded_resources(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosResourceCleaner.ExcludedResourcesProperty"]]]]:
'''Property excludedResources: Exclude parts from resources to be cleaned up.'''
result = self._values.get("excluded_resources")
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosResourceCleaner.ExcludedResourcesProperty"]]]], result)
@builtins.property
def failure_option(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property failureOption: The failure option of cleanup phase: - Normal: Resource failure does not affect the resources that depend on it.
- Fast: Resource failure causes all resources that depend on it to fail.
Default to Normal.
'''
result = self._values.get("failure_option")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def mode(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property mode: The result mode of resource cleaner: - Strict: Any scanning or cleanup failure leads to the failure of the cleaner.
- Loose: Only a little scanning and cleanup failures lead to the failure of the cleaner. Most scanning failures will be ignored, failure messages can be found in ScanErrors or ResourceDetails. Most cleanup failures will be ignored, failure messages can be found in ResourceDetails.
Default to Loose.
'''
result = self._values.get("mode")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def resource_filters(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosResourceCleaner.ResourceFiltersProperty"]]]]:
'''Property resourceFilters: Resource filters that ResourceCleaner uses to filter out the resources to be cleaned up during scanning.
Only one of ResourceFilters and Resources can be specified.
There are two filtering behaviors(Effect): Allow and Deny. The filters work as below:
1.Any resource denied by any Deny filter will not be cleaned up.
2.Only resources allowed by some Allow filter and not denied by any Deny filter will be cleaned up.
If filters are changed during resource update, ResourceCleaner requires to rescan. And if Action equals CleanUp, an error occurs.
'''
result = self._values.get("resource_filters")
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosResourceCleaner.ResourceFiltersProperty"]]]], result)
@builtins.property
def resources(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosResourceCleaner.ResourcesProperty"]]]]:
'''Property resources: Resources to be cleaned up.
Only one of Resources and ResourceFilters can be specified.
'''
result = self._values.get("resources")
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosResourceCleaner.ResourcesProperty"]]]], result)
@builtins.property
def resource_type_order(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]]:
'''Property resourceTypeOrder: This property takes effect only when property CleanUpAlgorithm is ResourceTypeOrder.
If it takes effect:
- Resources will be cleaned up in order from front to back.
- Resource with resource type not specified in this property will not be cleaned up.
'''
result = self._values.get("resource_type_order")
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "ResourceCleanerProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class RosAutoEnableService(
_ros_cdk_core_7adfd82f.RosResource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-ros.RosAutoEnableService",
):
'''A ROS template type: ``ALIYUN::ROS::AutoEnableService``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["RosAutoEnableServiceProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
'''Create a new ``ALIYUN::ROS::AutoEnableService``.
:param scope: - scope in which this resource is defined.
:param id: - scoped id of the resource.
:param props: - resource properties.
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__0ec33eb47cb3443e767e1061d66564a07c572b34d90608a623c4aa9ae886970b)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@jsii.member(jsii_name="renderProperties")
def _render_properties(
self,
props: typing.Mapping[builtins.str, typing.Any],
) -> typing.Mapping[builtins.str, typing.Any]:
'''
:param props: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__8db009b9e7abb19b7a01094ec53a7c186d5886d4dadb880cd0c1bdfa98f09e43)
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))
@jsii.python.classproperty
@jsii.member(jsii_name="ROS_RESOURCE_TYPE_NAME")
def ROS_RESOURCE_TYPE_NAME(cls) -> builtins.str:
'''The resource type name for this resource class.'''
return typing.cast(builtins.str, jsii.sget(cls, "ROS_RESOURCE_TYPE_NAME"))
@builtins.property
@jsii.member(jsii_name="rosProperties")
def _ros_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "rosProperties"))
@builtins.property
@jsii.member(jsii_name="enableResourcePropertyConstraint")
def enable_resource_property_constraint(self) -> builtins.bool:
'''A factory method that creates a new instance of this class from an object containing the properties of this ROS resource.'''
return typing.cast(builtins.bool, jsii.get(self, "enableResourcePropertyConstraint"))
@enable_resource_property_constraint.setter
def enable_resource_property_constraint(self, value: builtins.bool) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__55def99714dd96ecb578e820aca777d664c6694946d9a0e8c59ddeb54184886a)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "enableResourcePropertyConstraint", value)
@builtins.property
@jsii.member(jsii_name="serviceName")
def service_name(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
serviceName: Which service to enable. Valid values:
AHAS: Application High Availability Service
ARMS: Realtime Monitoring Service
ApiGateway: API Gateway
BatchCompute: Batch Compute
BrainIndustrial: Brain Industrial
CloudStorageGateway: Cloud Storage Gateway
CMS: Cloud Monitor Service
CR: Container Registry
CS: Container Service
DataHub: Data Hub
DataWorks: DataWorks
DCDN: Dynamic Route for CDN
EDAS: Enterprise Distributed Application Service
EMAS: Enterprise Mobile Application Studio
FC: Function Compute
FNF: Serverless Workflow
MaxCompute: MaxCompute
NAS: Network Attached Storage
MNS: Message Service (MNS)
HBR: Hybrid Backup Recovery
IMM: Intelligent Media Management
IOT: IoT Platform
KMS: Key Management Service
NLP: Natural Language Processing
OSS: Object Storage Service
OTS: Table Store
PrivateLink: Private Link
PrivateZone: Private Zone
RocketMQ: RocketMQ
SAE: Serverless App Engine
SLS: Log Service
TrafficMirror: VPC Traffic Mirroring
VS: Video Surveillance
Xtrace: Tracing Anlaysis
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "serviceName"))
@service_name.setter
def service_name(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__0312d513329bf53c232a3c6a41a826f17c20a291120b6ada9d0bb646e4082f5f)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "serviceName", value)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-ros.RosAutoEnableServiceProps",
jsii_struct_bases=[],
name_mapping={"service_name": "serviceName"},
)
class RosAutoEnableServiceProps:
def __init__(
self,
*,
service_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
'''Properties for defining a ``ALIYUN::ROS::AutoEnableService``.
:param service_name:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__585ade1d0095b50f360bf4052cfb0313d1704881d0adab4882332b789868ac88)
check_type(argname="argument service_name", value=service_name, expected_type=type_hints["service_name"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"service_name": service_name,
}
@builtins.property
def service_name(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
serviceName: Which service to enable. Valid values:
AHAS: Application High Availability Service
ARMS: Realtime Monitoring Service
ApiGateway: API Gateway
BatchCompute: Batch Compute
BrainIndustrial: Brain Industrial
CloudStorageGateway: Cloud Storage Gateway
CMS: Cloud Monitor Service
CR: Container Registry
CS: Container Service
DataHub: Data Hub
DataWorks: DataWorks
DCDN: Dynamic Route for CDN
EDAS: Enterprise Distributed Application Service
EMAS: Enterprise Mobile Application Studio
FC: Function Compute
FNF: Serverless Workflow
MaxCompute: MaxCompute
NAS: Network Attached Storage
MNS: Message Service (MNS)
HBR: Hybrid Backup Recovery
IMM: Intelligent Media Management
IOT: IoT Platform
KMS: Key Management Service
NLP: Natural Language Processing
OSS: Object Storage Service
OTS: Table Store
PrivateLink: Private Link
PrivateZone: Private Zone
RocketMQ: RocketMQ
SAE: Serverless App Engine
SLS: Log Service
TrafficMirror: VPC Traffic Mirroring
VS: Video Surveillance
Xtrace: Tracing Anlaysis
'''
result = self._values.get("service_name")
assert result is not None, "Required property 'service_name' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "RosAutoEnableServiceProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class RosCustomResource(
_ros_cdk_core_7adfd82f.RosResource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-ros.RosCustomResource",
):
'''A ROS template type: ``ALIYUN::ROS::CustomResource``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["RosCustomResourceProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
'''Create a new ``ALIYUN::ROS::CustomResource``.
:param scope: - scope in which this resource is defined.
:param id: - scoped id of the resource.
:param props: - resource properties.
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__620cef2fc3ea4900166471cf74ad71a22f9b4baa2fffa94cb2f8001f866726c0)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@jsii.member(jsii_name="renderProperties")
def _render_properties(
self,
props: typing.Mapping[builtins.str, typing.Any],
) -> typing.Mapping[builtins.str, typing.Any]:
'''
:param props: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__0422aa4f44733abef4ecc28d768a4f25ad20655858c4bdbf0016cb6873ec1cb4)
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))
@jsii.python.classproperty
@jsii.member(jsii_name="ROS_RESOURCE_TYPE_NAME")
def ROS_RESOURCE_TYPE_NAME(cls) -> builtins.str:
'''The resource type name for this resource class.'''
return typing.cast(builtins.str, jsii.sget(cls, "ROS_RESOURCE_TYPE_NAME"))
@builtins.property
@jsii.member(jsii_name="attrOutputs")
def attr_outputs(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: Outputs: Output data received from service provider.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrOutputs"))
@builtins.property
@jsii.member(jsii_name="rosProperties")
def _ros_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "rosProperties"))
@builtins.property
@jsii.member(jsii_name="enableResourcePropertyConstraint")
def enable_resource_property_constraint(self) -> builtins.bool:
return typing.cast(builtins.bool, jsii.get(self, "enableResourcePropertyConstraint"))
@enable_resource_property_constraint.setter
def enable_resource_property_constraint(self, value: builtins.bool) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__bb5258d5a90ff55da1defdfd807ffc3e48fcea17fad4efb99d63405c465c4a6a)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "enableResourcePropertyConstraint", value)
@builtins.property
@jsii.member(jsii_name="serviceToken")
def service_token(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
serviceToken: The service token that was given to the template developer by the service provider to access the service.
Allowed values:
- Function Compute: acs:fc:<region_id>:<account_id>:services/<service_name>/functions/<function_name>
- MNS Queue: acs:mns:<region_id>:<account_id>:queues/<queue_name> or acs:mns:<region_id>:<account_id>:/queues/<queue_name>
- MNS Topic: acs:mns:<region_id>:<account_id>:topics/<topic_name> or acs:mns:<region_id>:<account_id>:/topics/<topic_name>
- HTTP&HTTPS: web[options]:
Two options are supported:
- sync: sync HTTP&HTTPS request.
- idempotent: indicates that the Create request is idempotent. Update and Delete requests should be always idempotent.
Examples:
- acs:fc:cn-hangzhou:123456789:services/test-service/functions/test-function
- acs:mns:cn-hangzhou:123456789:queues/test-queue
- acs:mns:cn-hangzhou:123456789:/queues/test-queue
- acs:mns:cn-hangzhou:123456789:topics/test-topic
- acs:mns:cn-hangzhou:123456789:/topics/test-topic
- web:https://abc.com
- web[sync]:http://abc.com
- web[sync,idempotent]:https://abc.com
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "serviceToken"))
@service_token.setter
def service_token(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__a2cf48b8f1cb2f16d01418e95cb85dde36dd9779c7c90cd222fb0d148ded53eb)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "serviceToken", value)
@builtins.property
@jsii.member(jsii_name="timeout")
def timeout(self) -> typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
timeout: Timeout seconds before service provider responses.
It takes effects only if the type of ServiceToken is Function Compute, MNS Queue, MNS Topic or async HTTP&HTTPS request.
Timeout seconds are always 10 for sync HTTP&HTTPS request.
'''
return typing.cast(typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "timeout"))
@timeout.setter
def timeout(
self,
value: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__effc3a3865bb6ce8fa3bfc3d3f17949e49db1b47d23dee9e754a840928a84554)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "timeout", value)
@builtins.property
@jsii.member(jsii_name="httpConfig")
def http_config(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosCustomResource.HttpConfigProperty"]]:
'''
:Property: httpConfig: Config for HTTP&HTTPS service provider.
'''
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosCustomResource.HttpConfigProperty"]], jsii.get(self, "httpConfig"))
@http_config.setter
def http_config(
self,
value: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosCustomResource.HttpConfigProperty"]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__d17b070e6a6cfb453efb23e21c31851c238bf55f4187f7186b054d19d732489b)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "httpConfig", value)
@builtins.property
@jsii.member(jsii_name="parameters")
def parameters(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]]:
'''
:Property: parameters: Parameters to be passed to service provider.
'''
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]], jsii.get(self, "parameters"))
@parameters.setter
def parameters(
self,
value: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__aeb771102b09e85e65d5eb81ac7790fa026a773629043f39c9ab089e6d77f1c0)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "parameters", value)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-ros.RosCustomResource.HttpConfigProperty",
jsii_struct_bases=[],
name_mapping={
"content_type": "contentType",
"headers": "headers",
"sign_key": "signKey",
},
)
class HttpConfigProperty:
def __init__(
self,
*,
content_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
headers: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]] = None,
sign_key: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''
:param content_type:
:param headers:
:param sign_key:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__892ec3d4d0d40972954d0c451c44747254e0053b3384132cb86597c6d0d85384)
check_type(argname="argument content_type", value=content_type, expected_type=type_hints["content_type"])
check_type(argname="argument headers", value=headers, expected_type=type_hints["headers"])
check_type(argname="argument sign_key", value=sign_key, expected_type=type_hints["sign_key"])
self._values: typing.Dict[builtins.str, typing.Any] = {}
if content_type is not None:
self._values["content_type"] = content_type
if headers is not None:
self._values["headers"] = headers
if sign_key is not None:
self._values["sign_key"] = sign_key
@builtins.property
def content_type(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: contentType: Content type of request body.
'''
result = self._values.get("content_type")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def headers(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]]:
'''
:Property: headers: Headers to be passed.
'''
result = self._values.get("headers")
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]], result)
@builtins.property
def sign_key(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
signKey: If SignKey is specified, Signature will be added to request data.
"Signature": {
"Date": "2021-03-11T13:32:02Z",
"Value": "10841498499ba1c4b07547a542c3a8718235f983"
}
Date: the UTC time to send request, which follows the ISO 8601 standard in the yyyy-MM-ddTHH:mm:ssZ format.
Value: the signature value calculated from the algorithm below.
The signature algorithm:
1.Concatenating signature string:POST
\\n
<content type: if ContentType is specified, use it, else use application/json.>
\\n
<md5 of request data: without Signature, json format, utf-8 encoded, sort keys, ensure ascii.>
\\n
\\n
'''
result = self._values.get("sign_key")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "HttpConfigProperty(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-ros.RosCustomResourceProps",
jsii_struct_bases=[],
name_mapping={
"service_token": "serviceToken",
"timeout": "timeout",
"http_config": "httpConfig",
"parameters": "parameters",
},
)
class RosCustomResourceProps:
def __init__(
self,
*,
service_token: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
timeout: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
http_config: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union[RosCustomResource.HttpConfigProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
parameters: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::ROS::CustomResource``.
:param service_token:
:param timeout:
:param http_config:
:param parameters:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__5070879f2c1fc643d0f36f6f5ff3e11f87a52010923bf00bf832bf0e97918dd8)
check_type(argname="argument service_token", value=service_token, expected_type=type_hints["service_token"])
check_type(argname="argument timeout", value=timeout, expected_type=type_hints["timeout"])
check_type(argname="argument http_config", value=http_config, expected_type=type_hints["http_config"])
check_type(argname="argument parameters", value=parameters, expected_type=type_hints["parameters"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"service_token": service_token,
"timeout": timeout,
}
if http_config is not None:
self._values["http_config"] = http_config
if parameters is not None:
self._values["parameters"] = parameters
@builtins.property
def service_token(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
serviceToken: The service token that was given to the template developer by the service provider to access the service.
Allowed values:
- Function Compute: acs:fc:<region_id>:<account_id>:services/<service_name>/functions/<function_name>
- MNS Queue: acs:mns:<region_id>:<account_id>:queues/<queue_name> or acs:mns:<region_id>:<account_id>:/queues/<queue_name>
- MNS Topic: acs:mns:<region_id>:<account_id>:topics/<topic_name> or acs:mns:<region_id>:<account_id>:/topics/<topic_name>
- HTTP&HTTPS: web[options]:
Two options are supported:
- sync: sync HTTP&HTTPS request.
- idempotent: indicates that the Create request is idempotent. Update and Delete requests should be always idempotent.
Examples:
- acs:fc:cn-hangzhou:123456789:services/test-service/functions/test-function
- acs:mns:cn-hangzhou:123456789:queues/test-queue
- acs:mns:cn-hangzhou:123456789:/queues/test-queue
- acs:mns:cn-hangzhou:123456789:topics/test-topic
- acs:mns:cn-hangzhou:123456789:/topics/test-topic
- web:https://abc.com
- web[sync]:http://abc.com
- web[sync,idempotent]:https://abc.com
'''
result = self._values.get("service_token")
assert result is not None, "Required property 'service_token' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def timeout(self) -> typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
timeout: Timeout seconds before service provider responses.
It takes effects only if the type of ServiceToken is Function Compute, MNS Queue, MNS Topic or async HTTP&HTTPS request.
Timeout seconds are always 10 for sync HTTP&HTTPS request.
'''
result = self._values.get("timeout")
assert result is not None, "Required property 'timeout' is missing"
return typing.cast(typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def http_config(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, RosCustomResource.HttpConfigProperty]]:
'''
:Property: httpConfig: Config for HTTP&HTTPS service provider.
'''
result = self._values.get("http_config")
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, RosCustomResource.HttpConfigProperty]], result)
@builtins.property
def parameters(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]]:
'''
:Property: parameters: Parameters to be passed to service provider.
'''
result = self._values.get("parameters")
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "RosCustomResourceProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class RosResourceCleaner(
_ros_cdk_core_7adfd82f.RosResource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-ros.RosResourceCleaner",
):
'''A ROS template type: ``ALIYUN::ROS::ResourceCleaner``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["RosResourceCleanerProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
'''Create a new ``ALIYUN::ROS::ResourceCleaner``.
:param scope: - scope in which this resource is defined.
:param id: - scoped id of the resource.
:param props: - resource properties.
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__d96a805ed502f7b8059199b15802b8362bb19253a5d94baf0deabceb7c77c4b2)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@jsii.member(jsii_name="renderProperties")
def _render_properties(
self,
props: typing.Mapping[builtins.str, typing.Any],
) -> typing.Mapping[builtins.str, typing.Any]:
'''
:param props: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__e1395137282e73d6460e1fa10d896573265e4d19a0f1b2ddedff02f021273c60)
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))
@jsii.python.classproperty
@jsii.member(jsii_name="ROS_RESOURCE_TYPE_NAME")
def ROS_RESOURCE_TYPE_NAME(cls) -> builtins.str:
'''The resource type name for this resource class.'''
return typing.cast(builtins.str, jsii.sget(cls, "ROS_RESOURCE_TYPE_NAME"))
@builtins.property
@jsii.member(jsii_name="attrCleanResult")
def attr_clean_result(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute:
CleanResult: The cleanup result. Valid values:
- Success: All resources are cleaned up successfully.
- ResourceFailure: Partial resources fail to clean up.
- Timeout: Timeout to clean up.
- CheckFailure: Pre check of cleanup fails.
- UnknownFailure: Unexpected failure.
- UserCancelled: Cleanup is cancelled by user.
- None: Cleanup is not triggered.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrCleanResult"))
@builtins.property
@jsii.member(jsii_name="attrNoCleanupResourceDetails")
def attr_no_cleanup_resource_details(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute:
NoCleanupResourceDetails: The details of the resources that are scanned but filtered.
Only resources with the resource types ResourceCleaner supports and the regions not filtered are scanned.
The format is the same as ResourceDetails.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrNoCleanupResourceDetails"))
@builtins.property
@jsii.member(jsii_name="attrNoCleanupResourcePartialDetails")
def attr_no_cleanup_resource_partial_details(
self,
) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute:
NoCleanupResourcePartialDetails: The partial details of the resources that are scanned but filtered.
Only resources with the resource types ResourceCleaner supports and the regions not filtered are scanned.
The format is the same as ResourcePartialDetails.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrNoCleanupResourcePartialDetails"))
@builtins.property
@jsii.member(jsii_name="attrResourceDetails")
def attr_resource_details(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute:
ResourceDetails: The details of resources to be cleaned up.
The value is a list of dict. The dict contains the fields below:
- ResourceType: Resource type of the resource.
- RegionId: Region ID of the resource.
- ResourceId: ID of the resource.
- ResourceName: Name of the resource.
- CleanupType: Cleanup type of the resource. Valid values:
- Normal: The resource can be deleted normally.
- DeleteWithInstance: The resource will be deleted with the resource it belongs to. If the resource it belongs to is filtered or excluded, the deletion probably fails. CleanupTypeReasons give more information.
- UnableToDelete: Unable to delete the resource. CleanupTypeReasons give more information.
- CleanupTypeReasons: The information of the related CleanupType.
- ResourceStatus: Status of the resource. Valid values:
- Deleting: The resource is deleting.
- Failure: The deletion of the resource failed.
- Success: The resource is deleted.
- Skipped: The deletion of the resource is skipped.
- Pending: The deletion of the resource is not started.
- ResourceStatusReason: The information of the related ResourceStatus.
- Dependencies: The resources that need to be deleted before the deletion of the resource. The value is a list of dict. The dict contains the fields below:
- ResourceType: Resource type of the dependency resource.
- RegionId: Region ID of the dependency resource.
- ResourceId: ID of the dependency resource.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrResourceDetails"))
@builtins.property
@jsii.member(jsii_name="attrResourcePartialDetails")
def attr_resource_partial_details(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute:
ResourcePartialDetails: The partial details of resources to be cleaned up.
The value is a list of dict. The dict contains the fields below:
- ResourceType: Resource type of the resource.
- RegionId: Region ID of the resource.
- ResourceId: ID of the resource.
- ResourceName: Name of the resource.
- ResourceStatus: Status of the resource. Valid values:
- Deleting: The resource is deleting.
- Failure: The deletion of the resource failed.
- Success: The resource is deleted.
- Skipped: The deletion of the resource is skipped.
- Pending: The deletion of the resource is not started.
- ResourceStatusReason: The information of the related ResourceStatus.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrResourcePartialDetails"))
@builtins.property
@jsii.member(jsii_name="attrResourceSummary")
def attr_resource_summary(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute:
ResourceSummary: The details of resources to be cleaned up.
The value is a list of dict. The dict contains the fields below:
- ResourceType: Resource type of the resources.
- DeletingCount: Number of deleting resources of the resource type.
- SuccessCount: Number of deleted resources of the resource type.
- FailureCount: Number of resources that failed to delete of the resource type.
- SkippedCount: Number of skipped resources of the resource type.
- PendingCount: Number of resources that have not been deleted of the resource type.
- OtherCount: Number of other resources of the resource type.
- TotalCount: Number of total resources of the resource type.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrResourceSummary"))
@builtins.property
@jsii.member(jsii_name="attrScanErrors")
def attr_scan_errors(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute:
ScanErrors: The scan errors. It takes effect only when property Mode is Loose.
The value is a list of dict. The dict contains the fields below:
- ResourceType: Resource type for scanning.
- RegionId: Region ID for scanning.
- ErrorMessage: Error message of scanning with specified resource type and region ID.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrScanErrors"))
@builtins.property
@jsii.member(jsii_name="rosProperties")
def _ros_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "rosProperties"))
@builtins.property
@jsii.member(jsii_name="action")
def action(self) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
action: Resource cleaner actions:
- Scan: Scanning phase. Scan out the resources to be cleaned up.
- CleanUp: Cleanup phase. Clean up the scanned resources. It it not allowed for resource creation.
- Scan+CleanUp: Scan first, then CleanUp.
- ScanWhenCreatingAndUpdating+CleanUpWhenDeleting: Scan when creating or updating resource, and CleanUp when deleting stack.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "action"))
@action.setter
def action(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__2cf3ab24cb80dfe22407735000b11f87c807728e20d8ed93cbada35538a1e491)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "action", value)
@builtins.property
@jsii.member(jsii_name="enableResourcePropertyConstraint")
def enable_resource_property_constraint(self) -> builtins.bool:
return typing.cast(builtins.bool, jsii.get(self, "enableResourcePropertyConstraint"))
@enable_resource_property_constraint.setter
def enable_resource_property_constraint(self, value: builtins.bool) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__a206793e45e66b0a2524b1943ea326e263023693332f0d3c6e273b97f748cdfb)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "enableResourcePropertyConstraint", value)
@builtins.property
@jsii.member(jsii_name="cleanUpAlgorithm")
def clean_up_algorithm(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
cleanUpAlgorithm: The cleanup algorithm of cleanup phase:
- ResourceDependency: Clean up by resource dependency tree.
- ResourceTypeOrder: Clean up by resource type order. Property ResourceTypeOrder can be used to specify resource type order. If it is not specified, a default order will be used.
Default to ResourceDependency.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "cleanUpAlgorithm"))
@clean_up_algorithm.setter
def clean_up_algorithm(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__87210d639d856beb050ab23de225a3a0e3a3f9039edadbe2574ecb8fa16ce7f9)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "cleanUpAlgorithm", value)
@builtins.property
@jsii.member(jsii_name="cleanUpRetryCount")
def clean_up_retry_count(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
cleanUpRetryCount: The maximum number of executions of cleanup phase.
Default to 1, which means no retry.
Conditions that trigger a retry: (the relationship is or)
1.There are resources which fail to be cleaned up.
2.The cleanup is timeout.
'''
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "cleanUpRetryCount"))
@clean_up_retry_count.setter
def clean_up_retry_count(
self,
value: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__719e08526a02b48f4d105de800f9c40cacc66038706f04aabcd551d76598cac3)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "cleanUpRetryCount", value)
@builtins.property
@jsii.member(jsii_name="cleanUpTimeout")
def clean_up_timeout(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
cleanUpTimeout: The timeout seconds of executions of cleanup phase.
Default to 1 hour.
'''
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "cleanUpTimeout"))
@clean_up_timeout.setter
def clean_up_timeout(
self,
value: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__6c8ac0efdba8befcf8ca579f7e1a5e3900e8514ce64cccb7ddf35acbfe73b23e)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "cleanUpTimeout", value)
@builtins.property
@jsii.member(jsii_name="disabledSideEffects")
def disabled_side_effects(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]]:
'''
:Property:
disabledSideEffects: Side effects to be disabled.
Cleaning up some resources will cause some side effects. If is not expected, use the property to disable them.
The side effects can be found in response(ResourceCleaner) of API GetFeatureDetails.
'''
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]], jsii.get(self, "disabledSideEffects"))
@disabled_side_effects.setter
def disabled_side_effects(
self,
value: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__0ea7cc49ec2b7bbcc4640e52caa0922fbaa8c54d34ef1aeb3724423413559217)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "disabledSideEffects", value)
@builtins.property
@jsii.member(jsii_name="excludedResources")
def excluded_resources(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosResourceCleaner.ExcludedResourcesProperty"]]]]:
'''
:Property: excludedResources: Exclude parts from resources to be cleaned up.
'''
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosResourceCleaner.ExcludedResourcesProperty"]]]], jsii.get(self, "excludedResources"))
@excluded_resources.setter
def excluded_resources(
self,
value: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosResourceCleaner.ExcludedResourcesProperty"]]]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__8b2af159d9065fcc62dbda450b6d14ca229dfbdea874bae9dc4b6c3482e14aac)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "excludedResources", value)
@builtins.property
@jsii.member(jsii_name="failureOption")
def failure_option(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
failureOption: The failure option of cleanup phase:
- Normal: Resource failure does not affect the resources that depend on it.
- Fast: Resource failure causes all resources that depend on it to fail.
Default to Normal.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "failureOption"))
@failure_option.setter
def failure_option(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__03d5cb81cd2b32389428f53c8f60d347b1f7e36c8572b1c7e86c0cdf03fbebbc)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "failureOption", value)
@builtins.property
@jsii.member(jsii_name="mode")
def mode(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
mode: The result mode of resource cleaner:
- Strict: Any scanning or cleanup failure leads to the failure of the cleaner.
- Loose: Only a little scanning and cleanup failures lead to the failure of the cleaner. Most scanning failures will be ignored, failure messages can be found in ScanErrors or ResourceDetails. Most cleanup failures will be ignored, failure messages can be found in ResourceDetails.
Default to Loose.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "mode"))
@mode.setter
def mode(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__7e0b0a662d78bc76b2e9c26bf2b454474989705fe2a8f8c0edb28696290d177b)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "mode", value)
@builtins.property
@jsii.member(jsii_name="resourceFilters")
def resource_filters(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosResourceCleaner.ResourceFiltersProperty"]]]]:
'''
:Property:
resourceFilters: Resource filters that ResourceCleaner uses to filter out the resources to be cleaned up during scanning.
Only one of ResourceFilters and Resources can be specified.
There are two filtering behaviors(Effect): Allow and Deny. The filters work as below:
1.Any resource denied by any Deny filter will not be cleaned up.
2.Only resources allowed by some Allow filter and not denied by any Deny filter will be cleaned up.
If filters are changed during resource update, ResourceCleaner requires to rescan. And if Action equals CleanUp, an error occurs.
'''
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosResourceCleaner.ResourceFiltersProperty"]]]], jsii.get(self, "resourceFilters"))
@resource_filters.setter
def resource_filters(
self,
value: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosResourceCleaner.ResourceFiltersProperty"]]]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__e7053ce7fba251ebad3cc37e0d42c04b6cae903640292f83cf2204e5a60ce22f)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "resourceFilters", value)
@builtins.property
@jsii.member(jsii_name="resources")
def resources(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosResourceCleaner.ResourcesProperty"]]]]:
'''
:Property:
resources: Resources to be cleaned up.
Only one of Resources and ResourceFilters can be specified.
'''
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosResourceCleaner.ResourcesProperty"]]]], jsii.get(self, "resources"))
@resources.setter
def resources(
self,
value: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosResourceCleaner.ResourcesProperty"]]]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__d63659a9d70be1b7da590dd97cebf62781a280f29574d181e2ee5aa5f638ec63)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "resources", value)
@builtins.property
@jsii.member(jsii_name="resourceTypeOrder")
def resource_type_order(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]]:
'''
:Property:
resourceTypeOrder: This property takes effect only when property CleanUpAlgorithm is ResourceTypeOrder.
If it takes effect:
- Resources will be cleaned up in order from front to back.
- Resource with resource type not specified in this property will not be cleaned up.
'''
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]], jsii.get(self, "resourceTypeOrder"))
@resource_type_order.setter
def resource_type_order(
self,
value: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__3d47a9fb58aebc5ca01dcf09014abc64d4c898b697ce3c8b82c177a579a4d05c)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "resourceTypeOrder", value)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-ros.RosResourceCleaner.ExcludedResourcesProperty",
jsii_struct_bases=[],
name_mapping={
"resource_id": "resourceId",
"region_id": "regionId",
"resource_type": "resourceType",
},
)
class ExcludedResourcesProperty:
def __init__(
self,
*,
resource_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
region_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
resource_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''
:param resource_id:
:param region_id:
:param resource_type:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__d57c77041d892a131393c6d140f9fac86b662ef34fe1d4120f96ea20009358b4)
check_type(argname="argument resource_id", value=resource_id, expected_type=type_hints["resource_id"])
check_type(argname="argument region_id", value=region_id, expected_type=type_hints["region_id"])
check_type(argname="argument resource_type", value=resource_type, expected_type=type_hints["resource_type"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"resource_id": resource_id,
}
if region_id is not None:
self._values["region_id"] = region_id
if resource_type is not None:
self._values["resource_type"] = resource_type
@builtins.property
def resource_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: resourceId: The ID of the resource to be excluded.
'''
result = self._values.get("resource_id")
assert result is not None, "Required property 'resource_id' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def region_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: regionId: The region ID of the resource to be excluded.
'''
result = self._values.get("region_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def resource_type(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
resourceType: The resource type of the resource to be excluded.
The allowed values are the resource types that ResourceCleaner supports to clean up.
'''
result = self._values.get("resource_type")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "ExcludedResourcesProperty(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-ros.RosResourceCleaner.ResourceFiltersProperty",
jsii_struct_bases=[],
name_mapping={
"effect": "effect",
"include_deletion_protection": "includeDeletionProtection",
"region_ids": "regionIds",
"resource_group_ids": "resourceGroupIds",
"resource_ids": "resourceIds",
"resource_name_patterns": "resourceNamePatterns",
"resource_type_patterns": "resourceTypePatterns",
"tags": "tags",
},
)
class ResourceFiltersProperty:
def __init__(
self,
*,
effect: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
include_deletion_protection: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
region_ids: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]] = None,
resource_group_ids: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]] = None,
resource_ids: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]] = None,
resource_name_patterns: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]] = None,
resource_type_patterns: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]] = None,
tags: typing.Optional[typing.Sequence[typing.Union["RosResourceCleaner.TagsProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
'''
:param effect:
:param include_deletion_protection:
:param region_ids:
:param resource_group_ids:
:param resource_ids:
:param resource_name_patterns:
:param resource_type_patterns:
:param tags:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__77d0b1298d806ff089bb0dc89535c4f113b894402d7ac95130e1248a02b2a491)
check_type(argname="argument effect", value=effect, expected_type=type_hints["effect"])
check_type(argname="argument include_deletion_protection", value=include_deletion_protection, expected_type=type_hints["include_deletion_protection"])
check_type(argname="argument region_ids", value=region_ids, expected_type=type_hints["region_ids"])
check_type(argname="argument resource_group_ids", value=resource_group_ids, expected_type=type_hints["resource_group_ids"])
check_type(argname="argument resource_ids", value=resource_ids, expected_type=type_hints["resource_ids"])
check_type(argname="argument resource_name_patterns", value=resource_name_patterns, expected_type=type_hints["resource_name_patterns"])
check_type(argname="argument resource_type_patterns", value=resource_type_patterns, expected_type=type_hints["resource_type_patterns"])
check_type(argname="argument tags", value=tags, expected_type=type_hints["tags"])
self._values: typing.Dict[builtins.str, typing.Any] = {}
if effect is not None:
self._values["effect"] = effect
if include_deletion_protection is not None:
self._values["include_deletion_protection"] = include_deletion_protection
if region_ids is not None:
self._values["region_ids"] = region_ids
if resource_group_ids is not None:
self._values["resource_group_ids"] = resource_group_ids
if resource_ids is not None:
self._values["resource_ids"] = resource_ids
if resource_name_patterns is not None:
self._values["resource_name_patterns"] = resource_name_patterns
if resource_type_patterns is not None:
self._values["resource_type_patterns"] = resource_type_patterns
if tags is not None:
self._values["tags"] = tags
@builtins.property
def effect(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
effect: Filtering behavior:
- Allow: Resource might be cleaned up if it passes the filter, will not be cleaned up if it does not pass the filter.
- Deny: Resource will not be cleaned up if it passes the filter.See also ResourceFilters for more details.
'''
result = self._values.get("effect")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def include_deletion_protection(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
includeDeletionProtection: Whether to include delete protected resources.
Default to True.
'''
result = self._values.get("include_deletion_protection")
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def region_ids(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]]:
'''
:Property:
regionIds: Region filtering.
The relationship of each item is or.
'''
result = self._values.get("region_ids")
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]], result)
@builtins.property
def resource_group_ids(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]]:
'''
:Property:
resourceGroupIds: Resource group filtering.
The relationship of each item is or.
'''
result = self._values.get("resource_group_ids")
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]], result)
@builtins.property
def resource_ids(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]]:
'''
:Property:
resourceIds: Resource ID filtering.
The relationship of each item is or.
'''
result = self._values.get("resource_ids")
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]], result)
@builtins.property
def resource_name_patterns(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]]:
'''
:Property:
resourceNamePatterns: Resource name fuzzy matching filtering.
The relationship of each item is or.
'''
result = self._values.get("resource_name_patterns")
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]], result)
@builtins.property
def resource_type_patterns(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]]:
'''
:Property:
resourceTypePatterns: Resource type fuzzy matching filtering.
The relationship of each item is or.
'''
result = self._values.get("resource_type_patterns")
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]], result)
@builtins.property
def tags(
self,
) -> typing.Optional[typing.List["RosResourceCleaner.TagsProperty"]]:
'''
:Property:
tags: Tag filtering, including custom tags and visible system tags.
The relationship of items with different Keys is and. The relationship of items with same Key is or.
'''
result = self._values.get("tags")
return typing.cast(typing.Optional[typing.List["RosResourceCleaner.TagsProperty"]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "ResourceFiltersProperty(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-ros.RosResourceCleaner.ResourcesProperty",
jsii_struct_bases=[],
name_mapping={
"region_id": "regionId",
"resource_id": "resourceId",
"resource_type": "resourceType",
},
)
class ResourcesProperty:
def __init__(
self,
*,
region_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
resource_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
resource_type: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
'''
:param region_id:
:param resource_id:
:param resource_type:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__22540af933791fb382255407e6a76b1346ad347c14e507ad2aaccda0aaca9ed7)
check_type(argname="argument region_id", value=region_id, expected_type=type_hints["region_id"])
check_type(argname="argument resource_id", value=resource_id, expected_type=type_hints["resource_id"])
check_type(argname="argument resource_type", value=resource_type, expected_type=type_hints["resource_type"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"region_id": region_id,
"resource_id": resource_id,
"resource_type": resource_type,
}
@builtins.property
def region_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: regionId: The region ID of the resource to be cleaned up.
'''
result = self._values.get("region_id")
assert result is not None, "Required property 'region_id' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def resource_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: resourceId: The ID of the resource to be cleaned up.
'''
result = self._values.get("resource_id")
assert result is not None, "Required property 'resource_id' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def resource_type(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
resourceType: The resource type of the resource to be cleaned up.
The allowed values are the resource types that ResourceCleaner supports to clean up.
'''
result = self._values.get("resource_type")
assert result is not None, "Required property 'resource_type' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "ResourcesProperty(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-ros.RosResourceCleaner.TagsProperty",
jsii_struct_bases=[],
name_mapping={"key": "key", "value": "value"},
)
class TagsProperty:
def __init__(
self,
*,
key: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''
:param key:
:param value:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__f42328b4dcb985397b40492afdb002a4024d69e02016f1917f526b3a9eb4c754)
check_type(argname="argument key", value=key, expected_type=type_hints["key"])
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"key": key,
}
if value is not None:
self._values["value"] = value
@builtins.property
def key(self) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: key: Tag key.
'''
result = self._values.get("key")
assert result is not None, "Required property 'key' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def value(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
value: Tag value.
If Value is not specified, as long as the tag key of the resource to be filtered exists, the resource passes the filtering of the tag key.
If multiple different Values is specified for the same tag Key, as long as the resource to be filtered contains a pair of them, the resource passes the filtering of the tag key.
'''
result = self._values.get("value")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "TagsProperty(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-ros.RosResourceCleanerProps",
jsii_struct_bases=[],
name_mapping={
"action": "action",
"clean_up_algorithm": "cleanUpAlgorithm",
"clean_up_retry_count": "cleanUpRetryCount",
"clean_up_timeout": "cleanUpTimeout",
"disabled_side_effects": "disabledSideEffects",
"excluded_resources": "excludedResources",
"failure_option": "failureOption",
"mode": "mode",
"resource_filters": "resourceFilters",
"resources": "resources",
"resource_type_order": "resourceTypeOrder",
},
)
class RosResourceCleanerProps:
def __init__(
self,
*,
action: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
clean_up_algorithm: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
clean_up_retry_count: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
clean_up_timeout: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
disabled_side_effects: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]] = None,
excluded_resources: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union[RosResourceCleaner.ExcludedResourcesProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
failure_option: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
mode: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
resource_filters: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union[RosResourceCleaner.ResourceFiltersProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
resources: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union[RosResourceCleaner.ResourcesProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
resource_type_order: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::ROS::ResourceCleaner``.
:param action:
:param clean_up_algorithm:
:param clean_up_retry_count:
:param clean_up_timeout:
:param disabled_side_effects:
:param excluded_resources:
:param failure_option:
:param mode:
:param resource_filters:
:param resources:
:param resource_type_order:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__16a1c77d183d6f3ea6d178565f7ae129faeb5a652449b9bfe96b2bfb1b4ca231)
check_type(argname="argument action", value=action, expected_type=type_hints["action"])
check_type(argname="argument clean_up_algorithm", value=clean_up_algorithm, expected_type=type_hints["clean_up_algorithm"])
check_type(argname="argument clean_up_retry_count", value=clean_up_retry_count, expected_type=type_hints["clean_up_retry_count"])
check_type(argname="argument clean_up_timeout", value=clean_up_timeout, expected_type=type_hints["clean_up_timeout"])
check_type(argname="argument disabled_side_effects", value=disabled_side_effects, expected_type=type_hints["disabled_side_effects"])
check_type(argname="argument excluded_resources", value=excluded_resources, expected_type=type_hints["excluded_resources"])
check_type(argname="argument failure_option", value=failure_option, expected_type=type_hints["failure_option"])
check_type(argname="argument mode", value=mode, expected_type=type_hints["mode"])
check_type(argname="argument resource_filters", value=resource_filters, expected_type=type_hints["resource_filters"])
check_type(argname="argument resources", value=resources, expected_type=type_hints["resources"])
check_type(argname="argument resource_type_order", value=resource_type_order, expected_type=type_hints["resource_type_order"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"action": action,
}
if clean_up_algorithm is not None:
self._values["clean_up_algorithm"] = clean_up_algorithm
if clean_up_retry_count is not None:
self._values["clean_up_retry_count"] = clean_up_retry_count
if clean_up_timeout is not None:
self._values["clean_up_timeout"] = clean_up_timeout
if disabled_side_effects is not None:
self._values["disabled_side_effects"] = disabled_side_effects
if excluded_resources is not None:
self._values["excluded_resources"] = excluded_resources
if failure_option is not None:
self._values["failure_option"] = failure_option
if mode is not None:
self._values["mode"] = mode
if resource_filters is not None:
self._values["resource_filters"] = resource_filters
if resources is not None:
self._values["resources"] = resources
if resource_type_order is not None:
self._values["resource_type_order"] = resource_type_order
@builtins.property
def action(self) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
action: Resource cleaner actions:
- Scan: Scanning phase. Scan out the resources to be cleaned up.
- CleanUp: Cleanup phase. Clean up the scanned resources. It it not allowed for resource creation.
- Scan+CleanUp: Scan first, then CleanUp.
- ScanWhenCreatingAndUpdating+CleanUpWhenDeleting: Scan when creating or updating resource, and CleanUp when deleting stack.
'''
result = self._values.get("action")
assert result is not None, "Required property 'action' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def clean_up_algorithm(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
cleanUpAlgorithm: The cleanup algorithm of cleanup phase:
- ResourceDependency: Clean up by resource dependency tree.
- ResourceTypeOrder: Clean up by resource type order. Property ResourceTypeOrder can be used to specify resource type order. If it is not specified, a default order will be used.
Default to ResourceDependency.
'''
result = self._values.get("clean_up_algorithm")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def clean_up_retry_count(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
cleanUpRetryCount: The maximum number of executions of cleanup phase.
Default to 1, which means no retry.
Conditions that trigger a retry: (the relationship is or)
1.There are resources which fail to be cleaned up.
2.The cleanup is timeout.
'''
result = self._values.get("clean_up_retry_count")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def clean_up_timeout(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
cleanUpTimeout: The timeout seconds of executions of cleanup phase.
Default to 1 hour.
'''
result = self._values.get("clean_up_timeout")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def disabled_side_effects(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]]:
'''
:Property:
disabledSideEffects: Side effects to be disabled.
Cleaning up some resources will cause some side effects. If is not expected, use the property to disable them.
The side effects can be found in response(ResourceCleaner) of API GetFeatureDetails.
'''
result = self._values.get("disabled_side_effects")
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]], result)
@builtins.property
def excluded_resources(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, RosResourceCleaner.ExcludedResourcesProperty]]]]:
'''
:Property: excludedResources: Exclude parts from resources to be cleaned up.
'''
result = self._values.get("excluded_resources")
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, RosResourceCleaner.ExcludedResourcesProperty]]]], result)
@builtins.property
def failure_option(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
failureOption: The failure option of cleanup phase:
- Normal: Resource failure does not affect the resources that depend on it.
- Fast: Resource failure causes all resources that depend on it to fail.
Default to Normal.
'''
result = self._values.get("failure_option")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def mode(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
mode: The result mode of resource cleaner:
- Strict: Any scanning or cleanup failure leads to the failure of the cleaner.
- Loose: Only a little scanning and cleanup failures lead to the failure of the cleaner. Most scanning failures will be ignored, failure messages can be found in ScanErrors or ResourceDetails. Most cleanup failures will be ignored, failure messages can be found in ResourceDetails.
Default to Loose.
'''
result = self._values.get("mode")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def resource_filters(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, RosResourceCleaner.ResourceFiltersProperty]]]]:
'''
:Property:
resourceFilters: Resource filters that ResourceCleaner uses to filter out the resources to be cleaned up during scanning.
Only one of ResourceFilters and Resources can be specified.
There are two filtering behaviors(Effect): Allow and Deny. The filters work as below:
1.Any resource denied by any Deny filter will not be cleaned up.
2.Only resources allowed by some Allow filter and not denied by any Deny filter will be cleaned up.
If filters are changed during resource update, ResourceCleaner requires to rescan. And if Action equals CleanUp, an error occurs.
'''
result = self._values.get("resource_filters")
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, RosResourceCleaner.ResourceFiltersProperty]]]], result)
@builtins.property
def resources(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, RosResourceCleaner.ResourcesProperty]]]]:
'''
:Property:
resources: Resources to be cleaned up.
Only one of Resources and ResourceFilters can be specified.
'''
result = self._values.get("resources")
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, RosResourceCleaner.ResourcesProperty]]]], result)
@builtins.property
def resource_type_order(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]]:
'''
:Property:
resourceTypeOrder: This property takes effect only when property CleanUpAlgorithm is ResourceTypeOrder.
If it takes effect:
- Resources will be cleaned up in order from front to back.
- Resource with resource type not specified in this property will not be cleaned up.
'''
result = self._values.get("resource_type_order")
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "RosResourceCleanerProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class RosSleep(
_ros_cdk_core_7adfd82f.RosResource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-ros.RosSleep",
):
'''A ROS template type: ``ALIYUN::ROS::Sleep``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["RosSleepProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
'''Create a new ``ALIYUN::ROS::Sleep``.
:param scope: - scope in which this resource is defined.
:param id: - scoped id of the resource.
:param props: - resource properties.
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__cca213ccefd05503419352e3c8203f3837b67591c820e476ececc4e769bb6476)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@jsii.member(jsii_name="renderProperties")
def _render_properties(
self,
props: typing.Mapping[builtins.str, typing.Any],
) -> typing.Mapping[builtins.str, typing.Any]:
'''
:param props: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__99ceb94c7c7e292b916387b22bcb2364bb64dcb772225ef6c0d6a33f33948965)
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))
@jsii.python.classproperty
@jsii.member(jsii_name="ROS_RESOURCE_TYPE_NAME")
def ROS_RESOURCE_TYPE_NAME(cls) -> builtins.str:
'''The resource type name for this resource class.'''
return typing.cast(builtins.str, jsii.sget(cls, "ROS_RESOURCE_TYPE_NAME"))
@builtins.property
@jsii.member(jsii_name="rosProperties")
def _ros_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "rosProperties"))
@builtins.property
@jsii.member(jsii_name="enableResourcePropertyConstraint")
def enable_resource_property_constraint(self) -> builtins.bool:
'''A factory method that creates a new instance of this class from an object containing the properties of this ROS resource.'''
return typing.cast(builtins.bool, jsii.get(self, "enableResourcePropertyConstraint"))
@enable_resource_property_constraint.setter
def enable_resource_property_constraint(self, value: builtins.bool) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__0f55764a6db9524e64337a782408ecb0f29fb1e7922663f2730eb4a734247d13)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "enableResourcePropertyConstraint", value)
@builtins.property
@jsii.member(jsii_name="createDuration")
def create_duration(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: createDuration: The number of seconds to wait before resource creation.
'''
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "createDuration"))
@create_duration.setter
def create_duration(
self,
value: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__eb4645a4573f2a315d3eb532356ad7ce1f5e962e08b847ec3997e1be942ac914)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "createDuration", value)
@builtins.property
@jsii.member(jsii_name="deleteDuration")
def delete_duration(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: deleteDuration: The number of seconds to wait before resource deletion.
'''
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "deleteDuration"))
@delete_duration.setter
def delete_duration(
self,
value: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__a3fa7e5c52a41d3119c4ee5cf678f90486cfc0c9d4dc005bb6ffa8dc76e2e5ac)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "deleteDuration", value)
@builtins.property
@jsii.member(jsii_name="triggers")
def triggers(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]]:
'''
:Property: triggers: Arbitrary map of values that, when changed, will run update or update rollback delays again.
'''
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]], jsii.get(self, "triggers"))
@triggers.setter
def triggers(
self,
value: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__eac5e73c8516d62c8748b8107cdb7d6738b647a3931560ed438e9a3d64b1c15e)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "triggers", value)
@builtins.property
@jsii.member(jsii_name="updateDuration")
def update_duration(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: updateDuration: The number of seconds to wait before resource update. It only triggers when the property Triggers change and the status of stack is UPDATE_IN_PROGRESS.
'''
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "updateDuration"))
@update_duration.setter
def update_duration(
self,
value: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__3816586d47402c821fb2bffc18b8a2602939552e65c8eccc1c6c0d5f64c6e7c2)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "updateDuration", value)
@builtins.property
@jsii.member(jsii_name="updateRollbackDuration")
def update_rollback_duration(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: updateRollbackDuration: The number of seconds to wait before resource update rollback. It only triggers when stack update failed and resource was updated.
'''
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "updateRollbackDuration"))
@update_rollback_duration.setter
def update_rollback_duration(
self,
value: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__c1f16a266a455c39ce4f1c8d4b6427ea076c50ec10e1aed814d6e5c621300472)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "updateRollbackDuration", value)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-ros.RosSleepProps",
jsii_struct_bases=[],
name_mapping={
"create_duration": "createDuration",
"delete_duration": "deleteDuration",
"triggers": "triggers",
"update_duration": "updateDuration",
"update_rollback_duration": "updateRollbackDuration",
},
)
class RosSleepProps:
def __init__(
self,
*,
create_duration: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
delete_duration: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
triggers: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]] = None,
update_duration: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
update_rollback_duration: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::ROS::Sleep``.
:param create_duration:
:param delete_duration:
:param triggers:
:param update_duration:
:param update_rollback_duration:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__b7987fe5a26aa92b3a77dd747aa812a03972bb089b73c6026506d9e9db1db76c)
check_type(argname="argument create_duration", value=create_duration, expected_type=type_hints["create_duration"])
check_type(argname="argument delete_duration", value=delete_duration, expected_type=type_hints["delete_duration"])
check_type(argname="argument triggers", value=triggers, expected_type=type_hints["triggers"])
check_type(argname="argument update_duration", value=update_duration, expected_type=type_hints["update_duration"])
check_type(argname="argument update_rollback_duration", value=update_rollback_duration, expected_type=type_hints["update_rollback_duration"])
self._values: typing.Dict[builtins.str, typing.Any] = {}
if create_duration is not None:
self._values["create_duration"] = create_duration
if delete_duration is not None:
self._values["delete_duration"] = delete_duration
if triggers is not None:
self._values["triggers"] = triggers
if update_duration is not None:
self._values["update_duration"] = update_duration
if update_rollback_duration is not None:
self._values["update_rollback_duration"] = update_rollback_duration
@builtins.property
def create_duration(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: createDuration: The number of seconds to wait before resource creation.
'''
result = self._values.get("create_duration")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def delete_duration(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: deleteDuration: The number of seconds to wait before resource deletion.
'''
result = self._values.get("delete_duration")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def triggers(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]]:
'''
:Property: triggers: Arbitrary map of values that, when changed, will run update or update rollback delays again.
'''
result = self._values.get("triggers")
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]], result)
@builtins.property
def update_duration(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: updateDuration: The number of seconds to wait before resource update. It only triggers when the property Triggers change and the status of stack is UPDATE_IN_PROGRESS.
'''
result = self._values.get("update_duration")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def update_rollback_duration(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: updateRollbackDuration: The number of seconds to wait before resource update rollback. It only triggers when stack update failed and resource was updated.
'''
result = self._values.get("update_rollback_duration")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "RosSleepProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class RosStack(
_ros_cdk_core_7adfd82f.RosResource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-ros.RosStack",
):
'''A ROS template type: ``ALIYUN::ROS::Stack``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["RosStackProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
'''Create a new ``ALIYUN::ROS::Stack``.
:param scope: - scope in which this resource is defined.
:param id: - scoped id of the resource.
:param props: - resource properties.
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__6d19ff6c89064ccea6ba2cb6625e2db34c8e6ef891a8dfb67e08c73afc90a0df)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@jsii.member(jsii_name="renderProperties")
def _render_properties(
self,
props: typing.Mapping[builtins.str, typing.Any],
) -> typing.Mapping[builtins.str, typing.Any]:
'''
:param props: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__8bf88c321c6df8e65332bf8086a50c9fbe14982e83e26b52cdf1472af72d0983)
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))
@jsii.python.classproperty
@jsii.member(jsii_name="ROS_RESOURCE_TYPE_NAME")
def ROS_RESOURCE_TYPE_NAME(cls) -> builtins.str:
'''The resource type name for this resource class.'''
return typing.cast(builtins.str, jsii.sget(cls, "ROS_RESOURCE_TYPE_NAME"))
@builtins.property
@jsii.member(jsii_name="rosProperties")
def _ros_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "rosProperties"))
@builtins.property
@jsii.member(jsii_name="enableResourcePropertyConstraint")
def enable_resource_property_constraint(self) -> builtins.bool:
'''A factory method that creates a new instance of this class from an object containing the properties of this ROS resource.'''
return typing.cast(builtins.bool, jsii.get(self, "enableResourcePropertyConstraint"))
@enable_resource_property_constraint.setter
def enable_resource_property_constraint(self, value: builtins.bool) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__8de0c5d869b839a65804da2d4c39073ca870f490995ed7feb1feeee98f8880bd)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "enableResourcePropertyConstraint", value)
@builtins.property
@jsii.member(jsii_name="parameters")
def parameters(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]]:
'''
:Property: parameters: The set of parameters passed to this nested stack.
'''
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]], jsii.get(self, "parameters"))
@parameters.setter
def parameters(
self,
value: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__8e0df706b75956f27ed59784145e81f437af1c944cc5f8c45df466260d39f8dc)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "parameters", value)
@builtins.property
@jsii.member(jsii_name="resourceGroupId")
def resource_group_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: resourceGroupId: Resource group.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "resourceGroupId"))
@resource_group_id.setter
def resource_group_id(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__c1379f96715c1bfd4c24c8bfc0c8810e0f5a92fcfa2d8670ecd2001db00799f6)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "resourceGroupId", value)
@builtins.property
@jsii.member(jsii_name="tags")
def tags(self) -> typing.Optional[typing.List["RosStack.TagsProperty"]]:
'''
:Property: tags: The tags of nested stack. If it is specified, it will be passed to all tag-supported resources in the nested stack.
'''
return typing.cast(typing.Optional[typing.List["RosStack.TagsProperty"]], jsii.get(self, "tags"))
@tags.setter
def tags(
self,
value: typing.Optional[typing.List["RosStack.TagsProperty"]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__54a4123241a47f21745e1d240b90dca2f2294e75b11fd437da125168b542cc66)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "tags", value)
@builtins.property
@jsii.member(jsii_name="templateBody")
def template_body(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]]:
'''
:Property:
templateBody: Structure containing the template body.
It is just to facilitate the passing of template. It is raw content.Functions in TemplateBody will not be resolved in parent stack.
You must specify either the TemplateBody or the TemplateURL property. If both are specified, TemplateBody will be used.
'''
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]], jsii.get(self, "templateBody"))
@template_body.setter
def template_body(
self,
value: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__262d2db5ca265873dbfe7923e3b1c982ffd8926b3286cb004123cf599714a5f0)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "templateBody", value)
@builtins.property
@jsii.member(jsii_name="templateId")
def template_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: templateId: Template ID of template containing the template body.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "templateId"))
@template_id.setter
def template_id(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__d44d231eb7362d9ffc3333c5c878ba2dab37f89c48c9186cb9182e74593baedb)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "templateId", value)
@builtins.property
@jsii.member(jsii_name="templateUrl")
def template_url(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
templateUrl: Location of file containing the template body. The URL must point to a template (max size: 524288 bytes) that is located in a http web server(http, https), or an Aliyun OSS bucket(Such as oss://ros-template/demo?RegionId=cn-hangzhou, oss://ros-template/demo. RegionId is default to the value of RegionId Parameter of the request.).
You must specify either the TemplateBody or the TemplateURL property. If both are specified, TemplateBody will be used.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "templateUrl"))
@template_url.setter
def template_url(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__14140fee33c34a019996763719f29c14d926cac0ef91a1eb11f9b3b963b3a777)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "templateUrl", value)
@builtins.property
@jsii.member(jsii_name="templateVersion")
def template_version(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: templateVersion: Template version of template containing the template body.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "templateVersion"))
@template_version.setter
def template_version(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__6bad1f0df2640157d9b0faf6139c58434e0806b1088477ad60fd379f2791ea44)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "templateVersion", value)
@builtins.property
@jsii.member(jsii_name="timeoutMins")
def timeout_mins(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: timeoutMins: The length of time, in minutes, to wait for the nested stack creation or update. Default to 60 minutes.
'''
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "timeoutMins"))
@timeout_mins.setter
def timeout_mins(
self,
value: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__5180deb15ec59728c757024bfb35dcfc511be5385427b9a30727f370792b8bbc)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "timeoutMins", value)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-ros.RosStack.TagsProperty",
jsii_struct_bases=[],
name_mapping={"key": "key", "value": "value"},
)
class TagsProperty:
def __init__(
self,
*,
key: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''
:param key:
:param value:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__c7ed03402966de59ed141451f12176129ca206bd0ea5f77d834142110bc9346e)
check_type(argname="argument key", value=key, expected_type=type_hints["key"])
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"key": key,
}
if value is not None:
self._values["value"] = value
@builtins.property
def key(self) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: key: Tag key.
'''
result = self._values.get("key")
assert result is not None, "Required property 'key' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def value(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: value: Tag value.
'''
result = self._values.get("value")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "TagsProperty(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class RosStackGroup(
_ros_cdk_core_7adfd82f.RosResource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-ros.RosStackGroup",
):
'''A ROS template type: ``ALIYUN::ROS::StackGroup``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["RosStackGroupProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
'''Create a new ``ALIYUN::ROS::StackGroup``.
:param scope: - scope in which this resource is defined.
:param id: - scoped id of the resource.
:param props: - resource properties.
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__bb0dc90a8ce8d2d43dbd7a5844cc38be3a33b4a7107e2faf55263fc630d44f21)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@jsii.member(jsii_name="renderProperties")
def _render_properties(
self,
props: typing.Mapping[builtins.str, typing.Any],
) -> typing.Mapping[builtins.str, typing.Any]:
'''
:param props: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__c4b5da0bc75c19de3fe264bbc03b2520b8a5448efe937c7d10711337ea79981f)
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))
@jsii.python.classproperty
@jsii.member(jsii_name="ROS_RESOURCE_TYPE_NAME")
def ROS_RESOURCE_TYPE_NAME(cls) -> builtins.str:
'''The resource type name for this resource class.'''
return typing.cast(builtins.str, jsii.sget(cls, "ROS_RESOURCE_TYPE_NAME"))
@builtins.property
@jsii.member(jsii_name="attrStackGroupId")
def attr_stack_group_id(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: StackGroupId: undefined
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrStackGroupId"))
@builtins.property
@jsii.member(jsii_name="rosProperties")
def _ros_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "rosProperties"))
@builtins.property
@jsii.member(jsii_name="enableResourcePropertyConstraint")
def enable_resource_property_constraint(self) -> builtins.bool:
return typing.cast(builtins.bool, jsii.get(self, "enableResourcePropertyConstraint"))
@enable_resource_property_constraint.setter
def enable_resource_property_constraint(self, value: builtins.bool) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__1050515447762202af2c09eb04a40ab13d8e267e55a9ef1be991ad0feb3b9ff2)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "enableResourcePropertyConstraint", value)
@builtins.property
@jsii.member(jsii_name="stackGroupName")
def stack_group_name(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: stackGroupName: undefined
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "stackGroupName"))
@stack_group_name.setter
def stack_group_name(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__0ce34e22d6ec551590820ccf22eea6272a7f1b9ce27f8d8aaa296ab00af3567d)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "stackGroupName", value)
@builtins.property
@jsii.member(jsii_name="administrationRoleName")
def administration_role_name(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: administrationRoleName: undefined
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "administrationRoleName"))
@administration_role_name.setter
def administration_role_name(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__8611051e3be119ec216a37fbf35a5228de5bc286de51c7271fe487abbb7c7a6d)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "administrationRoleName", value)
@builtins.property
@jsii.member(jsii_name="autoDeployment")
def auto_deployment(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosStackGroup.AutoDeploymentProperty"]]:
'''
:Property: autoDeployment: undefined
'''
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosStackGroup.AutoDeploymentProperty"]], jsii.get(self, "autoDeployment"))
@auto_deployment.setter
def auto_deployment(
self,
value: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosStackGroup.AutoDeploymentProperty"]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__8207e954cd77ba62edb85c8df77aeff3aa7c7869fb2be1c2e35f4d55e3d305e7)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "autoDeployment", value)
@builtins.property
@jsii.member(jsii_name="description")
def description(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: description: undefined
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "description"))
@description.setter
def description(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__86b154bc533c7449b1ef408d95b553d4521660ae3e257b39a98e3fce937b5a1f)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "description", value)
@builtins.property
@jsii.member(jsii_name="dynamicTemplateBody")
def dynamic_template_body(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]]:
'''
:Property: dynamicTemplateBody: undefined
'''
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]], jsii.get(self, "dynamicTemplateBody"))
@dynamic_template_body.setter
def dynamic_template_body(
self,
value: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__7c27abc0a7bcc5dc914f919f40c187fca2fb489546a55203828b1dc7333e676a)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "dynamicTemplateBody", value)
@builtins.property
@jsii.member(jsii_name="executionRoleName")
def execution_role_name(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: executionRoleName: undefined
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "executionRoleName"))
@execution_role_name.setter
def execution_role_name(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__3e844c23d1ac10e69e932739510819da82569725d15abc7f964a30810fb41302)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "executionRoleName", value)
@builtins.property
@jsii.member(jsii_name="parameters")
def parameters(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]]:
'''
:Property: parameters: undefined
'''
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]], jsii.get(self, "parameters"))
@parameters.setter
def parameters(
self,
value: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__6dcb0a5f1b8b88f6ae6379f81a3278ba1efe8379a4d99ea51f4bd57ca2891ccf)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "parameters", value)
@builtins.property
@jsii.member(jsii_name="permissionModel")
def permission_model(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: permissionModel: undefined
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "permissionModel"))
@permission_model.setter
def permission_model(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__bd10643fa01f590dc8b24a27a6b7b69accd20d12c3b13fc5aa4ce2750b70cac3)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "permissionModel", value)
@builtins.property
@jsii.member(jsii_name="resourceGroupId")
def resource_group_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: resourceGroupId: undefined
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "resourceGroupId"))
@resource_group_id.setter
def resource_group_id(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__a8e297e4252d94c28357e4b7f9f989c25aa7a1a791a48d62c3c22c222605b9d5)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "resourceGroupId", value)
@builtins.property
@jsii.member(jsii_name="templateBody")
def template_body(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]]:
'''
:Property: templateBody: undefined
'''
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]], jsii.get(self, "templateBody"))
@template_body.setter
def template_body(
self,
value: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__6a55d7bb5783f685d4e9c7fd3864be21dad07c71bec6fd8ad37501550bdda72f)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "templateBody", value)
@builtins.property
@jsii.member(jsii_name="templateId")
def template_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: templateId: undefined
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "templateId"))
@template_id.setter
def template_id(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__7c321f9bdbbb641847b8650e7fd828035dfa0a3a7a004e21f3bd754efed0b844)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "templateId", value)
@builtins.property
@jsii.member(jsii_name="templateUrl")
def template_url(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: templateUrl: undefined
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "templateUrl"))
@template_url.setter
def template_url(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__f4e826aca9d657ebffcfabaca14724524eb3e4b23f6e3379d9b47d8c697bf342)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "templateUrl", value)
@builtins.property
@jsii.member(jsii_name="templateVersion")
def template_version(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: templateVersion: undefined
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "templateVersion"))
@template_version.setter
def template_version(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__2b75222df4d35921b446a1104254a5b69a5ceb2123c19ae9386e6d60742fa8a9)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "templateVersion", value)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-ros.RosStackGroup.AutoDeploymentProperty",
jsii_struct_bases=[],
name_mapping={
"enabled": "enabled",
"retain_stacks_on_account_removal": "retainStacksOnAccountRemoval",
},
)
class AutoDeploymentProperty:
def __init__(
self,
*,
enabled: typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable],
retain_stacks_on_account_removal: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''
:param enabled:
:param retain_stacks_on_account_removal:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__80631bc33aec6685ca0f25038bf944cc4666f4a8d0ab9c65b529395cd40c35f1)
check_type(argname="argument enabled", value=enabled, expected_type=type_hints["enabled"])
check_type(argname="argument retain_stacks_on_account_removal", value=retain_stacks_on_account_removal, expected_type=type_hints["retain_stacks_on_account_removal"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"enabled": enabled,
}
if retain_stacks_on_account_removal is not None:
self._values["retain_stacks_on_account_removal"] = retain_stacks_on_account_removal
@builtins.property
def enabled(
self,
) -> typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: enabled: undefined
'''
result = self._values.get("enabled")
assert result is not None, "Required property 'enabled' is missing"
return typing.cast(typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def retain_stacks_on_account_removal(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: retainStacksOnAccountRemoval: undefined
'''
result = self._values.get("retain_stacks_on_account_removal")
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "AutoDeploymentProperty(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-ros.RosStackGroupProps",
jsii_struct_bases=[],
name_mapping={
"stack_group_name": "stackGroupName",
"administration_role_name": "administrationRoleName",
"auto_deployment": "autoDeployment",
"description": "description",
"dynamic_template_body": "dynamicTemplateBody",
"execution_role_name": "executionRoleName",
"parameters": "parameters",
"permission_model": "permissionModel",
"resource_group_id": "resourceGroupId",
"template_body": "templateBody",
"template_id": "templateId",
"template_url": "templateUrl",
"template_version": "templateVersion",
},
)
class RosStackGroupProps:
def __init__(
self,
*,
stack_group_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
administration_role_name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
auto_deployment: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union[RosStackGroup.AutoDeploymentProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
description: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
dynamic_template_body: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]] = None,
execution_role_name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
parameters: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]] = None,
permission_model: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
resource_group_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
template_body: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]] = None,
template_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
template_url: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
template_version: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::ROS::StackGroup``.
:param stack_group_name:
:param administration_role_name:
:param auto_deployment:
:param description:
:param dynamic_template_body:
:param execution_role_name:
:param parameters:
:param permission_model:
:param resource_group_id:
:param template_body:
:param template_id:
:param template_url:
:param template_version:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__3df7ab21265e5b105388acc3893739cbf524373cc52ca273403b3a08860c4452)
check_type(argname="argument stack_group_name", value=stack_group_name, expected_type=type_hints["stack_group_name"])
check_type(argname="argument administration_role_name", value=administration_role_name, expected_type=type_hints["administration_role_name"])
check_type(argname="argument auto_deployment", value=auto_deployment, expected_type=type_hints["auto_deployment"])
check_type(argname="argument description", value=description, expected_type=type_hints["description"])
check_type(argname="argument dynamic_template_body", value=dynamic_template_body, expected_type=type_hints["dynamic_template_body"])
check_type(argname="argument execution_role_name", value=execution_role_name, expected_type=type_hints["execution_role_name"])
check_type(argname="argument parameters", value=parameters, expected_type=type_hints["parameters"])
check_type(argname="argument permission_model", value=permission_model, expected_type=type_hints["permission_model"])
check_type(argname="argument resource_group_id", value=resource_group_id, expected_type=type_hints["resource_group_id"])
check_type(argname="argument template_body", value=template_body, expected_type=type_hints["template_body"])
check_type(argname="argument template_id", value=template_id, expected_type=type_hints["template_id"])
check_type(argname="argument template_url", value=template_url, expected_type=type_hints["template_url"])
check_type(argname="argument template_version", value=template_version, expected_type=type_hints["template_version"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"stack_group_name": stack_group_name,
}
if administration_role_name is not None:
self._values["administration_role_name"] = administration_role_name
if auto_deployment is not None:
self._values["auto_deployment"] = auto_deployment
if description is not None:
self._values["description"] = description
if dynamic_template_body is not None:
self._values["dynamic_template_body"] = dynamic_template_body
if execution_role_name is not None:
self._values["execution_role_name"] = execution_role_name
if parameters is not None:
self._values["parameters"] = parameters
if permission_model is not None:
self._values["permission_model"] = permission_model
if resource_group_id is not None:
self._values["resource_group_id"] = resource_group_id
if template_body is not None:
self._values["template_body"] = template_body
if template_id is not None:
self._values["template_id"] = template_id
if template_url is not None:
self._values["template_url"] = template_url
if template_version is not None:
self._values["template_version"] = template_version
@builtins.property
def stack_group_name(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: stackGroupName: undefined
'''
result = self._values.get("stack_group_name")
assert result is not None, "Required property 'stack_group_name' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def administration_role_name(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: administrationRoleName: undefined
'''
result = self._values.get("administration_role_name")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def auto_deployment(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, RosStackGroup.AutoDeploymentProperty]]:
'''
:Property: autoDeployment: undefined
'''
result = self._values.get("auto_deployment")
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, RosStackGroup.AutoDeploymentProperty]], result)
@builtins.property
def description(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: description: undefined
'''
result = self._values.get("description")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def dynamic_template_body(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]]:
'''
:Property: dynamicTemplateBody: undefined
'''
result = self._values.get("dynamic_template_body")
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]], result)
@builtins.property
def execution_role_name(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: executionRoleName: undefined
'''
result = self._values.get("execution_role_name")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def parameters(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]]:
'''
:Property: parameters: undefined
'''
result = self._values.get("parameters")
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]], result)
@builtins.property
def permission_model(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: permissionModel: undefined
'''
result = self._values.get("permission_model")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def resource_group_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: resourceGroupId: undefined
'''
result = self._values.get("resource_group_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def template_body(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]]:
'''
:Property: templateBody: undefined
'''
result = self._values.get("template_body")
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]], result)
@builtins.property
def template_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: templateId: undefined
'''
result = self._values.get("template_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def template_url(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: templateUrl: undefined
'''
result = self._values.get("template_url")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def template_version(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: templateVersion: undefined
'''
result = self._values.get("template_version")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "RosStackGroupProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class RosStackInstances(
_ros_cdk_core_7adfd82f.RosResource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-ros.RosStackInstances",
):
'''A ROS template type: ``ALIYUN::ROS::StackInstances``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["RosStackInstancesProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
'''Create a new ``ALIYUN::ROS::StackInstances``.
:param scope: - scope in which this resource is defined.
:param id: - scoped id of the resource.
:param props: - resource properties.
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__5f68c2b865bf7d07a9f13bc815982c06caf6a58839aae62e938abc89d1a82ee6)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@jsii.member(jsii_name="renderProperties")
def _render_properties(
self,
props: typing.Mapping[builtins.str, typing.Any],
) -> typing.Mapping[builtins.str, typing.Any]:
'''
:param props: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__823b4d30bf039e7be49e34d4c782799ad75402c5ad5b7d26e66904f4bf324947)
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))
@jsii.python.classproperty
@jsii.member(jsii_name="ROS_RESOURCE_TYPE_NAME")
def ROS_RESOURCE_TYPE_NAME(cls) -> builtins.str:
'''The resource type name for this resource class.'''
return typing.cast(builtins.str, jsii.sget(cls, "ROS_RESOURCE_TYPE_NAME"))
@builtins.property
@jsii.member(jsii_name="attrLastOperationId")
def attr_last_operation_id(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: LastOperationId: undefined
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrLastOperationId"))
@builtins.property
@jsii.member(jsii_name="attrStacks")
def attr_stacks(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: Stacks: undefined
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrStacks"))
@builtins.property
@jsii.member(jsii_name="rosProperties")
def _ros_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "rosProperties"))
@builtins.property
@jsii.member(jsii_name="enableResourcePropertyConstraint")
def enable_resource_property_constraint(self) -> builtins.bool:
return typing.cast(builtins.bool, jsii.get(self, "enableResourcePropertyConstraint"))
@enable_resource_property_constraint.setter
def enable_resource_property_constraint(self, value: builtins.bool) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__5b9c470258dbc5c822be175a2078ab31c315e89c79da2bfcc8dc5e9e8ca0bd24)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "enableResourcePropertyConstraint", value)
@builtins.property
@jsii.member(jsii_name="regionIds")
def region_ids(
self,
) -> typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]:
'''
:Property: regionIds: undefined
'''
return typing.cast(typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]], jsii.get(self, "regionIds"))
@region_ids.setter
def region_ids(
self,
value: typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__9062084c37863a4bbb13145ff7a47446ac1935dda760f8a7d027122b247b3386)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "regionIds", value)
@builtins.property
@jsii.member(jsii_name="stackGroupName")
def stack_group_name(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: stackGroupName: undefined
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "stackGroupName"))
@stack_group_name.setter
def stack_group_name(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__c7df7ada9ae5d0425e9ff1d1a590f8347b14a4a49574ea1efbd1a2f115ef8e91)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "stackGroupName", value)
@builtins.property
@jsii.member(jsii_name="accountIds")
def account_ids(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]]:
'''
:Property: accountIds: undefined
'''
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]], jsii.get(self, "accountIds"))
@account_ids.setter
def account_ids(
self,
value: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__72c98679ce80843eacc28aa591854c97d68a38fdad569c251de8439e3614da13)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "accountIds", value)
@builtins.property
@jsii.member(jsii_name="deploymentTargets")
def deployment_targets(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosStackInstances.DeploymentTargetsProperty"]]:
'''
:Property: deploymentTargets: undefined
'''
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosStackInstances.DeploymentTargetsProperty"]], jsii.get(self, "deploymentTargets"))
@deployment_targets.setter
def deployment_targets(
self,
value: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosStackInstances.DeploymentTargetsProperty"]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__be22f8688c6a3fceda9ca69ed4cb0aaf2d69655e3d84aa071e266b23a47da7fe)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "deploymentTargets", value)
@builtins.property
@jsii.member(jsii_name="disableRollback")
def disable_rollback(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: disableRollback: undefined
'''
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "disableRollback"))
@disable_rollback.setter
def disable_rollback(
self,
value: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__64667045967d918dc5dc25e2a339982474702ee966bbaa7c9b0b417522d5e891)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "disableRollback", value)
@builtins.property
@jsii.member(jsii_name="operationDescription")
def operation_description(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: operationDescription: undefined
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "operationDescription"))
@operation_description.setter
def operation_description(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__837fe7db7399bfcd1328dee9f76c478826c5862d93c4fe6cd8b968c53c54691e)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "operationDescription", value)
@builtins.property
@jsii.member(jsii_name="operationPreferences")
def operation_preferences(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosStackInstances.OperationPreferencesProperty"]]:
'''
:Property: operationPreferences: undefined
'''
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosStackInstances.OperationPreferencesProperty"]], jsii.get(self, "operationPreferences"))
@operation_preferences.setter
def operation_preferences(
self,
value: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosStackInstances.OperationPreferencesProperty"]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__a9846a2445e442adc87dccfd1015c9f264b8e64e789a3c004967e7bc3cb7ca4e)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "operationPreferences", value)
@builtins.property
@jsii.member(jsii_name="parameterOverrides")
def parameter_overrides(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]]:
'''
:Property: parameterOverrides: undefined
'''
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]], jsii.get(self, "parameterOverrides"))
@parameter_overrides.setter
def parameter_overrides(
self,
value: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__98d8f67193a80dbb0dfc64c2f63eaa49d1ec64c18a7a7f731c4cade5f7f8a109)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "parameterOverrides", value)
@builtins.property
@jsii.member(jsii_name="retainStacks")
def retain_stacks(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: retainStacks: undefined
'''
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "retainStacks"))
@retain_stacks.setter
def retain_stacks(
self,
value: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__dca809881ade9c30f5e50d9a55767d26eb72043d6415524e688198dd3646c0e1)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "retainStacks", value)
@builtins.property
@jsii.member(jsii_name="timeoutInMinutes")
def timeout_in_minutes(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: timeoutInMinutes: undefined
'''
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "timeoutInMinutes"))
@timeout_in_minutes.setter
def timeout_in_minutes(
self,
value: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__5f66bcb5c4d13025aa855cfcc7850cc4e9a6510f894496e2f76fac1b1ca0d410)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "timeoutInMinutes", value)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-ros.RosStackInstances.DeploymentTargetsProperty",
jsii_struct_bases=[],
name_mapping={"rd_folder_ids": "rdFolderIds"},
)
class DeploymentTargetsProperty:
def __init__(
self,
*,
rd_folder_ids: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]] = None,
) -> None:
'''
:param rd_folder_ids:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__d3080e72abcbb31718c9703a33547e1446d0fb747b78c5b6dc5018d806d03b2b)
check_type(argname="argument rd_folder_ids", value=rd_folder_ids, expected_type=type_hints["rd_folder_ids"])
self._values: typing.Dict[builtins.str, typing.Any] = {}
if rd_folder_ids is not None:
self._values["rd_folder_ids"] = rd_folder_ids
@builtins.property
def rd_folder_ids(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]]:
'''
:Property: rdFolderIds: undefined
'''
result = self._values.get("rd_folder_ids")
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "DeploymentTargetsProperty(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-ros.RosStackInstances.OperationPreferencesProperty",
jsii_struct_bases=[],
name_mapping={
"failure_tolerance_count": "failureToleranceCount",
"failure_tolerance_percentage": "failureTolerancePercentage",
"max_concurrent_count": "maxConcurrentCount",
"max_concurrent_percentage": "maxConcurrentPercentage",
},
)
class OperationPreferencesProperty:
def __init__(
self,
*,
failure_tolerance_count: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
failure_tolerance_percentage: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
max_concurrent_count: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
max_concurrent_percentage: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''
:param failure_tolerance_count:
:param failure_tolerance_percentage:
:param max_concurrent_count:
:param max_concurrent_percentage:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__63eb9bdd315957aa4506db86bb05e1cf7f2be0cd756f55135cb804aba04a7008)
check_type(argname="argument failure_tolerance_count", value=failure_tolerance_count, expected_type=type_hints["failure_tolerance_count"])
check_type(argname="argument failure_tolerance_percentage", value=failure_tolerance_percentage, expected_type=type_hints["failure_tolerance_percentage"])
check_type(argname="argument max_concurrent_count", value=max_concurrent_count, expected_type=type_hints["max_concurrent_count"])
check_type(argname="argument max_concurrent_percentage", value=max_concurrent_percentage, expected_type=type_hints["max_concurrent_percentage"])
self._values: typing.Dict[builtins.str, typing.Any] = {}
if failure_tolerance_count is not None:
self._values["failure_tolerance_count"] = failure_tolerance_count
if failure_tolerance_percentage is not None:
self._values["failure_tolerance_percentage"] = failure_tolerance_percentage
if max_concurrent_count is not None:
self._values["max_concurrent_count"] = max_concurrent_count
if max_concurrent_percentage is not None:
self._values["max_concurrent_percentage"] = max_concurrent_percentage
@builtins.property
def failure_tolerance_count(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: failureToleranceCount: undefined
'''
result = self._values.get("failure_tolerance_count")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def failure_tolerance_percentage(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: failureTolerancePercentage: undefined
'''
result = self._values.get("failure_tolerance_percentage")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def max_concurrent_count(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: maxConcurrentCount: undefined
'''
result = self._values.get("max_concurrent_count")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def max_concurrent_percentage(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: maxConcurrentPercentage: undefined
'''
result = self._values.get("max_concurrent_percentage")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "OperationPreferencesProperty(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-ros.RosStackInstancesProps",
jsii_struct_bases=[],
name_mapping={
"region_ids": "regionIds",
"stack_group_name": "stackGroupName",
"account_ids": "accountIds",
"deployment_targets": "deploymentTargets",
"disable_rollback": "disableRollback",
"operation_description": "operationDescription",
"operation_preferences": "operationPreferences",
"parameter_overrides": "parameterOverrides",
"retain_stacks": "retainStacks",
"timeout_in_minutes": "timeoutInMinutes",
},
)
class RosStackInstancesProps:
def __init__(
self,
*,
region_ids: typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]],
stack_group_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
account_ids: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]] = None,
deployment_targets: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union[RosStackInstances.DeploymentTargetsProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
disable_rollback: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
operation_description: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
operation_preferences: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union[RosStackInstances.OperationPreferencesProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
parameter_overrides: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]] = None,
retain_stacks: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
timeout_in_minutes: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::ROS::StackInstances``.
:param region_ids:
:param stack_group_name:
:param account_ids:
:param deployment_targets:
:param disable_rollback:
:param operation_description:
:param operation_preferences:
:param parameter_overrides:
:param retain_stacks:
:param timeout_in_minutes:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__296f009dca83480c49620b6f4e244139922fa78be46fa15031fb0a90baa95e28)
check_type(argname="argument region_ids", value=region_ids, expected_type=type_hints["region_ids"])
check_type(argname="argument stack_group_name", value=stack_group_name, expected_type=type_hints["stack_group_name"])
check_type(argname="argument account_ids", value=account_ids, expected_type=type_hints["account_ids"])
check_type(argname="argument deployment_targets", value=deployment_targets, expected_type=type_hints["deployment_targets"])
check_type(argname="argument disable_rollback", value=disable_rollback, expected_type=type_hints["disable_rollback"])
check_type(argname="argument operation_description", value=operation_description, expected_type=type_hints["operation_description"])
check_type(argname="argument operation_preferences", value=operation_preferences, expected_type=type_hints["operation_preferences"])
check_type(argname="argument parameter_overrides", value=parameter_overrides, expected_type=type_hints["parameter_overrides"])
check_type(argname="argument retain_stacks", value=retain_stacks, expected_type=type_hints["retain_stacks"])
check_type(argname="argument timeout_in_minutes", value=timeout_in_minutes, expected_type=type_hints["timeout_in_minutes"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"region_ids": region_ids,
"stack_group_name": stack_group_name,
}
if account_ids is not None:
self._values["account_ids"] = account_ids
if deployment_targets is not None:
self._values["deployment_targets"] = deployment_targets
if disable_rollback is not None:
self._values["disable_rollback"] = disable_rollback
if operation_description is not None:
self._values["operation_description"] = operation_description
if operation_preferences is not None:
self._values["operation_preferences"] = operation_preferences
if parameter_overrides is not None:
self._values["parameter_overrides"] = parameter_overrides
if retain_stacks is not None:
self._values["retain_stacks"] = retain_stacks
if timeout_in_minutes is not None:
self._values["timeout_in_minutes"] = timeout_in_minutes
@builtins.property
def region_ids(
self,
) -> typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]:
'''
:Property: regionIds: undefined
'''
result = self._values.get("region_ids")
assert result is not None, "Required property 'region_ids' is missing"
return typing.cast(typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]], result)
@builtins.property
def stack_group_name(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: stackGroupName: undefined
'''
result = self._values.get("stack_group_name")
assert result is not None, "Required property 'stack_group_name' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def account_ids(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]]:
'''
:Property: accountIds: undefined
'''
result = self._values.get("account_ids")
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]], result)
@builtins.property
def deployment_targets(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, RosStackInstances.DeploymentTargetsProperty]]:
'''
:Property: deploymentTargets: undefined
'''
result = self._values.get("deployment_targets")
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, RosStackInstances.DeploymentTargetsProperty]], result)
@builtins.property
def disable_rollback(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: disableRollback: undefined
'''
result = self._values.get("disable_rollback")
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def operation_description(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: operationDescription: undefined
'''
result = self._values.get("operation_description")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def operation_preferences(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, RosStackInstances.OperationPreferencesProperty]]:
'''
:Property: operationPreferences: undefined
'''
result = self._values.get("operation_preferences")
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, RosStackInstances.OperationPreferencesProperty]], result)
@builtins.property
def parameter_overrides(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]]:
'''
:Property: parameterOverrides: undefined
'''
result = self._values.get("parameter_overrides")
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]], result)
@builtins.property
def retain_stacks(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: retainStacks: undefined
'''
result = self._values.get("retain_stacks")
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def timeout_in_minutes(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: timeoutInMinutes: undefined
'''
result = self._values.get("timeout_in_minutes")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "RosStackInstancesProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-ros.RosStackProps",
jsii_struct_bases=[],
name_mapping={
"parameters": "parameters",
"resource_group_id": "resourceGroupId",
"tags": "tags",
"template_body": "templateBody",
"template_id": "templateId",
"template_url": "templateUrl",
"template_version": "templateVersion",
"timeout_mins": "timeoutMins",
},
)
class RosStackProps:
def __init__(
self,
*,
parameters: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]] = None,
resource_group_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
tags: typing.Optional[typing.Sequence[typing.Union[RosStack.TagsProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
template_body: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]] = None,
template_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
template_url: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
template_version: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
timeout_mins: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::ROS::Stack``.
:param parameters:
:param resource_group_id:
:param tags:
:param template_body:
:param template_id:
:param template_url:
:param template_version:
:param timeout_mins:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__028a4f01359b4010a644bbfdbbfa9f2642ce8740bd9955d67a9609ff47b0f9a4)
check_type(argname="argument parameters", value=parameters, expected_type=type_hints["parameters"])
check_type(argname="argument resource_group_id", value=resource_group_id, expected_type=type_hints["resource_group_id"])
check_type(argname="argument tags", value=tags, expected_type=type_hints["tags"])
check_type(argname="argument template_body", value=template_body, expected_type=type_hints["template_body"])
check_type(argname="argument template_id", value=template_id, expected_type=type_hints["template_id"])
check_type(argname="argument template_url", value=template_url, expected_type=type_hints["template_url"])
check_type(argname="argument template_version", value=template_version, expected_type=type_hints["template_version"])
check_type(argname="argument timeout_mins", value=timeout_mins, expected_type=type_hints["timeout_mins"])
self._values: typing.Dict[builtins.str, typing.Any] = {}
if parameters is not None:
self._values["parameters"] = parameters
if resource_group_id is not None:
self._values["resource_group_id"] = resource_group_id
if tags is not None:
self._values["tags"] = tags
if template_body is not None:
self._values["template_body"] = template_body
if template_id is not None:
self._values["template_id"] = template_id
if template_url is not None:
self._values["template_url"] = template_url
if template_version is not None:
self._values["template_version"] = template_version
if timeout_mins is not None:
self._values["timeout_mins"] = timeout_mins
@builtins.property
def parameters(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]]:
'''
:Property: parameters: The set of parameters passed to this nested stack.
'''
result = self._values.get("parameters")
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]], result)
@builtins.property
def resource_group_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: resourceGroupId: Resource group.
'''
result = self._values.get("resource_group_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def tags(self) -> typing.Optional[typing.List[RosStack.TagsProperty]]:
'''
:Property: tags: The tags of nested stack. If it is specified, it will be passed to all tag-supported resources in the nested stack.
'''
result = self._values.get("tags")
return typing.cast(typing.Optional[typing.List[RosStack.TagsProperty]], result)
@builtins.property
def template_body(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]]:
'''
:Property:
templateBody: Structure containing the template body.
It is just to facilitate the passing of template. It is raw content.Functions in TemplateBody will not be resolved in parent stack.
You must specify either the TemplateBody or the TemplateURL property. If both are specified, TemplateBody will be used.
'''
result = self._values.get("template_body")
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]], result)
@builtins.property
def template_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: templateId: Template ID of template containing the template body.
'''
result = self._values.get("template_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def template_url(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
templateUrl: Location of file containing the template body. The URL must point to a template (max size: 524288 bytes) that is located in a http web server(http, https), or an Aliyun OSS bucket(Such as oss://ros-template/demo?RegionId=cn-hangzhou, oss://ros-template/demo. RegionId is default to the value of RegionId Parameter of the request.).
You must specify either the TemplateBody or the TemplateURL property. If both are specified, TemplateBody will be used.
'''
result = self._values.get("template_url")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def template_version(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: templateVersion: Template version of template containing the template body.
'''
result = self._values.get("template_version")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def timeout_mins(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: timeoutMins: The length of time, in minutes, to wait for the nested stack creation or update. Default to 60 minutes.
'''
result = self._values.get("timeout_mins")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "RosStackProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class RosWaitCondition(
_ros_cdk_core_7adfd82f.RosResource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-ros.RosWaitCondition",
):
'''A ROS template type: ``ALIYUN::ROS::WaitCondition``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["RosWaitConditionProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
'''Create a new ``ALIYUN::ROS::WaitCondition``.
:param scope: - scope in which this resource is defined.
:param id: - scoped id of the resource.
:param props: - resource properties.
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__7b36122ca77fbfd6a63cd0370ae004bd94a5bf89a8efa46ab44ed7699e9cafce)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@jsii.member(jsii_name="renderProperties")
def _render_properties(
self,
props: typing.Mapping[builtins.str, typing.Any],
) -> typing.Mapping[builtins.str, typing.Any]:
'''
:param props: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__ae23af8177df06da8fc6e37ddbe5b4580b3d167248f1b05daa1add78c04d4215)
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))
@jsii.python.classproperty
@jsii.member(jsii_name="ROS_RESOURCE_TYPE_NAME")
def ROS_RESOURCE_TYPE_NAME(cls) -> builtins.str:
'''The resource type name for this resource class.'''
return typing.cast(builtins.str, jsii.sget(cls, "ROS_RESOURCE_TYPE_NAME"))
@builtins.property
@jsii.member(jsii_name="attrData")
def attr_data(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: Data: JSON serialized dict containing data associated with wait condition signals sent to the handle.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrData"))
@builtins.property
@jsii.member(jsii_name="attrErrorData")
def attr_error_data(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: ErrorData: JSON serialized dict containing data associated with wait condition error signals sent to the handle.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrErrorData"))
@builtins.property
@jsii.member(jsii_name="attrJoinedErrorData")
def attr_joined_error_data(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: JoinedErrorData: String containing data associated with wait condition error signals sent to the handle.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrJoinedErrorData"))
@builtins.property
@jsii.member(jsii_name="rosProperties")
def _ros_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "rosProperties"))
@builtins.property
@jsii.member(jsii_name="enableResourcePropertyConstraint")
def enable_resource_property_constraint(self) -> builtins.bool:
return typing.cast(builtins.bool, jsii.get(self, "enableResourcePropertyConstraint"))
@enable_resource_property_constraint.setter
def enable_resource_property_constraint(self, value: builtins.bool) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__ce9d87191d13d5c3012c001ab275e2d622e5ac34cca6b7bd602456fdcf1a9e81)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "enableResourcePropertyConstraint", value)
@builtins.property
@jsii.member(jsii_name="handle")
def handle(self) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: handle: A reference to the wait condition handle used to signal this wait condition.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "handle"))
@handle.setter
def handle(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__ba9db45571a2733c343bedcf9e4d7a8e793d5a3ffacfaf8f5d989cb7487add15)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "handle", value)
@builtins.property
@jsii.member(jsii_name="timeout")
def timeout(self) -> typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: timeout: The number of seconds to wait for the correct number of signals to arrive.
'''
return typing.cast(typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "timeout"))
@timeout.setter
def timeout(
self,
value: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__b4192186a5b66108af6feb061ee83ca94b1b210342d5d74e3eea33ceb673ee02)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "timeout", value)
@builtins.property
@jsii.member(jsii_name="count")
def count(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: count: The number of success signals that must be received before the stack creation process continues.
'''
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "count"))
@count.setter
def count(
self,
value: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__19cb3fb7870573f62c2f62fd460dec7484bdfbd60be69e7ad6c3e7e1e39d1a27)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "count", value)
@builtins.property
@jsii.member(jsii_name="showProgressEvent")
def show_progress_event(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: showProgressEvent: Whether to generate progress changed event. Default to Disabled.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "showProgressEvent"))
@show_progress_event.setter
def show_progress_event(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__410ed0349426ebbe5b7eb842714484ebb433445b59c0b628addd5f7adafe445d)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "showProgressEvent", value)
class RosWaitConditionHandle(
_ros_cdk_core_7adfd82f.RosResource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-ros.RosWaitConditionHandle",
):
'''A ROS template type: ``ALIYUN::ROS::WaitConditionHandle``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["RosWaitConditionHandleProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
'''Create a new ``ALIYUN::ROS::WaitConditionHandle``.
:param scope: - scope in which this resource is defined.
:param id: - scoped id of the resource.
:param props: - resource properties.
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__297b73ea8e02c335ce7d62f3f8d765ebf8dffebd0ce11c824a225aa2bc03d6c2)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@jsii.member(jsii_name="renderProperties")
def _render_properties(
self,
props: typing.Mapping[builtins.str, typing.Any],
) -> typing.Mapping[builtins.str, typing.Any]:
'''
:param props: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__793dbb57bb359ba5d1fcadb4d516fbed1af088d497df1fb34290a3cd9b94d1ad)
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))
@jsii.python.classproperty
@jsii.member(jsii_name="ROS_RESOURCE_TYPE_NAME")
def ROS_RESOURCE_TYPE_NAME(cls) -> builtins.str:
'''The resource type name for this resource class.'''
return typing.cast(builtins.str, jsii.sget(cls, "ROS_RESOURCE_TYPE_NAME"))
@builtins.property
@jsii.member(jsii_name="attrCurlCli")
def attr_curl_cli(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: CurlCli: Convenience attribute, provides curl CLI command prefix, which can be used for signalling handle completion or failure. You can signal success by adding --data-binary '{"status": "SUCCESS"}' , or signal failure by adding --data-binary '{"status": "FAILURE"}'
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrCurlCli"))
@builtins.property
@jsii.member(jsii_name="attrHeaders")
def attr_headers(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: Headers: HTTP POST Headers used for signalling handle completion or failure.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrHeaders"))
@builtins.property
@jsii.member(jsii_name="attrPowerShellCurlCli")
def attr_power_shell_curl_cli(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: PowerShellCurlCli: Convenience attribute, provides curl CLI command prefix for PowerShell, which can be used for signalling handle completion or failure. As this cmdlet was introduced in PowerShell 3.0, ensure the version of PowerShell satisfies the constraint. (Show the version via $PSVersionTable.PSVersion.) You can signal success by adding -Body '{"status": "SUCCESS"}' , or signal failure by adding -Body '{"status": "FAILURE"}'
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrPowerShellCurlCli"))
@builtins.property
@jsii.member(jsii_name="attrUrl")
def attr_url(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: URL: HTTP POST URL used for signalling handle completion or failure.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrUrl"))
@builtins.property
@jsii.member(jsii_name="attrWindowsCurlCli")
def attr_windows_curl_cli(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: WindowsCurlCli: Convenience attribute, provides curl CLI command prefix for Windows, which can be used for signalling handle completion or failure. As Windows does not support curl command, you need to install curl.exe and add it to PATH first. You can signal success by adding --data-binary "{"status": "SUCCESS"}" , or signal failure by adding --data-binary "{"status": "FAILURE"}"
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrWindowsCurlCli"))
@builtins.property
@jsii.member(jsii_name="rosProperties")
def _ros_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "rosProperties"))
@builtins.property
@jsii.member(jsii_name="enableResourcePropertyConstraint")
def enable_resource_property_constraint(self) -> builtins.bool:
return typing.cast(builtins.bool, jsii.get(self, "enableResourcePropertyConstraint"))
@enable_resource_property_constraint.setter
def enable_resource_property_constraint(self, value: builtins.bool) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__8f7f23ed9343e84325d0c91e4c5da6352ed4c0958b2364c068058b12c865864e)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "enableResourcePropertyConstraint", value)
@builtins.property
@jsii.member(jsii_name="count")
def count(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
count: There are 3 preconditions that make Count taking effect:
1.Mode is set to Full.
2.Count >= 0.
3.The id of signal is not specified. If so, it will be a self-increasing integer started from 1. For example, the id of the first signal is 1, the id of the second signal is 2, and so on.
If Count takes effect, signals with id > Count will be deleted before update.
The default value is -1, which means no effect.
It is recommended to quote the same value with WaitCondition.Count.
'''
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "count"))
@count.setter
def count(
self,
value: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__2faa163202b14589308011331f2c4f577dd1c4de9ec1399a352dbd78a2d2057e)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "count", value)
@builtins.property
@jsii.member(jsii_name="mode")
def mode(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
mode: If set to Increment, all old signals will be deleted before update. In this mode, WaitCondition.Count should reference an incremental value instead of a full value, such as ScalingGroupEnable.ScalingRuleArisExecuteResultNumberOfAddedInstances.
If set to Full, no old signal will be deleted unless Count is set. In this mode, WaitCondition.Count should reference a full value, such as the same value with InstanceGroup.MaxAmount. It is recommended to use this mode with Count.
Default to Full.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "mode"))
@mode.setter
def mode(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__4ba3fb86aa4cc3e8d1c11985db22dccbabf45af0f80ffac9b216163fd4ad5ca9)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "mode", value)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-ros.RosWaitConditionHandleProps",
jsii_struct_bases=[],
name_mapping={"count": "count", "mode": "mode"},
)
class RosWaitConditionHandleProps:
def __init__(
self,
*,
count: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
mode: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::ROS::WaitConditionHandle``.
:param count:
:param mode:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__50b711299e6e5f3c4d5329e531c4a9967c44994ebadbb75880543df9ae63135c)
check_type(argname="argument count", value=count, expected_type=type_hints["count"])
check_type(argname="argument mode", value=mode, expected_type=type_hints["mode"])
self._values: typing.Dict[builtins.str, typing.Any] = {}
if count is not None:
self._values["count"] = count
if mode is not None:
self._values["mode"] = mode
@builtins.property
def count(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
count: There are 3 preconditions that make Count taking effect:
1.Mode is set to Full.
2.Count >= 0.
3.The id of signal is not specified. If so, it will be a self-increasing integer started from 1. For example, the id of the first signal is 1, the id of the second signal is 2, and so on.
If Count takes effect, signals with id > Count will be deleted before update.
The default value is -1, which means no effect.
It is recommended to quote the same value with WaitCondition.Count.
'''
result = self._values.get("count")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def mode(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
mode: If set to Increment, all old signals will be deleted before update. In this mode, WaitCondition.Count should reference an incremental value instead of a full value, such as ScalingGroupEnable.ScalingRuleArisExecuteResultNumberOfAddedInstances.
If set to Full, no old signal will be deleted unless Count is set. In this mode, WaitCondition.Count should reference a full value, such as the same value with InstanceGroup.MaxAmount. It is recommended to use this mode with Count.
Default to Full.
'''
result = self._values.get("mode")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "RosWaitConditionHandleProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-ros.RosWaitConditionProps",
jsii_struct_bases=[],
name_mapping={
"handle": "handle",
"timeout": "timeout",
"count": "count",
"show_progress_event": "showProgressEvent",
},
)
class RosWaitConditionProps:
def __init__(
self,
*,
handle: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
timeout: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
count: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
show_progress_event: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::ROS::WaitCondition``.
:param handle:
:param timeout:
:param count:
:param show_progress_event:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__930acbaa7f83895d350eb4ea76aa9906c0ec14dd3773c57fedfa39a6279c2c06)
check_type(argname="argument handle", value=handle, expected_type=type_hints["handle"])
check_type(argname="argument timeout", value=timeout, expected_type=type_hints["timeout"])
check_type(argname="argument count", value=count, expected_type=type_hints["count"])
check_type(argname="argument show_progress_event", value=show_progress_event, expected_type=type_hints["show_progress_event"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"handle": handle,
"timeout": timeout,
}
if count is not None:
self._values["count"] = count
if show_progress_event is not None:
self._values["show_progress_event"] = show_progress_event
@builtins.property
def handle(self) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: handle: A reference to the wait condition handle used to signal this wait condition.
'''
result = self._values.get("handle")
assert result is not None, "Required property 'handle' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def timeout(self) -> typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: timeout: The number of seconds to wait for the correct number of signals to arrive.
'''
result = self._values.get("timeout")
assert result is not None, "Required property 'timeout' is missing"
return typing.cast(typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def count(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: count: The number of success signals that must be received before the stack creation process continues.
'''
result = self._values.get("count")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def show_progress_event(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: showProgressEvent: Whether to generate progress changed event. Default to Disabled.
'''
result = self._values.get("show_progress_event")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "RosWaitConditionProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class Sleep(
_ros_cdk_core_7adfd82f.Resource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-ros.Sleep",
):
'''A ROS resource type: ``ALIYUN::ROS::Sleep``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Optional[typing.Union["SleepProps", typing.Dict[builtins.str, typing.Any]]] = None,
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
'''Create a new ``ALIYUN::ROS::Sleep``.
Param scope - scope in which this resource is defined
Param id - scoped id of the resource
Param props - resource properties
:param scope: -
:param id: -
:param props: -
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__51238a3b7ea5963d718a3ab55e38e4ba13ddabc9f308deb695998763869b5d46)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-ros.SleepProps",
jsii_struct_bases=[],
name_mapping={
"create_duration": "createDuration",
"delete_duration": "deleteDuration",
"triggers": "triggers",
"update_duration": "updateDuration",
"update_rollback_duration": "updateRollbackDuration",
},
)
class SleepProps:
def __init__(
self,
*,
create_duration: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
delete_duration: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
triggers: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]] = None,
update_duration: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
update_rollback_duration: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::ROS::Sleep``.
:param create_duration: Property createDuration: The number of seconds to wait before resource creation.
:param delete_duration: Property deleteDuration: The number of seconds to wait before resource deletion.
:param triggers: Property triggers: Arbitrary map of values that, when changed, will run update or update rollback delays again.
:param update_duration: Property updateDuration: The number of seconds to wait before resource update. It only triggers when the property Triggers change and the status of stack is UPDATE_IN_PROGRESS.
:param update_rollback_duration: Property updateRollbackDuration: The number of seconds to wait before resource update rollback. It only triggers when stack update failed and resource was updated.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__9651688a0f3b7c1f4ead2ff79281d8335d6fcfc825a3a4527194465b2da37026)
check_type(argname="argument create_duration", value=create_duration, expected_type=type_hints["create_duration"])
check_type(argname="argument delete_duration", value=delete_duration, expected_type=type_hints["delete_duration"])
check_type(argname="argument triggers", value=triggers, expected_type=type_hints["triggers"])
check_type(argname="argument update_duration", value=update_duration, expected_type=type_hints["update_duration"])
check_type(argname="argument update_rollback_duration", value=update_rollback_duration, expected_type=type_hints["update_rollback_duration"])
self._values: typing.Dict[builtins.str, typing.Any] = {}
if create_duration is not None:
self._values["create_duration"] = create_duration
if delete_duration is not None:
self._values["delete_duration"] = delete_duration
if triggers is not None:
self._values["triggers"] = triggers
if update_duration is not None:
self._values["update_duration"] = update_duration
if update_rollback_duration is not None:
self._values["update_rollback_duration"] = update_rollback_duration
@builtins.property
def create_duration(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property createDuration: The number of seconds to wait before resource creation.'''
result = self._values.get("create_duration")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def delete_duration(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property deleteDuration: The number of seconds to wait before resource deletion.'''
result = self._values.get("delete_duration")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def triggers(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]]:
'''Property triggers: Arbitrary map of values that, when changed, will run update or update rollback delays again.'''
result = self._values.get("triggers")
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]], result)
@builtins.property
def update_duration(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property updateDuration: The number of seconds to wait before resource update.
It only triggers when the property Triggers change and the status of stack is UPDATE_IN_PROGRESS.
'''
result = self._values.get("update_duration")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def update_rollback_duration(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property updateRollbackDuration: The number of seconds to wait before resource update rollback.
It only triggers when stack update failed and resource was updated.
'''
result = self._values.get("update_rollback_duration")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "SleepProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class Stack(
_ros_cdk_core_7adfd82f.Resource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-ros.Stack",
):
'''A ROS resource type: ``ALIYUN::ROS::Stack``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Optional[typing.Union["StackProps", typing.Dict[builtins.str, typing.Any]]] = None,
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
'''Create a new ``ALIYUN::ROS::Stack``.
Param scope - scope in which this resource is defined
Param id - scoped id of the resource
Param props - resource properties
:param scope: -
:param id: -
:param props: -
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__65856122acbc66bc495a54825b5c8fe2ef3735ad8fbc11ac4cd83e9c6fbc9914)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
class StackGroup(
_ros_cdk_core_7adfd82f.Resource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-ros.StackGroup",
):
'''A ROS resource type: ``ALIYUN::ROS::StackGroup``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["StackGroupProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
'''Create a new ``ALIYUN::ROS::StackGroup``.
Param scope - scope in which this resource is defined
Param id - scoped id of the resource
Param props - resource properties
:param scope: -
:param id: -
:param props: -
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__676fbdb4aae9f081068398c3f7469df61bb9d2b2b79d94c8ff303cdb83df3030)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@builtins.property
@jsii.member(jsii_name="attrStackGroupId")
def attr_stack_group_id(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute StackGroupId: undefined.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrStackGroupId"))
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-ros.StackGroupProps",
jsii_struct_bases=[],
name_mapping={
"stack_group_name": "stackGroupName",
"administration_role_name": "administrationRoleName",
"auto_deployment": "autoDeployment",
"description": "description",
"dynamic_template_body": "dynamicTemplateBody",
"execution_role_name": "executionRoleName",
"parameters": "parameters",
"permission_model": "permissionModel",
"resource_group_id": "resourceGroupId",
"template_body": "templateBody",
"template_id": "templateId",
"template_url": "templateUrl",
"template_version": "templateVersion",
},
)
class StackGroupProps:
def __init__(
self,
*,
stack_group_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
administration_role_name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
auto_deployment: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union[RosStackGroup.AutoDeploymentProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
description: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
dynamic_template_body: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]] = None,
execution_role_name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
parameters: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]] = None,
permission_model: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
resource_group_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
template_body: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]] = None,
template_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
template_url: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
template_version: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::ROS::StackGroup``.
:param stack_group_name: Property stackGroupName: undefined.
:param administration_role_name: Property administrationRoleName: undefined.
:param auto_deployment: Property autoDeployment: undefined.
:param description: Property description: undefined.
:param dynamic_template_body: Property dynamicTemplateBody: undefined.
:param execution_role_name: Property executionRoleName: undefined.
:param parameters: Property parameters: undefined.
:param permission_model: Property permissionModel: undefined.
:param resource_group_id: Property resourceGroupId: undefined.
:param template_body: Property templateBody: undefined.
:param template_id: Property templateId: undefined.
:param template_url: Property templateUrl: undefined.
:param template_version: Property templateVersion: undefined.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__64c436a242f5f9177a74d7b22490581a7108701b2b4a1fce136ead4369168906)
check_type(argname="argument stack_group_name", value=stack_group_name, expected_type=type_hints["stack_group_name"])
check_type(argname="argument administration_role_name", value=administration_role_name, expected_type=type_hints["administration_role_name"])
check_type(argname="argument auto_deployment", value=auto_deployment, expected_type=type_hints["auto_deployment"])
check_type(argname="argument description", value=description, expected_type=type_hints["description"])
check_type(argname="argument dynamic_template_body", value=dynamic_template_body, expected_type=type_hints["dynamic_template_body"])
check_type(argname="argument execution_role_name", value=execution_role_name, expected_type=type_hints["execution_role_name"])
check_type(argname="argument parameters", value=parameters, expected_type=type_hints["parameters"])
check_type(argname="argument permission_model", value=permission_model, expected_type=type_hints["permission_model"])
check_type(argname="argument resource_group_id", value=resource_group_id, expected_type=type_hints["resource_group_id"])
check_type(argname="argument template_body", value=template_body, expected_type=type_hints["template_body"])
check_type(argname="argument template_id", value=template_id, expected_type=type_hints["template_id"])
check_type(argname="argument template_url", value=template_url, expected_type=type_hints["template_url"])
check_type(argname="argument template_version", value=template_version, expected_type=type_hints["template_version"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"stack_group_name": stack_group_name,
}
if administration_role_name is not None:
self._values["administration_role_name"] = administration_role_name
if auto_deployment is not None:
self._values["auto_deployment"] = auto_deployment
if description is not None:
self._values["description"] = description
if dynamic_template_body is not None:
self._values["dynamic_template_body"] = dynamic_template_body
if execution_role_name is not None:
self._values["execution_role_name"] = execution_role_name
if parameters is not None:
self._values["parameters"] = parameters
if permission_model is not None:
self._values["permission_model"] = permission_model
if resource_group_id is not None:
self._values["resource_group_id"] = resource_group_id
if template_body is not None:
self._values["template_body"] = template_body
if template_id is not None:
self._values["template_id"] = template_id
if template_url is not None:
self._values["template_url"] = template_url
if template_version is not None:
self._values["template_version"] = template_version
@builtins.property
def stack_group_name(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property stackGroupName: undefined.'''
result = self._values.get("stack_group_name")
assert result is not None, "Required property 'stack_group_name' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def administration_role_name(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property administrationRoleName: undefined.'''
result = self._values.get("administration_role_name")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def auto_deployment(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, RosStackGroup.AutoDeploymentProperty]]:
'''Property autoDeployment: undefined.'''
result = self._values.get("auto_deployment")
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, RosStackGroup.AutoDeploymentProperty]], result)
@builtins.property
def description(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property description: undefined.'''
result = self._values.get("description")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def dynamic_template_body(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]]:
'''Property dynamicTemplateBody: undefined.'''
result = self._values.get("dynamic_template_body")
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]], result)
@builtins.property
def execution_role_name(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property executionRoleName: undefined.'''
result = self._values.get("execution_role_name")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def parameters(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]]:
'''Property parameters: undefined.'''
result = self._values.get("parameters")
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]], result)
@builtins.property
def permission_model(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property permissionModel: undefined.'''
result = self._values.get("permission_model")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def resource_group_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property resourceGroupId: undefined.'''
result = self._values.get("resource_group_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def template_body(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]]:
'''Property templateBody: undefined.'''
result = self._values.get("template_body")
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]], result)
@builtins.property
def template_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property templateId: undefined.'''
result = self._values.get("template_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def template_url(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property templateUrl: undefined.'''
result = self._values.get("template_url")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def template_version(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property templateVersion: undefined.'''
result = self._values.get("template_version")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "StackGroupProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class StackInstances(
_ros_cdk_core_7adfd82f.Resource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-ros.StackInstances",
):
'''A ROS resource type: ``ALIYUN::ROS::StackInstances``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["StackInstancesProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
'''Create a new ``ALIYUN::ROS::StackInstances``.
Param scope - scope in which this resource is defined
Param id - scoped id of the resource
Param props - resource properties
:param scope: -
:param id: -
:param props: -
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__3ff7c4a8380f7f9fcbfb8f6efdcd916618cb26cfdb74f6c8e9339b7b77e43080)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@builtins.property
@jsii.member(jsii_name="attrLastOperationId")
def attr_last_operation_id(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute LastOperationId: undefined.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrLastOperationId"))
@builtins.property
@jsii.member(jsii_name="attrStacks")
def attr_stacks(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute Stacks: undefined.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrStacks"))
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-ros.StackInstancesProps",
jsii_struct_bases=[],
name_mapping={
"region_ids": "regionIds",
"stack_group_name": "stackGroupName",
"account_ids": "accountIds",
"deployment_targets": "deploymentTargets",
"disable_rollback": "disableRollback",
"operation_description": "operationDescription",
"operation_preferences": "operationPreferences",
"parameter_overrides": "parameterOverrides",
"retain_stacks": "retainStacks",
"timeout_in_minutes": "timeoutInMinutes",
},
)
class StackInstancesProps:
def __init__(
self,
*,
region_ids: typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]],
stack_group_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
account_ids: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]] = None,
deployment_targets: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union[RosStackInstances.DeploymentTargetsProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
disable_rollback: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
operation_description: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
operation_preferences: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union[RosStackInstances.OperationPreferencesProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
parameter_overrides: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]] = None,
retain_stacks: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
timeout_in_minutes: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::ROS::StackInstances``.
:param region_ids: Property regionIds: undefined.
:param stack_group_name: Property stackGroupName: undefined.
:param account_ids: Property accountIds: undefined.
:param deployment_targets: Property deploymentTargets: undefined.
:param disable_rollback: Property disableRollback: undefined.
:param operation_description: Property operationDescription: undefined.
:param operation_preferences: Property operationPreferences: undefined.
:param parameter_overrides: Property parameterOverrides: undefined.
:param retain_stacks: Property retainStacks: undefined.
:param timeout_in_minutes: Property timeoutInMinutes: undefined.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__f281983fa0910d1544fde2a8251a6582c04dad463d9670e20a4c74520966a8ed)
check_type(argname="argument region_ids", value=region_ids, expected_type=type_hints["region_ids"])
check_type(argname="argument stack_group_name", value=stack_group_name, expected_type=type_hints["stack_group_name"])
check_type(argname="argument account_ids", value=account_ids, expected_type=type_hints["account_ids"])
check_type(argname="argument deployment_targets", value=deployment_targets, expected_type=type_hints["deployment_targets"])
check_type(argname="argument disable_rollback", value=disable_rollback, expected_type=type_hints["disable_rollback"])
check_type(argname="argument operation_description", value=operation_description, expected_type=type_hints["operation_description"])
check_type(argname="argument operation_preferences", value=operation_preferences, expected_type=type_hints["operation_preferences"])
check_type(argname="argument parameter_overrides", value=parameter_overrides, expected_type=type_hints["parameter_overrides"])
check_type(argname="argument retain_stacks", value=retain_stacks, expected_type=type_hints["retain_stacks"])
check_type(argname="argument timeout_in_minutes", value=timeout_in_minutes, expected_type=type_hints["timeout_in_minutes"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"region_ids": region_ids,
"stack_group_name": stack_group_name,
}
if account_ids is not None:
self._values["account_ids"] = account_ids
if deployment_targets is not None:
self._values["deployment_targets"] = deployment_targets
if disable_rollback is not None:
self._values["disable_rollback"] = disable_rollback
if operation_description is not None:
self._values["operation_description"] = operation_description
if operation_preferences is not None:
self._values["operation_preferences"] = operation_preferences
if parameter_overrides is not None:
self._values["parameter_overrides"] = parameter_overrides
if retain_stacks is not None:
self._values["retain_stacks"] = retain_stacks
if timeout_in_minutes is not None:
self._values["timeout_in_minutes"] = timeout_in_minutes
@builtins.property
def region_ids(
self,
) -> typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]:
'''Property regionIds: undefined.'''
result = self._values.get("region_ids")
assert result is not None, "Required property 'region_ids' is missing"
return typing.cast(typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]], result)
@builtins.property
def stack_group_name(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property stackGroupName: undefined.'''
result = self._values.get("stack_group_name")
assert result is not None, "Required property 'stack_group_name' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def account_ids(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]]:
'''Property accountIds: undefined.'''
result = self._values.get("account_ids")
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]], result)
@builtins.property
def deployment_targets(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, RosStackInstances.DeploymentTargetsProperty]]:
'''Property deploymentTargets: undefined.'''
result = self._values.get("deployment_targets")
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, RosStackInstances.DeploymentTargetsProperty]], result)
@builtins.property
def disable_rollback(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property disableRollback: undefined.'''
result = self._values.get("disable_rollback")
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def operation_description(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property operationDescription: undefined.'''
result = self._values.get("operation_description")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def operation_preferences(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, RosStackInstances.OperationPreferencesProperty]]:
'''Property operationPreferences: undefined.'''
result = self._values.get("operation_preferences")
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, RosStackInstances.OperationPreferencesProperty]], result)
@builtins.property
def parameter_overrides(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]]:
'''Property parameterOverrides: undefined.'''
result = self._values.get("parameter_overrides")
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]], result)
@builtins.property
def retain_stacks(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property retainStacks: undefined.'''
result = self._values.get("retain_stacks")
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def timeout_in_minutes(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property timeoutInMinutes: undefined.'''
result = self._values.get("timeout_in_minutes")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "StackInstancesProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-ros.StackProps",
jsii_struct_bases=[],
name_mapping={
"parameters": "parameters",
"resource_group_id": "resourceGroupId",
"tags": "tags",
"template_body": "templateBody",
"template_id": "templateId",
"template_url": "templateUrl",
"template_version": "templateVersion",
"timeout_mins": "timeoutMins",
},
)
class StackProps:
def __init__(
self,
*,
parameters: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]] = None,
resource_group_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
tags: typing.Optional[typing.Sequence[typing.Union[RosStack.TagsProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
template_body: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]] = None,
template_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
template_url: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
template_version: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
timeout_mins: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::ROS::Stack``.
:param parameters: Property parameters: The set of parameters passed to this nested stack.
:param resource_group_id: Property resourceGroupId: Resource group.
:param tags: Property tags: The tags of nested stack. If it is specified, it will be passed to all tag-supported resources in the nested stack.
:param template_body: Property templateBody: Structure containing the template body. It is just to facilitate the passing of template. It is raw content.Functions in TemplateBody will not be resolved in parent stack. You must specify either the TemplateBody or the TemplateURL property. If both are specified, TemplateBody will be used.
:param template_id: Property templateId: Template ID of template containing the template body.
:param template_url: Property templateUrl: Location of file containing the template body. The URL must point to a template (max size: 524288 bytes) that is located in a http web server(http, https), or an Aliyun OSS bucket(Such as oss://ros-template/demo?RegionId=cn-hangzhou, oss://ros-template/demo. RegionId is default to the value of RegionId Parameter of the request.). You must specify either the TemplateBody or the TemplateURL property. If both are specified, TemplateBody will be used.
:param template_version: Property templateVersion: Template version of template containing the template body.
:param timeout_mins: Property timeoutMins: The length of time, in minutes, to wait for the nested stack creation or update. Default to 60 minutes.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__dff5755f904dcbfd7c013e8533057f031d953d3ff444976703bc527f36c292c8)
check_type(argname="argument parameters", value=parameters, expected_type=type_hints["parameters"])
check_type(argname="argument resource_group_id", value=resource_group_id, expected_type=type_hints["resource_group_id"])
check_type(argname="argument tags", value=tags, expected_type=type_hints["tags"])
check_type(argname="argument template_body", value=template_body, expected_type=type_hints["template_body"])
check_type(argname="argument template_id", value=template_id, expected_type=type_hints["template_id"])
check_type(argname="argument template_url", value=template_url, expected_type=type_hints["template_url"])
check_type(argname="argument template_version", value=template_version, expected_type=type_hints["template_version"])
check_type(argname="argument timeout_mins", value=timeout_mins, expected_type=type_hints["timeout_mins"])
self._values: typing.Dict[builtins.str, typing.Any] = {}
if parameters is not None:
self._values["parameters"] = parameters
if resource_group_id is not None:
self._values["resource_group_id"] = resource_group_id
if tags is not None:
self._values["tags"] = tags
if template_body is not None:
self._values["template_body"] = template_body
if template_id is not None:
self._values["template_id"] = template_id
if template_url is not None:
self._values["template_url"] = template_url
if template_version is not None:
self._values["template_version"] = template_version
if timeout_mins is not None:
self._values["timeout_mins"] = timeout_mins
@builtins.property
def parameters(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]]:
'''Property parameters: The set of parameters passed to this nested stack.'''
result = self._values.get("parameters")
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]], result)
@builtins.property
def resource_group_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property resourceGroupId: Resource group.'''
result = self._values.get("resource_group_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def tags(self) -> typing.Optional[typing.List[RosStack.TagsProperty]]:
'''Property tags: The tags of nested stack.
If it is specified, it will be passed to all tag-supported resources in the nested stack.
'''
result = self._values.get("tags")
return typing.cast(typing.Optional[typing.List[RosStack.TagsProperty]], result)
@builtins.property
def template_body(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]]:
'''Property templateBody: Structure containing the template body.
It is just to facilitate the passing of template. It is raw content.Functions in TemplateBody will not be resolved in parent stack.
You must specify either the TemplateBody or the TemplateURL property. If both are specified, TemplateBody will be used.
'''
result = self._values.get("template_body")
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]], result)
@builtins.property
def template_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property templateId: Template ID of template containing the template body.'''
result = self._values.get("template_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def template_url(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property templateUrl: Location of file containing the template body.
The URL must point to a template (max size: 524288 bytes) that is located in a http web server(http, https), or an Aliyun OSS bucket(Such as oss://ros-template/demo?RegionId=cn-hangzhou, oss://ros-template/demo. RegionId is default to the value of RegionId Parameter of the request.).
You must specify either the TemplateBody or the TemplateURL property. If both are specified, TemplateBody will be used.
'''
result = self._values.get("template_url")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def template_version(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property templateVersion: Template version of template containing the template body.'''
result = self._values.get("template_version")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def timeout_mins(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property timeoutMins: The length of time, in minutes, to wait for the nested stack creation or update.
Default to 60 minutes.
'''
result = self._values.get("timeout_mins")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "StackProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class WaitCondition(
_ros_cdk_core_7adfd82f.Resource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-ros.WaitCondition",
):
'''A ROS resource type: ``ALIYUN::ROS::WaitCondition``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["WaitConditionProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
'''Create a new ``ALIYUN::ROS::WaitCondition``.
Param scope - scope in which this resource is defined
Param id - scoped id of the resource
Param props - resource properties
:param scope: -
:param id: -
:param props: -
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__86b0ee6fb63e784d60e37337c08f234a1b27097b0552b79613f67a7536a67bf2)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@builtins.property
@jsii.member(jsii_name="attrData")
def attr_data(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute Data: JSON serialized dict containing data associated with wait condition signals sent to the handle.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrData"))
@builtins.property
@jsii.member(jsii_name="attrErrorData")
def attr_error_data(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute ErrorData: JSON serialized dict containing data associated with wait condition error signals sent to the handle.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrErrorData"))
@builtins.property
@jsii.member(jsii_name="attrJoinedErrorData")
def attr_joined_error_data(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute JoinedErrorData: String containing data associated with wait condition error signals sent to the handle.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrJoinedErrorData"))
class WaitConditionHandle(
_ros_cdk_core_7adfd82f.Resource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-ros.WaitConditionHandle",
):
'''A ROS resource type: ``ALIYUN::ROS::WaitConditionHandle``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Optional[typing.Union["WaitConditionHandleProps", typing.Dict[builtins.str, typing.Any]]] = None,
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
'''Create a new ``ALIYUN::ROS::WaitConditionHandle``.
Param scope - scope in which this resource is defined
Param id - scoped id of the resource
Param props - resource properties
:param scope: -
:param id: -
:param props: -
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__731334e5ac400ae777842cac9e1799ca3372f514388bbead4c764e4a146ad326)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@builtins.property
@jsii.member(jsii_name="attrCurlCli")
def attr_curl_cli(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute CurlCli: Convenience attribute, provides curl CLI command prefix, which can be used for signalling handle completion or failure.
You can signal success by adding --data-binary '{"status": "SUCCESS"}' , or signal failure by adding --data-binary '{"status": "FAILURE"}'
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrCurlCli"))
@builtins.property
@jsii.member(jsii_name="attrHeaders")
def attr_headers(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute Headers: HTTP POST Headers used for signalling handle completion or failure.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrHeaders"))
@builtins.property
@jsii.member(jsii_name="attrPowerShellCurlCli")
def attr_power_shell_curl_cli(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute PowerShellCurlCli: Convenience attribute, provides curl CLI command prefix for PowerShell, which can be used for signalling handle completion or failure.
As this cmdlet was introduced in PowerShell 3.0, ensure the version of PowerShell satisfies the constraint. (Show the version via $PSVersionTable.PSVersion.) You can signal success by adding -Body '{"status": "SUCCESS"}' , or signal failure by adding -Body '{"status": "FAILURE"}'
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrPowerShellCurlCli"))
@builtins.property
@jsii.member(jsii_name="attrUrl")
def attr_url(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute URL: HTTP POST URL used for signalling handle completion or failure.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrUrl"))
@builtins.property
@jsii.member(jsii_name="attrWindowsCurlCli")
def attr_windows_curl_cli(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute WindowsCurlCli: Convenience attribute, provides curl CLI command prefix for Windows, which can be used for signalling handle completion or failure.
As Windows does not support curl command, you need to install curl.exe and add it to PATH first. You can signal success by adding --data-binary "{"status": "SUCCESS"}" , or signal failure by adding --data-binary "{"status": "FAILURE"}"
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrWindowsCurlCli"))
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-ros.WaitConditionHandleProps",
jsii_struct_bases=[],
name_mapping={"count": "count", "mode": "mode"},
)
class WaitConditionHandleProps:
def __init__(
self,
*,
count: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
mode: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::ROS::WaitConditionHandle``.
:param count: Property count: There are 3 preconditions that make Count taking effect: 1.Mode is set to Full. 2.Count >= 0. 3.The id of signal is not specified. If so, it will be a self-increasing integer started from 1. For example, the id of the first signal is 1, the id of the second signal is 2, and so on. If Count takes effect, signals with id > Count will be deleted before update. The default value is -1, which means no effect. It is recommended to quote the same value with WaitCondition.Count.
:param mode: Property mode: If set to Increment, all old signals will be deleted before update. In this mode, WaitCondition.Count should reference an incremental value instead of a full value, such as ScalingGroupEnable.ScalingRuleArisExecuteResultNumberOfAddedInstances. If set to Full, no old signal will be deleted unless Count is set. In this mode, WaitCondition.Count should reference a full value, such as the same value with InstanceGroup.MaxAmount. It is recommended to use this mode with Count. Default to Full.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__718f12e3b509382a086836ac2d0e76eb7a26bea3a981dc5f0740e6aa3d408c98)
check_type(argname="argument count", value=count, expected_type=type_hints["count"])
check_type(argname="argument mode", value=mode, expected_type=type_hints["mode"])
self._values: typing.Dict[builtins.str, typing.Any] = {}
if count is not None:
self._values["count"] = count
if mode is not None:
self._values["mode"] = mode
@builtins.property
def count(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property count: There are 3 preconditions that make Count taking effect: 1.Mode is set to Full. 2.Count >= 0. 3.The id of signal is not specified. If so, it will be a self-increasing integer started from 1. For example, the id of the first signal is 1, the id of the second signal is 2, and so on.
If Count takes effect, signals with id > Count will be deleted before update.
The default value is -1, which means no effect.
It is recommended to quote the same value with WaitCondition.Count.
'''
result = self._values.get("count")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def mode(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property mode: If set to Increment, all old signals will be deleted before update.
In this mode, WaitCondition.Count should reference an incremental value instead of a full value, such as ScalingGroupEnable.ScalingRuleArisExecuteResultNumberOfAddedInstances.
If set to Full, no old signal will be deleted unless Count is set. In this mode, WaitCondition.Count should reference a full value, such as the same value with InstanceGroup.MaxAmount. It is recommended to use this mode with Count.
Default to Full.
'''
result = self._values.get("mode")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "WaitConditionHandleProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-ros.WaitConditionProps",
jsii_struct_bases=[],
name_mapping={
"handle": "handle",
"timeout": "timeout",
"count": "count",
"show_progress_event": "showProgressEvent",
},
)
class WaitConditionProps:
def __init__(
self,
*,
handle: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
timeout: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
count: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
show_progress_event: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::ROS::WaitCondition``.
:param handle: Property handle: A reference to the wait condition handle used to signal this wait condition.
:param timeout: Property timeout: The number of seconds to wait for the correct number of signals to arrive.
:param count: Property count: The number of success signals that must be received before the stack creation process continues.
:param show_progress_event: Property showProgressEvent: Whether to generate progress changed event. Default to Disabled.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__5037ad6bb5d615f3e94135743546c782906039cccdbee4a2f035f547617132b2)
check_type(argname="argument handle", value=handle, expected_type=type_hints["handle"])
check_type(argname="argument timeout", value=timeout, expected_type=type_hints["timeout"])
check_type(argname="argument count", value=count, expected_type=type_hints["count"])
check_type(argname="argument show_progress_event", value=show_progress_event, expected_type=type_hints["show_progress_event"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"handle": handle,
"timeout": timeout,
}
if count is not None:
self._values["count"] = count
if show_progress_event is not None:
self._values["show_progress_event"] = show_progress_event
@builtins.property
def handle(self) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property handle: A reference to the wait condition handle used to signal this wait condition.'''
result = self._values.get("handle")
assert result is not None, "Required property 'handle' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def timeout(self) -> typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property timeout: The number of seconds to wait for the correct number of signals to arrive.'''
result = self._values.get("timeout")
assert result is not None, "Required property 'timeout' is missing"
return typing.cast(typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def count(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property count: The number of success signals that must be received before the stack creation process continues.'''
result = self._values.get("count")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def show_progress_event(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property showProgressEvent: Whether to generate progress changed event.
Default to Disabled.
'''
result = self._values.get("show_progress_event")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "WaitConditionProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
__all__ = [
"AutoEnableService",
"AutoEnableServiceProps",
"CustomResource",
"CustomResourceProps",
"ResourceCleaner",
"ResourceCleanerProps",
"RosAutoEnableService",
"RosAutoEnableServiceProps",
"RosCustomResource",
"RosCustomResourceProps",
"RosResourceCleaner",
"RosResourceCleanerProps",
"RosSleep",
"RosSleepProps",
"RosStack",
"RosStackGroup",
"RosStackGroupProps",
"RosStackInstances",
"RosStackInstancesProps",
"RosStackProps",
"RosWaitCondition",
"RosWaitConditionHandle",
"RosWaitConditionHandleProps",
"RosWaitConditionProps",
"Sleep",
"SleepProps",
"Stack",
"StackGroup",
"StackGroupProps",
"StackInstances",
"StackInstancesProps",
"StackProps",
"WaitCondition",
"WaitConditionHandle",
"WaitConditionHandleProps",
"WaitConditionProps",
"datasource",
]
publication.publish()
# Loading modules to ensure their types are registered with the jsii runtime library
from . import datasource
def _typecheckingstub__2d8a8c9fa5b38272cd4d19c32f93b096a09834e4e35cd4e2a08af4596d2dbf65(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[AutoEnableServiceProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__30ea77db475c0f5824b0ba7b97667bc253cd8842e5f24b57a3a63b7e1007ad06(
*,
service_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__2d6f9e5b9f81f49e4166358718dae3297fbabc9b345e8bd677d5b922267e3a29(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[CustomResourceProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__9129cec239b0558cab530c370a4abf7bb62e688591667aa286ba2ebbe348281f(
*,
service_token: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
timeout: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
http_config: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union[RosCustomResource.HttpConfigProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
parameters: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__5417e52208987ab69f690c256a7f3060b239f571e5c38afd6989a89ea685499c(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[ResourceCleanerProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__0331866add02443ec8b42c3f37daeae5168b155c40af69d959ef0fabb58d5178(
*,
action: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
clean_up_algorithm: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
clean_up_retry_count: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
clean_up_timeout: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
disabled_side_effects: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]] = None,
excluded_resources: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union[RosResourceCleaner.ExcludedResourcesProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
failure_option: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
mode: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
resource_filters: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union[RosResourceCleaner.ResourceFiltersProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
resources: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union[RosResourceCleaner.ResourcesProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
resource_type_order: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__0ec33eb47cb3443e767e1061d66564a07c572b34d90608a623c4aa9ae886970b(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[RosAutoEnableServiceProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__8db009b9e7abb19b7a01094ec53a7c186d5886d4dadb880cd0c1bdfa98f09e43(
props: typing.Mapping[builtins.str, typing.Any],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__55def99714dd96ecb578e820aca777d664c6694946d9a0e8c59ddeb54184886a(
value: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__0312d513329bf53c232a3c6a41a826f17c20a291120b6ada9d0bb646e4082f5f(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__585ade1d0095b50f360bf4052cfb0313d1704881d0adab4882332b789868ac88(
*,
service_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__620cef2fc3ea4900166471cf74ad71a22f9b4baa2fffa94cb2f8001f866726c0(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[RosCustomResourceProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__0422aa4f44733abef4ecc28d768a4f25ad20655858c4bdbf0016cb6873ec1cb4(
props: typing.Mapping[builtins.str, typing.Any],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__bb5258d5a90ff55da1defdfd807ffc3e48fcea17fad4efb99d63405c465c4a6a(
value: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__a2cf48b8f1cb2f16d01418e95cb85dde36dd9779c7c90cd222fb0d148ded53eb(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__effc3a3865bb6ce8fa3bfc3d3f17949e49db1b47d23dee9e754a840928a84554(
value: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__d17b070e6a6cfb453efb23e21c31851c238bf55f4187f7186b054d19d732489b(
value: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, RosCustomResource.HttpConfigProperty]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__aeb771102b09e85e65d5eb81ac7790fa026a773629043f39c9ab089e6d77f1c0(
value: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__892ec3d4d0d40972954d0c451c44747254e0053b3384132cb86597c6d0d85384(
*,
content_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
headers: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]] = None,
sign_key: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__5070879f2c1fc643d0f36f6f5ff3e11f87a52010923bf00bf832bf0e97918dd8(
*,
service_token: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
timeout: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
http_config: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union[RosCustomResource.HttpConfigProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
parameters: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__d96a805ed502f7b8059199b15802b8362bb19253a5d94baf0deabceb7c77c4b2(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[RosResourceCleanerProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__e1395137282e73d6460e1fa10d896573265e4d19a0f1b2ddedff02f021273c60(
props: typing.Mapping[builtins.str, typing.Any],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__2cf3ab24cb80dfe22407735000b11f87c807728e20d8ed93cbada35538a1e491(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__a206793e45e66b0a2524b1943ea326e263023693332f0d3c6e273b97f748cdfb(
value: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__87210d639d856beb050ab23de225a3a0e3a3f9039edadbe2574ecb8fa16ce7f9(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__719e08526a02b48f4d105de800f9c40cacc66038706f04aabcd551d76598cac3(
value: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__6c8ac0efdba8befcf8ca579f7e1a5e3900e8514ce64cccb7ddf35acbfe73b23e(
value: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__0ea7cc49ec2b7bbcc4640e52caa0922fbaa8c54d34ef1aeb3724423413559217(
value: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__8b2af159d9065fcc62dbda450b6d14ca229dfbdea874bae9dc4b6c3482e14aac(
value: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, RosResourceCleaner.ExcludedResourcesProperty]]]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__03d5cb81cd2b32389428f53c8f60d347b1f7e36c8572b1c7e86c0cdf03fbebbc(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__7e0b0a662d78bc76b2e9c26bf2b454474989705fe2a8f8c0edb28696290d177b(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__e7053ce7fba251ebad3cc37e0d42c04b6cae903640292f83cf2204e5a60ce22f(
value: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, RosResourceCleaner.ResourceFiltersProperty]]]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__d63659a9d70be1b7da590dd97cebf62781a280f29574d181e2ee5aa5f638ec63(
value: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, RosResourceCleaner.ResourcesProperty]]]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__3d47a9fb58aebc5ca01dcf09014abc64d4c898b697ce3c8b82c177a579a4d05c(
value: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__d57c77041d892a131393c6d140f9fac86b662ef34fe1d4120f96ea20009358b4(
*,
resource_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
region_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
resource_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__77d0b1298d806ff089bb0dc89535c4f113b894402d7ac95130e1248a02b2a491(
*,
effect: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
include_deletion_protection: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
region_ids: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]] = None,
resource_group_ids: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]] = None,
resource_ids: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]] = None,
resource_name_patterns: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]] = None,
resource_type_patterns: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]] = None,
tags: typing.Optional[typing.Sequence[typing.Union[RosResourceCleaner.TagsProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__22540af933791fb382255407e6a76b1346ad347c14e507ad2aaccda0aaca9ed7(
*,
region_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
resource_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
resource_type: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__f42328b4dcb985397b40492afdb002a4024d69e02016f1917f526b3a9eb4c754(
*,
key: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__16a1c77d183d6f3ea6d178565f7ae129faeb5a652449b9bfe96b2bfb1b4ca231(
*,
action: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
clean_up_algorithm: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
clean_up_retry_count: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
clean_up_timeout: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
disabled_side_effects: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]] = None,
excluded_resources: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union[RosResourceCleaner.ExcludedResourcesProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
failure_option: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
mode: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
resource_filters: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union[RosResourceCleaner.ResourceFiltersProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
resources: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union[RosResourceCleaner.ResourcesProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
resource_type_order: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__cca213ccefd05503419352e3c8203f3837b67591c820e476ececc4e769bb6476(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[RosSleepProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__99ceb94c7c7e292b916387b22bcb2364bb64dcb772225ef6c0d6a33f33948965(
props: typing.Mapping[builtins.str, typing.Any],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__0f55764a6db9524e64337a782408ecb0f29fb1e7922663f2730eb4a734247d13(
value: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__eb4645a4573f2a315d3eb532356ad7ce1f5e962e08b847ec3997e1be942ac914(
value: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__a3fa7e5c52a41d3119c4ee5cf678f90486cfc0c9d4dc005bb6ffa8dc76e2e5ac(
value: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__eac5e73c8516d62c8748b8107cdb7d6738b647a3931560ed438e9a3d64b1c15e(
value: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__3816586d47402c821fb2bffc18b8a2602939552e65c8eccc1c6c0d5f64c6e7c2(
value: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__c1f16a266a455c39ce4f1c8d4b6427ea076c50ec10e1aed814d6e5c621300472(
value: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__b7987fe5a26aa92b3a77dd747aa812a03972bb089b73c6026506d9e9db1db76c(
*,
create_duration: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
delete_duration: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
triggers: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]] = None,
update_duration: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
update_rollback_duration: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__6d19ff6c89064ccea6ba2cb6625e2db34c8e6ef891a8dfb67e08c73afc90a0df(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[RosStackProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__8bf88c321c6df8e65332bf8086a50c9fbe14982e83e26b52cdf1472af72d0983(
props: typing.Mapping[builtins.str, typing.Any],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__8de0c5d869b839a65804da2d4c39073ca870f490995ed7feb1feeee98f8880bd(
value: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__8e0df706b75956f27ed59784145e81f437af1c944cc5f8c45df466260d39f8dc(
value: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__c1379f96715c1bfd4c24c8bfc0c8810e0f5a92fcfa2d8670ecd2001db00799f6(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__54a4123241a47f21745e1d240b90dca2f2294e75b11fd437da125168b542cc66(
value: typing.Optional[typing.List[RosStack.TagsProperty]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__262d2db5ca265873dbfe7923e3b1c982ffd8926b3286cb004123cf599714a5f0(
value: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__d44d231eb7362d9ffc3333c5c878ba2dab37f89c48c9186cb9182e74593baedb(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__14140fee33c34a019996763719f29c14d926cac0ef91a1eb11f9b3b963b3a777(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__6bad1f0df2640157d9b0faf6139c58434e0806b1088477ad60fd379f2791ea44(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__5180deb15ec59728c757024bfb35dcfc511be5385427b9a30727f370792b8bbc(
value: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__c7ed03402966de59ed141451f12176129ca206bd0ea5f77d834142110bc9346e(
*,
key: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__bb0dc90a8ce8d2d43dbd7a5844cc38be3a33b4a7107e2faf55263fc630d44f21(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[RosStackGroupProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__c4b5da0bc75c19de3fe264bbc03b2520b8a5448efe937c7d10711337ea79981f(
props: typing.Mapping[builtins.str, typing.Any],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__1050515447762202af2c09eb04a40ab13d8e267e55a9ef1be991ad0feb3b9ff2(
value: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__0ce34e22d6ec551590820ccf22eea6272a7f1b9ce27f8d8aaa296ab00af3567d(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__8611051e3be119ec216a37fbf35a5228de5bc286de51c7271fe487abbb7c7a6d(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__8207e954cd77ba62edb85c8df77aeff3aa7c7869fb2be1c2e35f4d55e3d305e7(
value: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, RosStackGroup.AutoDeploymentProperty]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__86b154bc533c7449b1ef408d95b553d4521660ae3e257b39a98e3fce937b5a1f(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__7c27abc0a7bcc5dc914f919f40c187fca2fb489546a55203828b1dc7333e676a(
value: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__3e844c23d1ac10e69e932739510819da82569725d15abc7f964a30810fb41302(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__6dcb0a5f1b8b88f6ae6379f81a3278ba1efe8379a4d99ea51f4bd57ca2891ccf(
value: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__bd10643fa01f590dc8b24a27a6b7b69accd20d12c3b13fc5aa4ce2750b70cac3(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__a8e297e4252d94c28357e4b7f9f989c25aa7a1a791a48d62c3c22c222605b9d5(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__6a55d7bb5783f685d4e9c7fd3864be21dad07c71bec6fd8ad37501550bdda72f(
value: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__7c321f9bdbbb641847b8650e7fd828035dfa0a3a7a004e21f3bd754efed0b844(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__f4e826aca9d657ebffcfabaca14724524eb3e4b23f6e3379d9b47d8c697bf342(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__2b75222df4d35921b446a1104254a5b69a5ceb2123c19ae9386e6d60742fa8a9(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__80631bc33aec6685ca0f25038bf944cc4666f4a8d0ab9c65b529395cd40c35f1(
*,
enabled: typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable],
retain_stacks_on_account_removal: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__3df7ab21265e5b105388acc3893739cbf524373cc52ca273403b3a08860c4452(
*,
stack_group_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
administration_role_name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
auto_deployment: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union[RosStackGroup.AutoDeploymentProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
description: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
dynamic_template_body: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]] = None,
execution_role_name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
parameters: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]] = None,
permission_model: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
resource_group_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
template_body: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]] = None,
template_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
template_url: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
template_version: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__5f68c2b865bf7d07a9f13bc815982c06caf6a58839aae62e938abc89d1a82ee6(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[RosStackInstancesProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__823b4d30bf039e7be49e34d4c782799ad75402c5ad5b7d26e66904f4bf324947(
props: typing.Mapping[builtins.str, typing.Any],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__5b9c470258dbc5c822be175a2078ab31c315e89c79da2bfcc8dc5e9e8ca0bd24(
value: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__9062084c37863a4bbb13145ff7a47446ac1935dda760f8a7d027122b247b3386(
value: typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__c7df7ada9ae5d0425e9ff1d1a590f8347b14a4a49574ea1efbd1a2f115ef8e91(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__72c98679ce80843eacc28aa591854c97d68a38fdad569c251de8439e3614da13(
value: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__be22f8688c6a3fceda9ca69ed4cb0aaf2d69655e3d84aa071e266b23a47da7fe(
value: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, RosStackInstances.DeploymentTargetsProperty]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__64667045967d918dc5dc25e2a339982474702ee966bbaa7c9b0b417522d5e891(
value: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__837fe7db7399bfcd1328dee9f76c478826c5862d93c4fe6cd8b968c53c54691e(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__a9846a2445e442adc87dccfd1015c9f264b8e64e789a3c004967e7bc3cb7ca4e(
value: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, RosStackInstances.OperationPreferencesProperty]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__98d8f67193a80dbb0dfc64c2f63eaa49d1ec64c18a7a7f731c4cade5f7f8a109(
value: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__dca809881ade9c30f5e50d9a55767d26eb72043d6415524e688198dd3646c0e1(
value: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__5f66bcb5c4d13025aa855cfcc7850cc4e9a6510f894496e2f76fac1b1ca0d410(
value: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__d3080e72abcbb31718c9703a33547e1446d0fb747b78c5b6dc5018d806d03b2b(
*,
rd_folder_ids: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__63eb9bdd315957aa4506db86bb05e1cf7f2be0cd756f55135cb804aba04a7008(
*,
failure_tolerance_count: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
failure_tolerance_percentage: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
max_concurrent_count: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
max_concurrent_percentage: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__296f009dca83480c49620b6f4e244139922fa78be46fa15031fb0a90baa95e28(
*,
region_ids: typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]],
stack_group_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
account_ids: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]] = None,
deployment_targets: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union[RosStackInstances.DeploymentTargetsProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
disable_rollback: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
operation_description: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
operation_preferences: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union[RosStackInstances.OperationPreferencesProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
parameter_overrides: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]] = None,
retain_stacks: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
timeout_in_minutes: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__028a4f01359b4010a644bbfdbbfa9f2642ce8740bd9955d67a9609ff47b0f9a4(
*,
parameters: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]] = None,
resource_group_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
tags: typing.Optional[typing.Sequence[typing.Union[RosStack.TagsProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
template_body: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]] = None,
template_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
template_url: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
template_version: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
timeout_mins: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__7b36122ca77fbfd6a63cd0370ae004bd94a5bf89a8efa46ab44ed7699e9cafce(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[RosWaitConditionProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__ae23af8177df06da8fc6e37ddbe5b4580b3d167248f1b05daa1add78c04d4215(
props: typing.Mapping[builtins.str, typing.Any],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__ce9d87191d13d5c3012c001ab275e2d622e5ac34cca6b7bd602456fdcf1a9e81(
value: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__ba9db45571a2733c343bedcf9e4d7a8e793d5a3ffacfaf8f5d989cb7487add15(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__b4192186a5b66108af6feb061ee83ca94b1b210342d5d74e3eea33ceb673ee02(
value: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__19cb3fb7870573f62c2f62fd460dec7484bdfbd60be69e7ad6c3e7e1e39d1a27(
value: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__410ed0349426ebbe5b7eb842714484ebb433445b59c0b628addd5f7adafe445d(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__297b73ea8e02c335ce7d62f3f8d765ebf8dffebd0ce11c824a225aa2bc03d6c2(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[RosWaitConditionHandleProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__793dbb57bb359ba5d1fcadb4d516fbed1af088d497df1fb34290a3cd9b94d1ad(
props: typing.Mapping[builtins.str, typing.Any],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__8f7f23ed9343e84325d0c91e4c5da6352ed4c0958b2364c068058b12c865864e(
value: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__2faa163202b14589308011331f2c4f577dd1c4de9ec1399a352dbd78a2d2057e(
value: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__4ba3fb86aa4cc3e8d1c11985db22dccbabf45af0f80ffac9b216163fd4ad5ca9(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__50b711299e6e5f3c4d5329e531c4a9967c44994ebadbb75880543df9ae63135c(
*,
count: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
mode: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__930acbaa7f83895d350eb4ea76aa9906c0ec14dd3773c57fedfa39a6279c2c06(
*,
handle: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
timeout: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
count: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
show_progress_event: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__51238a3b7ea5963d718a3ab55e38e4ba13ddabc9f308deb695998763869b5d46(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Optional[typing.Union[SleepProps, typing.Dict[builtins.str, typing.Any]]] = None,
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__9651688a0f3b7c1f4ead2ff79281d8335d6fcfc825a3a4527194465b2da37026(
*,
create_duration: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
delete_duration: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
triggers: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]] = None,
update_duration: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
update_rollback_duration: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__65856122acbc66bc495a54825b5c8fe2ef3735ad8fbc11ac4cd83e9c6fbc9914(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Optional[typing.Union[StackProps, typing.Dict[builtins.str, typing.Any]]] = None,
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__676fbdb4aae9f081068398c3f7469df61bb9d2b2b79d94c8ff303cdb83df3030(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[StackGroupProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__64c436a242f5f9177a74d7b22490581a7108701b2b4a1fce136ead4369168906(
*,
stack_group_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
administration_role_name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
auto_deployment: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union[RosStackGroup.AutoDeploymentProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
description: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
dynamic_template_body: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]] = None,
execution_role_name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
parameters: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]] = None,
permission_model: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
resource_group_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
template_body: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]] = None,
template_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
template_url: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
template_version: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__3ff7c4a8380f7f9fcbfb8f6efdcd916618cb26cfdb74f6c8e9339b7b77e43080(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[StackInstancesProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__f281983fa0910d1544fde2a8251a6582c04dad463d9670e20a4c74520966a8ed(
*,
region_ids: typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]],
stack_group_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
account_ids: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]] = None,
deployment_targets: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union[RosStackInstances.DeploymentTargetsProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
disable_rollback: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
operation_description: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
operation_preferences: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union[RosStackInstances.OperationPreferencesProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
parameter_overrides: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]] = None,
retain_stacks: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
timeout_in_minutes: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__dff5755f904dcbfd7c013e8533057f031d953d3ff444976703bc527f36c292c8(
*,
parameters: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]] = None,
resource_group_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
tags: typing.Optional[typing.Sequence[typing.Union[RosStack.TagsProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
template_body: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]] = None,
template_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
template_url: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
template_version: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
timeout_mins: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__86b0ee6fb63e784d60e37337c08f234a1b27097b0552b79613f67a7536a67bf2(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[WaitConditionProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__731334e5ac400ae777842cac9e1799ca3372f514388bbead4c764e4a146ad326(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Optional[typing.Union[WaitConditionHandleProps, typing.Dict[builtins.str, typing.Any]]] = None,
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__718f12e3b509382a086836ac2d0e76eb7a26bea3a981dc5f0740e6aa3d408c98(
*,
count: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
mode: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__5037ad6bb5d615f3e94135743546c782906039cccdbee4a2f035f547617132b2(
*,
handle: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
timeout: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
count: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
show_progress_event: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass | /ros-cdk-ros-1.0.17.tar.gz/ros-cdk-ros-1.0.17/src/ros_cdk_ros/__init__.py | 0.664976 | 0.208119 | __init__.py | pypi |
import abc
import builtins
import datetime
import enum
import typing
import jsii
import publication
import typing_extensions
from typeguard import check_type
from ._jsii import *
import ros_cdk_core as _ros_cdk_core_7adfd82f
class Application(
_ros_cdk_core_7adfd82f.Resource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-sae.Application",
):
'''A ROS resource type: ``ALIYUN::SAE::Application``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["ApplicationProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
'''Create a new ``ALIYUN::SAE::Application``.
Param scope - scope in which this resource is defined
Param id - scoped id of the resource
Param props - resource properties
:param scope: -
:param id: -
:param props: -
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__f40e4e0dc21b5530d850ac62cc0ec37d92bd5e584281413caabd068c72ee536d)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@builtins.property
@jsii.member(jsii_name="attrAppId")
def attr_app_id(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute AppId: Creating successful application ID.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrAppId"))
@builtins.property
@jsii.member(jsii_name="attrChangeOrderId")
def attr_change_order_id(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute ChangeOrderId: Return to release a single ID, used to query task execution status.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrChangeOrderId"))
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-sae.ApplicationProps",
jsii_struct_bases=[],
name_mapping={
"app_name": "appName",
"cpu": "cpu",
"memory": "memory",
"namespace_id": "namespaceId",
"package_type": "packageType",
"replicas": "replicas",
"app_description": "appDescription",
"command": "command",
"command_args": "commandArgs",
"custom_host_alias": "customHostAlias",
"deploy": "deploy",
"edas_container_version": "edasContainerVersion",
"envs": "envs",
"image_url": "imageUrl",
"jar_start_args": "jarStartArgs",
"jar_start_options": "jarStartOptions",
"jdk": "jdk",
"liveness": "liveness",
"mount_desc": "mountDesc",
"mount_host": "mountHost",
"nas_id": "nasId",
"package_url": "packageUrl",
"package_version": "packageVersion",
"post_start": "postStart",
"pre_stop": "preStop",
"readiness": "readiness",
"security_group_id": "securityGroupId",
"sls_configs": "slsConfigs",
"tags": "tags",
"timezone": "timezone",
"vpc_id": "vpcId",
"v_switch_id": "vSwitchId",
"war_start_options": "warStartOptions",
"web_container": "webContainer",
},
)
class ApplicationProps:
def __init__(
self,
*,
app_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
cpu: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
memory: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
namespace_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
package_type: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
replicas: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
app_description: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
command: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
command_args: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
custom_host_alias: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
deploy: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
edas_container_version: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
envs: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
image_url: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
jar_start_args: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
jar_start_options: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
jdk: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
liveness: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
mount_desc: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
mount_host: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
nas_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
package_url: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
package_version: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
post_start: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
pre_stop: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
readiness: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
security_group_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
sls_configs: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
tags: typing.Optional[typing.Sequence[typing.Union["RosApplication.TagsProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
timezone: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
vpc_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
v_switch_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
war_start_options: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
web_container: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::SAE::Application``.
:param app_name: Property appName: Application Name. Allowed numbers, letters and underlined combinations thereof. We must begin with the letters, the maximum length of 36 characters.
:param cpu: Property cpu: Each instance of the CPU required, in units of milli core, can not be zero. Currently only supports fixed specifications instance type.
:param memory: Property memory: Each instance of the required memory, in units of MB, can not be zero. Currently only supports fixed specifications instance type.
:param namespace_id: Property namespaceId: EDAS namespace corresponding to ID. Canada supports only the name of the scribe lowercase namespace must begin with a letter. Namespace can interface to obtain from DescribeNamespaceList.
:param package_type: Property packageType: Application package type. Support FatJar, War, Image.
:param replicas: Property replicas: The initial number of instances.
:param app_description: Property appDescription: Application description. No more than 1024 characters.
:param command: Property command: Mirroring the start command. The command object in memory executable container must be. For example: sleep. This command will cause the image to set the original startup command failure.
:param command_args: Property commandArgs: Mirroring the start command parameters. Parameters required for the start-command. For example: [ "1d"]
:param custom_host_alias: Property customHostAlias: Custom mapping host vessel. For example: [{ "hostName": "samplehost", "ip": "127.0.0.1"}]
:param deploy: Property deploy: Whether deployed immediately take effect, the default is false.
:param edas_container_version: Property edasContainerVersion: EDAS pandora runtime environment used by the application.
:param envs: Property envs: Container environment variable parameters. For example: [{ "name": "envtmp", "value": "0"}]
:param image_url: Property imageUrl: Mirroring address. Image only type of application can be configured to mirror address.
:param jar_start_args: Property jarStartArgs: Jar package startup application parameters. Apply the default startup command: $ JAVA_HOME / bin / java $ JarStartOptions -jar $ CATALINA_OPTS "$ package_path" $ JarStartArgs
:param jar_start_options: Property jarStartOptions: Jar start the application package option. Apply the default startup command: $ JAVA_HOME / bin / java $ JarStartOptions -jar $ CATALINA_OPTS "$ package_path" $ JarStartArgs
:param jdk: Property jdk: Deployment of JDK version of the package depends on. Mirroring not supported.
:param liveness: Property liveness: Container health check, health check fails container will be killed and recovery. Currently only supports mode command issued in the container. The columns: { "exec": { "command": [ "sleep", "5s"]}, "initialDelaySeconds": 10, "timeoutSeconds": 11}
:param mount_desc: Property mountDesc: Mount Description.
:param mount_host: Property mountHost: nas mount point in the application of vpc.
:param nas_id: Property nasId: Mount the NAS ID, you must be in the same region and cluster. It must be available to create a mount point limit, or switch on its mount point already in the VPC. If you do not fill, and there mountDescs field, the default will automatically purchase a NAS and mount it onto the switch within the VPC.
:param package_url: Property packageUrl: Deployment packages address. Only FatJar War or the type of application can be configured to deploy packet address.
:param package_version: Property packageVersion: The version number of the deployed package, War FatJar type required. Please customize it meaning.
:param post_start: Property postStart: Executing the script, such as after starting the format: { "exec": { "command": "cat", "/ etc / group"}}.
:param pre_stop: Property preStop: Script is executed before stopping the format as: { "exec": { "command": "cat", "/ etc / group"}}.
:param readiness: Property readiness: Application launch status check, health check fails repeatedly container will be killed and restarted. Do not pass health check of the vessel will not have to enter SLB traffic. For example: { "exec": { "command": [ "sleep", "6s"]}, "initialDelaySeconds": 15, "timeoutSeconds": 12}
:param security_group_id: Property securityGroupId: Security group ID.
:param sls_configs: Property slsConfigs: Log collection configuration file.
:param tags: Property tags: Tags to attach to application. Max support 20 tags to add during create application. Each tag with two properties Key and Value, and Key is required.
:param timezone: Property timezone: Application time zone. Default Asia/Shanghai.
:param vpc_id: Property vpcId: EDAS namespace corresponding VPC. In Serverless in a corresponding one of the VPC namespace only, and can not be modified. Serverless first created in the application name space will form a binding relationship. You may correspond to a plurality of namespaces VPC. Do not fill was VpcId namespace binding.
:param v_switch_id: Property vSwitchId: Application examples where the elastic card virtual switch. The switch must be located above the VPC. The same switch with EDAS namespace binding relationship. Do not fill was VSwitchId namespace binding.
:param war_start_options: Property warStartOptions: War Start the application package option. Apply the default startup command: java $ JAVA_OPTS $ CATALINA_OPTS -Options org.apache.catalina.startup.Bootstrap "$ @" start
:param web_container: Property webContainer: Tomcat deployment of the package depends on the version. Mirroring not supported.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__9e0809ad432939d33626184efbc5fc3baf4368e4c612a52467ac68e941027e8f)
check_type(argname="argument app_name", value=app_name, expected_type=type_hints["app_name"])
check_type(argname="argument cpu", value=cpu, expected_type=type_hints["cpu"])
check_type(argname="argument memory", value=memory, expected_type=type_hints["memory"])
check_type(argname="argument namespace_id", value=namespace_id, expected_type=type_hints["namespace_id"])
check_type(argname="argument package_type", value=package_type, expected_type=type_hints["package_type"])
check_type(argname="argument replicas", value=replicas, expected_type=type_hints["replicas"])
check_type(argname="argument app_description", value=app_description, expected_type=type_hints["app_description"])
check_type(argname="argument command", value=command, expected_type=type_hints["command"])
check_type(argname="argument command_args", value=command_args, expected_type=type_hints["command_args"])
check_type(argname="argument custom_host_alias", value=custom_host_alias, expected_type=type_hints["custom_host_alias"])
check_type(argname="argument deploy", value=deploy, expected_type=type_hints["deploy"])
check_type(argname="argument edas_container_version", value=edas_container_version, expected_type=type_hints["edas_container_version"])
check_type(argname="argument envs", value=envs, expected_type=type_hints["envs"])
check_type(argname="argument image_url", value=image_url, expected_type=type_hints["image_url"])
check_type(argname="argument jar_start_args", value=jar_start_args, expected_type=type_hints["jar_start_args"])
check_type(argname="argument jar_start_options", value=jar_start_options, expected_type=type_hints["jar_start_options"])
check_type(argname="argument jdk", value=jdk, expected_type=type_hints["jdk"])
check_type(argname="argument liveness", value=liveness, expected_type=type_hints["liveness"])
check_type(argname="argument mount_desc", value=mount_desc, expected_type=type_hints["mount_desc"])
check_type(argname="argument mount_host", value=mount_host, expected_type=type_hints["mount_host"])
check_type(argname="argument nas_id", value=nas_id, expected_type=type_hints["nas_id"])
check_type(argname="argument package_url", value=package_url, expected_type=type_hints["package_url"])
check_type(argname="argument package_version", value=package_version, expected_type=type_hints["package_version"])
check_type(argname="argument post_start", value=post_start, expected_type=type_hints["post_start"])
check_type(argname="argument pre_stop", value=pre_stop, expected_type=type_hints["pre_stop"])
check_type(argname="argument readiness", value=readiness, expected_type=type_hints["readiness"])
check_type(argname="argument security_group_id", value=security_group_id, expected_type=type_hints["security_group_id"])
check_type(argname="argument sls_configs", value=sls_configs, expected_type=type_hints["sls_configs"])
check_type(argname="argument tags", value=tags, expected_type=type_hints["tags"])
check_type(argname="argument timezone", value=timezone, expected_type=type_hints["timezone"])
check_type(argname="argument vpc_id", value=vpc_id, expected_type=type_hints["vpc_id"])
check_type(argname="argument v_switch_id", value=v_switch_id, expected_type=type_hints["v_switch_id"])
check_type(argname="argument war_start_options", value=war_start_options, expected_type=type_hints["war_start_options"])
check_type(argname="argument web_container", value=web_container, expected_type=type_hints["web_container"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"app_name": app_name,
"cpu": cpu,
"memory": memory,
"namespace_id": namespace_id,
"package_type": package_type,
"replicas": replicas,
}
if app_description is not None:
self._values["app_description"] = app_description
if command is not None:
self._values["command"] = command
if command_args is not None:
self._values["command_args"] = command_args
if custom_host_alias is not None:
self._values["custom_host_alias"] = custom_host_alias
if deploy is not None:
self._values["deploy"] = deploy
if edas_container_version is not None:
self._values["edas_container_version"] = edas_container_version
if envs is not None:
self._values["envs"] = envs
if image_url is not None:
self._values["image_url"] = image_url
if jar_start_args is not None:
self._values["jar_start_args"] = jar_start_args
if jar_start_options is not None:
self._values["jar_start_options"] = jar_start_options
if jdk is not None:
self._values["jdk"] = jdk
if liveness is not None:
self._values["liveness"] = liveness
if mount_desc is not None:
self._values["mount_desc"] = mount_desc
if mount_host is not None:
self._values["mount_host"] = mount_host
if nas_id is not None:
self._values["nas_id"] = nas_id
if package_url is not None:
self._values["package_url"] = package_url
if package_version is not None:
self._values["package_version"] = package_version
if post_start is not None:
self._values["post_start"] = post_start
if pre_stop is not None:
self._values["pre_stop"] = pre_stop
if readiness is not None:
self._values["readiness"] = readiness
if security_group_id is not None:
self._values["security_group_id"] = security_group_id
if sls_configs is not None:
self._values["sls_configs"] = sls_configs
if tags is not None:
self._values["tags"] = tags
if timezone is not None:
self._values["timezone"] = timezone
if vpc_id is not None:
self._values["vpc_id"] = vpc_id
if v_switch_id is not None:
self._values["v_switch_id"] = v_switch_id
if war_start_options is not None:
self._values["war_start_options"] = war_start_options
if web_container is not None:
self._values["web_container"] = web_container
@builtins.property
def app_name(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property appName: Application Name.
Allowed numbers, letters and underlined combinations thereof. We must begin with the letters, the maximum length of 36 characters.
'''
result = self._values.get("app_name")
assert result is not None, "Required property 'app_name' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def cpu(self) -> typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property cpu: Each instance of the CPU required, in units of milli core, can not be zero.
Currently only supports fixed specifications instance type.
'''
result = self._values.get("cpu")
assert result is not None, "Required property 'cpu' is missing"
return typing.cast(typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def memory(self) -> typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property memory: Each instance of the required memory, in units of MB, can not be zero.
Currently only supports fixed specifications instance type.
'''
result = self._values.get("memory")
assert result is not None, "Required property 'memory' is missing"
return typing.cast(typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def namespace_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property namespaceId: EDAS namespace corresponding to ID.
Canada supports only the name of the scribe lowercase namespace must begin with a letter.
Namespace can interface to obtain from DescribeNamespaceList.
'''
result = self._values.get("namespace_id")
assert result is not None, "Required property 'namespace_id' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def package_type(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property packageType: Application package type.
Support FatJar, War, Image.
'''
result = self._values.get("package_type")
assert result is not None, "Required property 'package_type' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def replicas(self) -> typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property replicas: The initial number of instances.'''
result = self._values.get("replicas")
assert result is not None, "Required property 'replicas' is missing"
return typing.cast(typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def app_description(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property appDescription: Application description.
No more than 1024 characters.
'''
result = self._values.get("app_description")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def command(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property command: Mirroring the start command.
The command object in memory executable container must be. For example: sleep. This command will cause the image to set the original startup command failure.
'''
result = self._values.get("command")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def command_args(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property commandArgs: Mirroring the start command parameters.
Parameters required for the start-command. For example: [ "1d"]
'''
result = self._values.get("command_args")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def custom_host_alias(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property customHostAlias: Custom mapping host vessel.
For example: [{ "hostName": "samplehost", "ip": "127.0.0.1"}]
'''
result = self._values.get("custom_host_alias")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def deploy(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property deploy: Whether deployed immediately take effect, the default is false.'''
result = self._values.get("deploy")
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def edas_container_version(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property edasContainerVersion: EDAS pandora runtime environment used by the application.'''
result = self._values.get("edas_container_version")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def envs(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property envs: Container environment variable parameters.
For example: [{ "name": "envtmp", "value": "0"}]
'''
result = self._values.get("envs")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def image_url(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property imageUrl: Mirroring address.
Image only type of application can be configured to mirror address.
'''
result = self._values.get("image_url")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def jar_start_args(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property jarStartArgs: Jar package startup application parameters.
Apply the default startup command: $ JAVA_HOME / bin / java $ JarStartOptions -jar $ CATALINA_OPTS "$ package_path"
$ JarStartArgs
'''
result = self._values.get("jar_start_args")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def jar_start_options(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property jarStartOptions: Jar start the application package option.
Apply the default startup command: $ JAVA_HOME / bin / java $ JarStartOptions -jar $ CATALINA_OPTS "$ package_path"
$ JarStartArgs
'''
result = self._values.get("jar_start_options")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def jdk(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property jdk: Deployment of JDK version of the package depends on.
Mirroring not supported.
'''
result = self._values.get("jdk")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def liveness(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property liveness: Container health check, health check fails container will be killed and recovery.
Currently only supports mode command issued in the container. The columns: { "exec": { "command": [ "sleep", "5s"]}, "initialDelaySeconds": 10, "timeoutSeconds": 11}
'''
result = self._values.get("liveness")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def mount_desc(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property mountDesc: Mount Description.'''
result = self._values.get("mount_desc")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def mount_host(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property mountHost: nas mount point in the application of vpc.'''
result = self._values.get("mount_host")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def nas_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property nasId: Mount the NAS ID, you must be in the same region and cluster.
It must be available to create a mount point limit, or switch on its mount point already in the VPC. If you do not fill, and there mountDescs field, the default will automatically purchase a NAS and mount it onto the switch within the VPC.
'''
result = self._values.get("nas_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def package_url(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property packageUrl: Deployment packages address.
Only FatJar War or the type of application can be configured to deploy packet address.
'''
result = self._values.get("package_url")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def package_version(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property packageVersion: The version number of the deployed package, War FatJar type required.
Please customize it meaning.
'''
result = self._values.get("package_version")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def post_start(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property postStart: Executing the script, such as after starting the format: { "exec": { "command": "cat", "/ etc / group"}}.'''
result = self._values.get("post_start")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def pre_stop(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property preStop: Script is executed before stopping the format as: { "exec": { "command": "cat", "/ etc / group"}}.'''
result = self._values.get("pre_stop")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def readiness(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property readiness: Application launch status check, health check fails repeatedly container will be killed and restarted.
Do not pass health check of the vessel will not have to enter SLB traffic. For example: { "exec": { "command": [ "sleep", "6s"]}, "initialDelaySeconds": 15, "timeoutSeconds": 12}
'''
result = self._values.get("readiness")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def security_group_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property securityGroupId: Security group ID.'''
result = self._values.get("security_group_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def sls_configs(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property slsConfigs: Log collection configuration file.'''
result = self._values.get("sls_configs")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def tags(self) -> typing.Optional[typing.List["RosApplication.TagsProperty"]]:
'''Property tags: Tags to attach to application.
Max support 20 tags to add during create application. Each tag with two properties Key and Value, and Key is required.
'''
result = self._values.get("tags")
return typing.cast(typing.Optional[typing.List["RosApplication.TagsProperty"]], result)
@builtins.property
def timezone(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property timezone: Application time zone.
Default Asia/Shanghai.
'''
result = self._values.get("timezone")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def vpc_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property vpcId: EDAS namespace corresponding VPC.
In Serverless in a corresponding one of the VPC namespace only, and can not be modified. Serverless first created in the application name space will form a binding relationship. You may correspond to a plurality of namespaces VPC. Do not fill was VpcId namespace binding.
'''
result = self._values.get("vpc_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def v_switch_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property vSwitchId: Application examples where the elastic card virtual switch.
The switch must be located above the VPC. The same switch with EDAS namespace binding relationship. Do not fill was VSwitchId namespace binding.
'''
result = self._values.get("v_switch_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def war_start_options(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property warStartOptions: War Start the application package option.
Apply the default startup command: java $ JAVA_OPTS $ CATALINA_OPTS -Options org.apache.catalina.startup.Bootstrap "$ @" start
'''
result = self._values.get("war_start_options")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def web_container(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property webContainer: Tomcat deployment of the package depends on the version.
Mirroring not supported.
'''
result = self._values.get("web_container")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "ApplicationProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class Namespace(
_ros_cdk_core_7adfd82f.Resource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-sae.Namespace",
):
'''A ROS resource type: ``ALIYUN::SAE::Namespace``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["NamespaceProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
'''Create a new ``ALIYUN::SAE::Namespace``.
Param scope - scope in which this resource is defined
Param id - scoped id of the resource
Param props - resource properties
:param scope: -
:param id: -
:param props: -
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__f3f5a3b3a5bb50b41c8347823790f2a6e0c342121b76c178ab306a6124c6ed0d)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@builtins.property
@jsii.member(jsii_name="attrNamespaceId")
def attr_namespace_id(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute NamespaceId: Namespace ID.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrNamespaceId"))
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-sae.NamespaceProps",
jsii_struct_bases=[],
name_mapping={
"namespace_id": "namespaceId",
"namespace_name": "namespaceName",
"namespace_description": "namespaceDescription",
},
)
class NamespaceProps:
def __init__(
self,
*,
namespace_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
namespace_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
namespace_description: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::SAE::Namespace``.
:param namespace_id: Property namespaceId: Namespace ID. Format: "regionId:logicalId" or "logicalId"
:param namespace_name: Property namespaceName: Namespace name.
:param namespace_description: Property namespaceDescription: Namespace description.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__3b485e9afeb6d7962b252f0119e24ac9d51e6da5f0f3c36903b5cc97feb5113d)
check_type(argname="argument namespace_id", value=namespace_id, expected_type=type_hints["namespace_id"])
check_type(argname="argument namespace_name", value=namespace_name, expected_type=type_hints["namespace_name"])
check_type(argname="argument namespace_description", value=namespace_description, expected_type=type_hints["namespace_description"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"namespace_id": namespace_id,
"namespace_name": namespace_name,
}
if namespace_description is not None:
self._values["namespace_description"] = namespace_description
@builtins.property
def namespace_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property namespaceId: Namespace ID.
Format: "regionId:logicalId" or "logicalId"
'''
result = self._values.get("namespace_id")
assert result is not None, "Required property 'namespace_id' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def namespace_name(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property namespaceName: Namespace name.'''
result = self._values.get("namespace_name")
assert result is not None, "Required property 'namespace_name' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def namespace_description(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property namespaceDescription: Namespace description.'''
result = self._values.get("namespace_description")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "NamespaceProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class RosApplication(
_ros_cdk_core_7adfd82f.RosResource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-sae.RosApplication",
):
'''A ROS template type: ``ALIYUN::SAE::Application``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["RosApplicationProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
'''Create a new ``ALIYUN::SAE::Application``.
:param scope: - scope in which this resource is defined.
:param id: - scoped id of the resource.
:param props: - resource properties.
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__0c1ab3203db4f9a1da714c700215a6c337b7f1ad1132fd0ca6890604cd6bf929)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@jsii.member(jsii_name="renderProperties")
def _render_properties(
self,
props: typing.Mapping[builtins.str, typing.Any],
) -> typing.Mapping[builtins.str, typing.Any]:
'''
:param props: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__a922c8161e8f9e49f5d63e2ea3fe9a698c4aa80ad6ac78974a209b4befb2c66d)
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))
@jsii.python.classproperty
@jsii.member(jsii_name="ROS_RESOURCE_TYPE_NAME")
def ROS_RESOURCE_TYPE_NAME(cls) -> builtins.str:
'''The resource type name for this resource class.'''
return typing.cast(builtins.str, jsii.sget(cls, "ROS_RESOURCE_TYPE_NAME"))
@builtins.property
@jsii.member(jsii_name="attrAppId")
def attr_app_id(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: AppId: Creating successful application ID.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrAppId"))
@builtins.property
@jsii.member(jsii_name="attrChangeOrderId")
def attr_change_order_id(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: ChangeOrderId: Return to release a single ID, used to query task execution status.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrChangeOrderId"))
@builtins.property
@jsii.member(jsii_name="rosProperties")
def _ros_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "rosProperties"))
@builtins.property
@jsii.member(jsii_name="appName")
def app_name(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: appName: Application Name. Allowed numbers, letters and underlined combinations thereof. We must begin with the letters, the maximum length of 36 characters.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "appName"))
@app_name.setter
def app_name(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__b3d86995c21c86a4debd788a70ab20c9ff77940b1057cffbc078bd675f9dffc0)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "appName", value)
@builtins.property
@jsii.member(jsii_name="cpu")
def cpu(self) -> typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: cpu: Each instance of the CPU required, in units of milli core, can not be zero. Currently only supports fixed specifications instance type.
'''
return typing.cast(typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "cpu"))
@cpu.setter
def cpu(
self,
value: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__9afce2aab31020fd3125cb0cdff507b235b953c0a4bdec465ef92c5b2664d8e0)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "cpu", value)
@builtins.property
@jsii.member(jsii_name="enableResourcePropertyConstraint")
def enable_resource_property_constraint(self) -> builtins.bool:
return typing.cast(builtins.bool, jsii.get(self, "enableResourcePropertyConstraint"))
@enable_resource_property_constraint.setter
def enable_resource_property_constraint(self, value: builtins.bool) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__b971010065f6dccc0c659884efcdb0bdf98bd84080efaa6757d1a9442fe06107)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "enableResourcePropertyConstraint", value)
@builtins.property
@jsii.member(jsii_name="memory")
def memory(self) -> typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: memory: Each instance of the required memory, in units of MB, can not be zero. Currently only supports fixed specifications instance type.
'''
return typing.cast(typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "memory"))
@memory.setter
def memory(
self,
value: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__274f287b31834db9d901486785f88fea8bf061446a631a8704dcec2d515be9e8)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "memory", value)
@builtins.property
@jsii.member(jsii_name="namespaceId")
def namespace_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
namespaceId: EDAS namespace corresponding to ID. Canada supports only the name of the scribe lowercase namespace must begin with a letter.
Namespace can interface to obtain from DescribeNamespaceList.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "namespaceId"))
@namespace_id.setter
def namespace_id(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__d90690996fe24527ef0cc5e3d17bec3ea30242370a4877edabede7fbeb8d6216)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "namespaceId", value)
@builtins.property
@jsii.member(jsii_name="packageType")
def package_type(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: packageType: Application package type. Support FatJar, War, Image.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "packageType"))
@package_type.setter
def package_type(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__a4d49c765eb959bf619695505932285ece77e895292471016264d3ecbfed81be)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "packageType", value)
@builtins.property
@jsii.member(jsii_name="replicas")
def replicas(self) -> typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: replicas: The initial number of instances.
'''
return typing.cast(typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "replicas"))
@replicas.setter
def replicas(
self,
value: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__0b5a879d6eed27264cc1173cef1c78008345198d048be53c18aab4f07b513a14)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "replicas", value)
@builtins.property
@jsii.member(jsii_name="appDescription")
def app_description(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: appDescription: Application description. No more than 1024 characters.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "appDescription"))
@app_description.setter
def app_description(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__44b73e6612f1a6319f73a995f8bffb83f1292f1b18c622bd85b0038448d726a1)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "appDescription", value)
@builtins.property
@jsii.member(jsii_name="command")
def command(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: command: Mirroring the start command. The command object in memory executable container must be. For example: sleep. This command will cause the image to set the original startup command failure.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "command"))
@command.setter
def command(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__8b8e1b11b60d6cc7af8a85cfef24dc3d3b27f375961b4737363217d017fa7225)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "command", value)
@builtins.property
@jsii.member(jsii_name="commandArgs")
def command_args(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: commandArgs: Mirroring the start command parameters. Parameters required for the start-command. For example: [ "1d"]
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "commandArgs"))
@command_args.setter
def command_args(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__fab9baebb3937b437ab5c1b1b8a764c0b58296ff1fdf1162be8e957bab66e5d8)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "commandArgs", value)
@builtins.property
@jsii.member(jsii_name="customHostAlias")
def custom_host_alias(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: customHostAlias: Custom mapping host vessel. For example: [{ "hostName": "samplehost", "ip": "127.0.0.1"}]
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "customHostAlias"))
@custom_host_alias.setter
def custom_host_alias(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__69e502b7f583c59139da6fefa7fd3c4e4edcc34a0693d69164d3f9097b277e17)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "customHostAlias", value)
@builtins.property
@jsii.member(jsii_name="deploy")
def deploy(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: deploy: Whether deployed immediately take effect, the default is false.
'''
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "deploy"))
@deploy.setter
def deploy(
self,
value: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__62a56b828b0775c64b0f6205cee85421e514d707779c40ef901f72f3d872e7b8)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "deploy", value)
@builtins.property
@jsii.member(jsii_name="edasContainerVersion")
def edas_container_version(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: edasContainerVersion: EDAS pandora runtime environment used by the application.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "edasContainerVersion"))
@edas_container_version.setter
def edas_container_version(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__26ff260790e5e70b09f4a667e34338ab6f9342d45a018a3f4164c386e93d2b5b)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "edasContainerVersion", value)
@builtins.property
@jsii.member(jsii_name="envs")
def envs(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: envs: Container environment variable parameters. For example: [{ "name": "envtmp", "value": "0"}]
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "envs"))
@envs.setter
def envs(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__9829cc7d852a42250c2224cfc57ad1eb6ab6922065482e8945df14694a0282a8)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "envs", value)
@builtins.property
@jsii.member(jsii_name="imageUrl")
def image_url(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: imageUrl: Mirroring address. Image only type of application can be configured to mirror address.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "imageUrl"))
@image_url.setter
def image_url(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__4331d88d7f21128d9cf6abc3223a97fa1ada83796ff36125dfbc693314b49f88)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "imageUrl", value)
@builtins.property
@jsii.member(jsii_name="jarStartArgs")
def jar_start_args(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
jarStartArgs: Jar package startup application parameters. Apply the default startup command: $ JAVA_HOME / bin / java $ JarStartOptions -jar $ CATALINA_OPTS "$ package_path"
$ JarStartArgs
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "jarStartArgs"))
@jar_start_args.setter
def jar_start_args(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__ca61b554fb34e2e904e8d1ae9f2d261d9d93a916fce703176cb272d1e40edb4b)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "jarStartArgs", value)
@builtins.property
@jsii.member(jsii_name="jarStartOptions")
def jar_start_options(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
jarStartOptions: Jar start the application package option. Apply the default startup command: $ JAVA_HOME / bin / java $ JarStartOptions -jar $ CATALINA_OPTS "$ package_path"
$ JarStartArgs
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "jarStartOptions"))
@jar_start_options.setter
def jar_start_options(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__69856ed5fe95b9e615b6a9c413b7061af1bce763a24ff55d35e907d1a91f3d89)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "jarStartOptions", value)
@builtins.property
@jsii.member(jsii_name="jdk")
def jdk(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: jdk: Deployment of JDK version of the package depends on. Mirroring not supported.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "jdk"))
@jdk.setter
def jdk(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__07f3d362b7becba32d414f1cf3c251d8953afdd1698a6ae4eb50ff3bfba66b1b)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "jdk", value)
@builtins.property
@jsii.member(jsii_name="liveness")
def liveness(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: liveness: Container health check, health check fails container will be killed and recovery. Currently only supports mode command issued in the container. The columns: { "exec": { "command": [ "sleep", "5s"]}, "initialDelaySeconds": 10, "timeoutSeconds": 11}
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "liveness"))
@liveness.setter
def liveness(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__183d37776b468b778ce55cf09edebe71e639b56fc711fc9e89a1870b63f3c783)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "liveness", value)
@builtins.property
@jsii.member(jsii_name="mountDesc")
def mount_desc(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: mountDesc: Mount Description
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "mountDesc"))
@mount_desc.setter
def mount_desc(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__494b0fdbe0e3a07f261ef76829a1081e86225f96f622ccf1b796724d4720a42b)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "mountDesc", value)
@builtins.property
@jsii.member(jsii_name="mountHost")
def mount_host(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: mountHost: nas mount point in the application of vpc.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "mountHost"))
@mount_host.setter
def mount_host(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__4258555e4d3c8274e21366579b9af5f2eb31ecdcd1a8c036a48f0aa25fd8ce86)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "mountHost", value)
@builtins.property
@jsii.member(jsii_name="nasId")
def nas_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: nasId: Mount the NAS ID, you must be in the same region and cluster. It must be available to create a mount point limit, or switch on its mount point already in the VPC. If you do not fill, and there mountDescs field, the default will automatically purchase a NAS and mount it onto the switch within the VPC.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "nasId"))
@nas_id.setter
def nas_id(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__e1c94c35d79244abf1289c00f0f892cae5b6a984884304a1067250ad2de01c74)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "nasId", value)
@builtins.property
@jsii.member(jsii_name="packageUrl")
def package_url(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: packageUrl: Deployment packages address. Only FatJar War or the type of application can be configured to deploy packet address.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "packageUrl"))
@package_url.setter
def package_url(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__78b4538b42f95387212d94c9eed3d073f6254005b3813d96df5ff2e33fc0896a)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "packageUrl", value)
@builtins.property
@jsii.member(jsii_name="packageVersion")
def package_version(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: packageVersion: The version number of the deployed package, War FatJar type required. Please customize it meaning.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "packageVersion"))
@package_version.setter
def package_version(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__f5faf2cd874e6003daab00c1012b214add97a867395d90d160b7fa5fddb19498)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "packageVersion", value)
@builtins.property
@jsii.member(jsii_name="postStart")
def post_start(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: postStart: Executing the script, such as after starting the format: { "exec": { "command": "cat", "/ etc / group"}}
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "postStart"))
@post_start.setter
def post_start(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__45b49596d8ec100f2b41594fa583ec9314058196b1948be7ec5ed8318565799b)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "postStart", value)
@builtins.property
@jsii.member(jsii_name="preStop")
def pre_stop(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: preStop: Script is executed before stopping the format as: { "exec": { "command": "cat", "/ etc / group"}}
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "preStop"))
@pre_stop.setter
def pre_stop(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__cc9620a59954baf6fc324c7bf059d32303aa5e281fcfbac9426df0da86701564)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "preStop", value)
@builtins.property
@jsii.member(jsii_name="readiness")
def readiness(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: readiness: Application launch status check, health check fails repeatedly container will be killed and restarted. Do not pass health check of the vessel will not have to enter SLB traffic. For example: { "exec": { "command": [ "sleep", "6s"]}, "initialDelaySeconds": 15, "timeoutSeconds": 12}
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "readiness"))
@readiness.setter
def readiness(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__287eea9772792ae58a8e2a137164b8b244ac6bff880bafb14c8d34a5a4f8a818)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "readiness", value)
@builtins.property
@jsii.member(jsii_name="securityGroupId")
def security_group_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: securityGroupId: Security group ID.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "securityGroupId"))
@security_group_id.setter
def security_group_id(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__af32b8eea2efa3cfa4daba653a2801c5c8ac4a9bec4912c342c2919a3dc67778)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "securityGroupId", value)
@builtins.property
@jsii.member(jsii_name="slsConfigs")
def sls_configs(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: slsConfigs: Log collection configuration file
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "slsConfigs"))
@sls_configs.setter
def sls_configs(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__547dca69a5f43e2a98f326603afd6517f5fc6b40c369b012b2ce73786332afd2)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "slsConfigs", value)
@builtins.property
@jsii.member(jsii_name="tags")
def tags(self) -> typing.Optional[typing.List["RosApplication.TagsProperty"]]:
'''
:Property: tags: Tags to attach to application. Max support 20 tags to add during create application. Each tag with two properties Key and Value, and Key is required.
'''
return typing.cast(typing.Optional[typing.List["RosApplication.TagsProperty"]], jsii.get(self, "tags"))
@tags.setter
def tags(
self,
value: typing.Optional[typing.List["RosApplication.TagsProperty"]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__441091f3eb212761c411129f18585fc21940b52552609093eeaf031ee33ec42b)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "tags", value)
@builtins.property
@jsii.member(jsii_name="timezone")
def timezone(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: timezone: Application time zone. Default Asia/Shanghai.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "timezone"))
@timezone.setter
def timezone(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__bd51df4a485ca02763e035d9ff22a252dce4e3eef02bf1b218f8c06148846b57)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "timezone", value)
@builtins.property
@jsii.member(jsii_name="vpcId")
def vpc_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: vpcId: EDAS namespace corresponding VPC. In Serverless in a corresponding one of the VPC namespace only, and can not be modified. Serverless first created in the application name space will form a binding relationship. You may correspond to a plurality of namespaces VPC. Do not fill was VpcId namespace binding.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "vpcId"))
@vpc_id.setter
def vpc_id(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__c7e0d8213ad19f8767dfb51bf368df178dd50ebf50c25d0583e5971d5e4e3d1e)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "vpcId", value)
@builtins.property
@jsii.member(jsii_name="vSwitchId")
def v_switch_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: vSwitchId: Application examples where the elastic card virtual switch. The switch must be located above the VPC. The same switch with EDAS namespace binding relationship. Do not fill was VSwitchId namespace binding.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "vSwitchId"))
@v_switch_id.setter
def v_switch_id(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__40b0affc3a4ba9751a84d57fd38c49c16985270cabf93b655fee98c18b0fbe55)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "vSwitchId", value)
@builtins.property
@jsii.member(jsii_name="warStartOptions")
def war_start_options(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:: " start
:Property: warStartOptions: War Start the application package option. Apply the default startup command: java $ JAVA_OPTS $ CATALINA_OPTS -Options org.apache.catalina.startup.Bootstrap "$
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "warStartOptions"))
@war_start_options.setter
def war_start_options(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__2e4d87811349da12553158b6936d1f01163c17d41bf7cf650d402071f84251ae)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "warStartOptions", value)
@builtins.property
@jsii.member(jsii_name="webContainer")
def web_container(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: webContainer: Tomcat deployment of the package depends on the version. Mirroring not supported.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "webContainer"))
@web_container.setter
def web_container(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__431185569ef7168590bf23fc2ef060b720247d494123b4f17ec46951c093a3e6)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "webContainer", value)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-sae.RosApplication.TagsProperty",
jsii_struct_bases=[],
name_mapping={"key": "key", "value": "value"},
)
class TagsProperty:
def __init__(
self,
*,
key: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''
:param key:
:param value:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__e69f60863b35c099eb075f4bc11f90e1940104113f5c268720a2d2fb1ccd7a76)
check_type(argname="argument key", value=key, expected_type=type_hints["key"])
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"key": key,
}
if value is not None:
self._values["value"] = value
@builtins.property
def key(self) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: key: undefined
'''
result = self._values.get("key")
assert result is not None, "Required property 'key' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def value(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: value: undefined
'''
result = self._values.get("value")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "TagsProperty(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-sae.RosApplicationProps",
jsii_struct_bases=[],
name_mapping={
"app_name": "appName",
"cpu": "cpu",
"memory": "memory",
"namespace_id": "namespaceId",
"package_type": "packageType",
"replicas": "replicas",
"app_description": "appDescription",
"command": "command",
"command_args": "commandArgs",
"custom_host_alias": "customHostAlias",
"deploy": "deploy",
"edas_container_version": "edasContainerVersion",
"envs": "envs",
"image_url": "imageUrl",
"jar_start_args": "jarStartArgs",
"jar_start_options": "jarStartOptions",
"jdk": "jdk",
"liveness": "liveness",
"mount_desc": "mountDesc",
"mount_host": "mountHost",
"nas_id": "nasId",
"package_url": "packageUrl",
"package_version": "packageVersion",
"post_start": "postStart",
"pre_stop": "preStop",
"readiness": "readiness",
"security_group_id": "securityGroupId",
"sls_configs": "slsConfigs",
"tags": "tags",
"timezone": "timezone",
"vpc_id": "vpcId",
"v_switch_id": "vSwitchId",
"war_start_options": "warStartOptions",
"web_container": "webContainer",
},
)
class RosApplicationProps:
def __init__(
self,
*,
app_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
cpu: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
memory: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
namespace_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
package_type: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
replicas: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
app_description: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
command: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
command_args: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
custom_host_alias: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
deploy: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
edas_container_version: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
envs: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
image_url: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
jar_start_args: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
jar_start_options: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
jdk: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
liveness: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
mount_desc: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
mount_host: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
nas_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
package_url: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
package_version: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
post_start: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
pre_stop: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
readiness: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
security_group_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
sls_configs: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
tags: typing.Optional[typing.Sequence[typing.Union[RosApplication.TagsProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
timezone: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
vpc_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
v_switch_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
war_start_options: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
web_container: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::SAE::Application``.
:param app_name:
:param cpu:
:param memory:
:param namespace_id:
:param package_type:
:param replicas:
:param app_description:
:param command:
:param command_args:
:param custom_host_alias:
:param deploy:
:param edas_container_version:
:param envs:
:param image_url:
:param jar_start_args:
:param jar_start_options:
:param jdk:
:param liveness:
:param mount_desc:
:param mount_host:
:param nas_id:
:param package_url:
:param package_version:
:param post_start:
:param pre_stop:
:param readiness:
:param security_group_id:
:param sls_configs:
:param tags:
:param timezone:
:param vpc_id:
:param v_switch_id:
:param war_start_options:
:param web_container:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__b1cf0573cab520f93bd965580156a106306a6abd8a95a6252af4b3b133ed5644)
check_type(argname="argument app_name", value=app_name, expected_type=type_hints["app_name"])
check_type(argname="argument cpu", value=cpu, expected_type=type_hints["cpu"])
check_type(argname="argument memory", value=memory, expected_type=type_hints["memory"])
check_type(argname="argument namespace_id", value=namespace_id, expected_type=type_hints["namespace_id"])
check_type(argname="argument package_type", value=package_type, expected_type=type_hints["package_type"])
check_type(argname="argument replicas", value=replicas, expected_type=type_hints["replicas"])
check_type(argname="argument app_description", value=app_description, expected_type=type_hints["app_description"])
check_type(argname="argument command", value=command, expected_type=type_hints["command"])
check_type(argname="argument command_args", value=command_args, expected_type=type_hints["command_args"])
check_type(argname="argument custom_host_alias", value=custom_host_alias, expected_type=type_hints["custom_host_alias"])
check_type(argname="argument deploy", value=deploy, expected_type=type_hints["deploy"])
check_type(argname="argument edas_container_version", value=edas_container_version, expected_type=type_hints["edas_container_version"])
check_type(argname="argument envs", value=envs, expected_type=type_hints["envs"])
check_type(argname="argument image_url", value=image_url, expected_type=type_hints["image_url"])
check_type(argname="argument jar_start_args", value=jar_start_args, expected_type=type_hints["jar_start_args"])
check_type(argname="argument jar_start_options", value=jar_start_options, expected_type=type_hints["jar_start_options"])
check_type(argname="argument jdk", value=jdk, expected_type=type_hints["jdk"])
check_type(argname="argument liveness", value=liveness, expected_type=type_hints["liveness"])
check_type(argname="argument mount_desc", value=mount_desc, expected_type=type_hints["mount_desc"])
check_type(argname="argument mount_host", value=mount_host, expected_type=type_hints["mount_host"])
check_type(argname="argument nas_id", value=nas_id, expected_type=type_hints["nas_id"])
check_type(argname="argument package_url", value=package_url, expected_type=type_hints["package_url"])
check_type(argname="argument package_version", value=package_version, expected_type=type_hints["package_version"])
check_type(argname="argument post_start", value=post_start, expected_type=type_hints["post_start"])
check_type(argname="argument pre_stop", value=pre_stop, expected_type=type_hints["pre_stop"])
check_type(argname="argument readiness", value=readiness, expected_type=type_hints["readiness"])
check_type(argname="argument security_group_id", value=security_group_id, expected_type=type_hints["security_group_id"])
check_type(argname="argument sls_configs", value=sls_configs, expected_type=type_hints["sls_configs"])
check_type(argname="argument tags", value=tags, expected_type=type_hints["tags"])
check_type(argname="argument timezone", value=timezone, expected_type=type_hints["timezone"])
check_type(argname="argument vpc_id", value=vpc_id, expected_type=type_hints["vpc_id"])
check_type(argname="argument v_switch_id", value=v_switch_id, expected_type=type_hints["v_switch_id"])
check_type(argname="argument war_start_options", value=war_start_options, expected_type=type_hints["war_start_options"])
check_type(argname="argument web_container", value=web_container, expected_type=type_hints["web_container"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"app_name": app_name,
"cpu": cpu,
"memory": memory,
"namespace_id": namespace_id,
"package_type": package_type,
"replicas": replicas,
}
if app_description is not None:
self._values["app_description"] = app_description
if command is not None:
self._values["command"] = command
if command_args is not None:
self._values["command_args"] = command_args
if custom_host_alias is not None:
self._values["custom_host_alias"] = custom_host_alias
if deploy is not None:
self._values["deploy"] = deploy
if edas_container_version is not None:
self._values["edas_container_version"] = edas_container_version
if envs is not None:
self._values["envs"] = envs
if image_url is not None:
self._values["image_url"] = image_url
if jar_start_args is not None:
self._values["jar_start_args"] = jar_start_args
if jar_start_options is not None:
self._values["jar_start_options"] = jar_start_options
if jdk is not None:
self._values["jdk"] = jdk
if liveness is not None:
self._values["liveness"] = liveness
if mount_desc is not None:
self._values["mount_desc"] = mount_desc
if mount_host is not None:
self._values["mount_host"] = mount_host
if nas_id is not None:
self._values["nas_id"] = nas_id
if package_url is not None:
self._values["package_url"] = package_url
if package_version is not None:
self._values["package_version"] = package_version
if post_start is not None:
self._values["post_start"] = post_start
if pre_stop is not None:
self._values["pre_stop"] = pre_stop
if readiness is not None:
self._values["readiness"] = readiness
if security_group_id is not None:
self._values["security_group_id"] = security_group_id
if sls_configs is not None:
self._values["sls_configs"] = sls_configs
if tags is not None:
self._values["tags"] = tags
if timezone is not None:
self._values["timezone"] = timezone
if vpc_id is not None:
self._values["vpc_id"] = vpc_id
if v_switch_id is not None:
self._values["v_switch_id"] = v_switch_id
if war_start_options is not None:
self._values["war_start_options"] = war_start_options
if web_container is not None:
self._values["web_container"] = web_container
@builtins.property
def app_name(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: appName: Application Name. Allowed numbers, letters and underlined combinations thereof. We must begin with the letters, the maximum length of 36 characters.
'''
result = self._values.get("app_name")
assert result is not None, "Required property 'app_name' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def cpu(self) -> typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: cpu: Each instance of the CPU required, in units of milli core, can not be zero. Currently only supports fixed specifications instance type.
'''
result = self._values.get("cpu")
assert result is not None, "Required property 'cpu' is missing"
return typing.cast(typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def memory(self) -> typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: memory: Each instance of the required memory, in units of MB, can not be zero. Currently only supports fixed specifications instance type.
'''
result = self._values.get("memory")
assert result is not None, "Required property 'memory' is missing"
return typing.cast(typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def namespace_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
namespaceId: EDAS namespace corresponding to ID. Canada supports only the name of the scribe lowercase namespace must begin with a letter.
Namespace can interface to obtain from DescribeNamespaceList.
'''
result = self._values.get("namespace_id")
assert result is not None, "Required property 'namespace_id' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def package_type(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: packageType: Application package type. Support FatJar, War, Image.
'''
result = self._values.get("package_type")
assert result is not None, "Required property 'package_type' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def replicas(self) -> typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: replicas: The initial number of instances.
'''
result = self._values.get("replicas")
assert result is not None, "Required property 'replicas' is missing"
return typing.cast(typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def app_description(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: appDescription: Application description. No more than 1024 characters.
'''
result = self._values.get("app_description")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def command(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: command: Mirroring the start command. The command object in memory executable container must be. For example: sleep. This command will cause the image to set the original startup command failure.
'''
result = self._values.get("command")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def command_args(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: commandArgs: Mirroring the start command parameters. Parameters required for the start-command. For example: [ "1d"]
'''
result = self._values.get("command_args")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def custom_host_alias(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: customHostAlias: Custom mapping host vessel. For example: [{ "hostName": "samplehost", "ip": "127.0.0.1"}]
'''
result = self._values.get("custom_host_alias")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def deploy(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: deploy: Whether deployed immediately take effect, the default is false.
'''
result = self._values.get("deploy")
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def edas_container_version(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: edasContainerVersion: EDAS pandora runtime environment used by the application.
'''
result = self._values.get("edas_container_version")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def envs(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: envs: Container environment variable parameters. For example: [{ "name": "envtmp", "value": "0"}]
'''
result = self._values.get("envs")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def image_url(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: imageUrl: Mirroring address. Image only type of application can be configured to mirror address.
'''
result = self._values.get("image_url")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def jar_start_args(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
jarStartArgs: Jar package startup application parameters. Apply the default startup command: $ JAVA_HOME / bin / java $ JarStartOptions -jar $ CATALINA_OPTS "$ package_path"
$ JarStartArgs
'''
result = self._values.get("jar_start_args")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def jar_start_options(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
jarStartOptions: Jar start the application package option. Apply the default startup command: $ JAVA_HOME / bin / java $ JarStartOptions -jar $ CATALINA_OPTS "$ package_path"
$ JarStartArgs
'''
result = self._values.get("jar_start_options")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def jdk(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: jdk: Deployment of JDK version of the package depends on. Mirroring not supported.
'''
result = self._values.get("jdk")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def liveness(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: liveness: Container health check, health check fails container will be killed and recovery. Currently only supports mode command issued in the container. The columns: { "exec": { "command": [ "sleep", "5s"]}, "initialDelaySeconds": 10, "timeoutSeconds": 11}
'''
result = self._values.get("liveness")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def mount_desc(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: mountDesc: Mount Description
'''
result = self._values.get("mount_desc")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def mount_host(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: mountHost: nas mount point in the application of vpc.
'''
result = self._values.get("mount_host")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def nas_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: nasId: Mount the NAS ID, you must be in the same region and cluster. It must be available to create a mount point limit, or switch on its mount point already in the VPC. If you do not fill, and there mountDescs field, the default will automatically purchase a NAS and mount it onto the switch within the VPC.
'''
result = self._values.get("nas_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def package_url(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: packageUrl: Deployment packages address. Only FatJar War or the type of application can be configured to deploy packet address.
'''
result = self._values.get("package_url")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def package_version(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: packageVersion: The version number of the deployed package, War FatJar type required. Please customize it meaning.
'''
result = self._values.get("package_version")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def post_start(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: postStart: Executing the script, such as after starting the format: { "exec": { "command": "cat", "/ etc / group"}}
'''
result = self._values.get("post_start")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def pre_stop(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: preStop: Script is executed before stopping the format as: { "exec": { "command": "cat", "/ etc / group"}}
'''
result = self._values.get("pre_stop")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def readiness(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: readiness: Application launch status check, health check fails repeatedly container will be killed and restarted. Do not pass health check of the vessel will not have to enter SLB traffic. For example: { "exec": { "command": [ "sleep", "6s"]}, "initialDelaySeconds": 15, "timeoutSeconds": 12}
'''
result = self._values.get("readiness")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def security_group_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: securityGroupId: Security group ID.
'''
result = self._values.get("security_group_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def sls_configs(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: slsConfigs: Log collection configuration file
'''
result = self._values.get("sls_configs")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def tags(self) -> typing.Optional[typing.List[RosApplication.TagsProperty]]:
'''
:Property: tags: Tags to attach to application. Max support 20 tags to add during create application. Each tag with two properties Key and Value, and Key is required.
'''
result = self._values.get("tags")
return typing.cast(typing.Optional[typing.List[RosApplication.TagsProperty]], result)
@builtins.property
def timezone(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: timezone: Application time zone. Default Asia/Shanghai.
'''
result = self._values.get("timezone")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def vpc_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: vpcId: EDAS namespace corresponding VPC. In Serverless in a corresponding one of the VPC namespace only, and can not be modified. Serverless first created in the application name space will form a binding relationship. You may correspond to a plurality of namespaces VPC. Do not fill was VpcId namespace binding.
'''
result = self._values.get("vpc_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def v_switch_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: vSwitchId: Application examples where the elastic card virtual switch. The switch must be located above the VPC. The same switch with EDAS namespace binding relationship. Do not fill was VSwitchId namespace binding.
'''
result = self._values.get("v_switch_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def war_start_options(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:: " start
:Property: warStartOptions: War Start the application package option. Apply the default startup command: java $ JAVA_OPTS $ CATALINA_OPTS -Options org.apache.catalina.startup.Bootstrap "$
'''
result = self._values.get("war_start_options")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def web_container(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: webContainer: Tomcat deployment of the package depends on the version. Mirroring not supported.
'''
result = self._values.get("web_container")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "RosApplicationProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class RosNamespace(
_ros_cdk_core_7adfd82f.RosResource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-sae.RosNamespace",
):
'''A ROS template type: ``ALIYUN::SAE::Namespace``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["RosNamespaceProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
'''Create a new ``ALIYUN::SAE::Namespace``.
:param scope: - scope in which this resource is defined.
:param id: - scoped id of the resource.
:param props: - resource properties.
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__15a8e45635617a9683594fc8dcb4419f8350787eb38c78f222dde758a42980fb)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@jsii.member(jsii_name="renderProperties")
def _render_properties(
self,
props: typing.Mapping[builtins.str, typing.Any],
) -> typing.Mapping[builtins.str, typing.Any]:
'''
:param props: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__7e8ee023c0f95304cf7acc360eed41f2d9079274b796937e9be7c751a37275d2)
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))
@jsii.python.classproperty
@jsii.member(jsii_name="ROS_RESOURCE_TYPE_NAME")
def ROS_RESOURCE_TYPE_NAME(cls) -> builtins.str:
'''The resource type name for this resource class.'''
return typing.cast(builtins.str, jsii.sget(cls, "ROS_RESOURCE_TYPE_NAME"))
@builtins.property
@jsii.member(jsii_name="attrNamespaceId")
def attr_namespace_id(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: NamespaceId: Namespace ID
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrNamespaceId"))
@builtins.property
@jsii.member(jsii_name="rosProperties")
def _ros_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "rosProperties"))
@builtins.property
@jsii.member(jsii_name="enableResourcePropertyConstraint")
def enable_resource_property_constraint(self) -> builtins.bool:
return typing.cast(builtins.bool, jsii.get(self, "enableResourcePropertyConstraint"))
@enable_resource_property_constraint.setter
def enable_resource_property_constraint(self, value: builtins.bool) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__9521ee8c9c402fb6cc06ba0b29c811e4c97b401bbba3e573800bc7b7a58faca4)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "enableResourcePropertyConstraint", value)
@builtins.property
@jsii.member(jsii_name="namespaceId")
def namespace_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: namespaceId: Namespace ID. Format: "regionId:logicalId" or "logicalId"
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "namespaceId"))
@namespace_id.setter
def namespace_id(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__7be6b67baaccf4950b527774e4d0df8af926966616a8db1d6100f684add2c386)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "namespaceId", value)
@builtins.property
@jsii.member(jsii_name="namespaceName")
def namespace_name(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: namespaceName: Namespace name
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "namespaceName"))
@namespace_name.setter
def namespace_name(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__68b31d2a2dc5c2cdee47e29ba29505b06e2a98d5be0c81865e70fe51975997cd)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "namespaceName", value)
@builtins.property
@jsii.member(jsii_name="namespaceDescription")
def namespace_description(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: namespaceDescription: Namespace description
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "namespaceDescription"))
@namespace_description.setter
def namespace_description(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__c290c52b5e7e8c39e8bb112d577c29041b3b2c32d7b374cac887956b36d335e9)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "namespaceDescription", value)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-sae.RosNamespaceProps",
jsii_struct_bases=[],
name_mapping={
"namespace_id": "namespaceId",
"namespace_name": "namespaceName",
"namespace_description": "namespaceDescription",
},
)
class RosNamespaceProps:
def __init__(
self,
*,
namespace_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
namespace_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
namespace_description: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::SAE::Namespace``.
:param namespace_id:
:param namespace_name:
:param namespace_description:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__72b60bd7e7c943ee569b32df806fe13b811a07025835018b13cd2b4d31ea75fb)
check_type(argname="argument namespace_id", value=namespace_id, expected_type=type_hints["namespace_id"])
check_type(argname="argument namespace_name", value=namespace_name, expected_type=type_hints["namespace_name"])
check_type(argname="argument namespace_description", value=namespace_description, expected_type=type_hints["namespace_description"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"namespace_id": namespace_id,
"namespace_name": namespace_name,
}
if namespace_description is not None:
self._values["namespace_description"] = namespace_description
@builtins.property
def namespace_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: namespaceId: Namespace ID. Format: "regionId:logicalId" or "logicalId"
'''
result = self._values.get("namespace_id")
assert result is not None, "Required property 'namespace_id' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def namespace_name(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: namespaceName: Namespace name
'''
result = self._values.get("namespace_name")
assert result is not None, "Required property 'namespace_name' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def namespace_description(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: namespaceDescription: Namespace description
'''
result = self._values.get("namespace_description")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "RosNamespaceProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class RosSlbBinding(
_ros_cdk_core_7adfd82f.RosResource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-sae.RosSlbBinding",
):
'''A ROS template type: ``ALIYUN::SAE::SlbBinding``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["RosSlbBindingProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
'''Create a new ``ALIYUN::SAE::SlbBinding``.
:param scope: - scope in which this resource is defined.
:param id: - scoped id of the resource.
:param props: - resource properties.
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__fc528f258b9def1f2a5a16f5349e2aa027c742f748b4de154375c91c77698b18)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@jsii.member(jsii_name="renderProperties")
def _render_properties(
self,
props: typing.Mapping[builtins.str, typing.Any],
) -> typing.Mapping[builtins.str, typing.Any]:
'''
:param props: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__09f60df871539a0a0600bb4d2c955bdd8bee1b4dc990c05fcafd7cb9af180195)
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))
@jsii.python.classproperty
@jsii.member(jsii_name="ROS_RESOURCE_TYPE_NAME")
def ROS_RESOURCE_TYPE_NAME(cls) -> builtins.str:
'''The resource type name for this resource class.'''
return typing.cast(builtins.str, jsii.sget(cls, "ROS_RESOURCE_TYPE_NAME"))
@builtins.property
@jsii.member(jsii_name="attrAppId")
def attr_app_id(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: AppId: Successful application deployment target ID
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrAppId"))
@builtins.property
@jsii.member(jsii_name="attrChangeOrderId")
def attr_change_order_id(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: ChangeOrderId: Return to release a single ID, used to query task execution status.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrChangeOrderId"))
@builtins.property
@jsii.member(jsii_name="rosProperties")
def _ros_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "rosProperties"))
@builtins.property
@jsii.member(jsii_name="appId")
def app_id(self) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: appId: Successful application deployment target ID
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "appId"))
@app_id.setter
def app_id(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__bd0119dcee94bfd1aced3cf0508f60138fbef7de4e26599b45f188a94625bc14)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "appId", value)
@builtins.property
@jsii.member(jsii_name="enableResourcePropertyConstraint")
def enable_resource_property_constraint(self) -> builtins.bool:
return typing.cast(builtins.bool, jsii.get(self, "enableResourcePropertyConstraint"))
@enable_resource_property_constraint.setter
def enable_resource_property_constraint(self, value: builtins.bool) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__c8175baa1186a68d863607c163d20c902b3965c73e7e3985fc257f8a5a917fa2)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "enableResourcePropertyConstraint", value)
@builtins.property
@jsii.member(jsii_name="internet")
def internet(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: internet: Binding public SLB. For example: [{ "port": 80, "targetPort": 8080, "protocol": "TCP"}], shows a container port 8080 through port 80 slb exposed service, the protocol is TCP, the blank is ignored.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "internet"))
@internet.setter
def internet(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__65c9a2171164d5d8b96f83b0a619e9d6b77599323bb1e9c8ca513a9920b286e0)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "internet", value)
@builtins.property
@jsii.member(jsii_name="internetSlbId")
def internet_slb_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: internetSlbId: Use SLB purchased specified, currently only supports non-shared examples
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "internetSlbId"))
@internet_slb_id.setter
def internet_slb_id(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__836e3d2e22df9689daa13e1a4fe8c6ce4e0ee2393ed628f850b0be0d710aedbf)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "internetSlbId", value)
@builtins.property
@jsii.member(jsii_name="intranet")
def intranet(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: intranet: Bind private SLB. For example: [{ "port": 80, "targetPort": 8080, "protocol": "TCP"}], shows a container port 8080 through port 80 slb exposed service, the protocol is TCP, the blank is ignored.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "intranet"))
@intranet.setter
def intranet(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__6532d6a5b690645250fb6c7b93989387218d97eb230d5a6b73b694150a95d47d)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "intranet", value)
@builtins.property
@jsii.member(jsii_name="intranetSlbId")
def intranet_slb_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: intranetSlbId: Use SLB purchased specified, currently only supports non-shared examples
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "intranetSlbId"))
@intranet_slb_id.setter
def intranet_slb_id(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__bb2dc16e2400d4b03c34fb48eeeff5ead2d2cb81b1f9b1c519c67b932dac5e11)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "intranetSlbId", value)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-sae.RosSlbBindingProps",
jsii_struct_bases=[],
name_mapping={
"app_id": "appId",
"internet": "internet",
"internet_slb_id": "internetSlbId",
"intranet": "intranet",
"intranet_slb_id": "intranetSlbId",
},
)
class RosSlbBindingProps:
def __init__(
self,
*,
app_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
internet: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
internet_slb_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
intranet: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
intranet_slb_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::SAE::SlbBinding``.
:param app_id:
:param internet:
:param internet_slb_id:
:param intranet:
:param intranet_slb_id:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__10581af792f56a8204bc2a77f33f8523f265a00bf3b93bc2b02c2bf660d619f8)
check_type(argname="argument app_id", value=app_id, expected_type=type_hints["app_id"])
check_type(argname="argument internet", value=internet, expected_type=type_hints["internet"])
check_type(argname="argument internet_slb_id", value=internet_slb_id, expected_type=type_hints["internet_slb_id"])
check_type(argname="argument intranet", value=intranet, expected_type=type_hints["intranet"])
check_type(argname="argument intranet_slb_id", value=intranet_slb_id, expected_type=type_hints["intranet_slb_id"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"app_id": app_id,
}
if internet is not None:
self._values["internet"] = internet
if internet_slb_id is not None:
self._values["internet_slb_id"] = internet_slb_id
if intranet is not None:
self._values["intranet"] = intranet
if intranet_slb_id is not None:
self._values["intranet_slb_id"] = intranet_slb_id
@builtins.property
def app_id(self) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: appId: Successful application deployment target ID
'''
result = self._values.get("app_id")
assert result is not None, "Required property 'app_id' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def internet(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: internet: Binding public SLB. For example: [{ "port": 80, "targetPort": 8080, "protocol": "TCP"}], shows a container port 8080 through port 80 slb exposed service, the protocol is TCP, the blank is ignored.
'''
result = self._values.get("internet")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def internet_slb_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: internetSlbId: Use SLB purchased specified, currently only supports non-shared examples
'''
result = self._values.get("internet_slb_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def intranet(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: intranet: Bind private SLB. For example: [{ "port": 80, "targetPort": 8080, "protocol": "TCP"}], shows a container port 8080 through port 80 slb exposed service, the protocol is TCP, the blank is ignored.
'''
result = self._values.get("intranet")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def intranet_slb_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: intranetSlbId: Use SLB purchased specified, currently only supports non-shared examples
'''
result = self._values.get("intranet_slb_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "RosSlbBindingProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class SlbBinding(
_ros_cdk_core_7adfd82f.Resource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-sae.SlbBinding",
):
'''A ROS resource type: ``ALIYUN::SAE::SlbBinding``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["SlbBindingProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
'''Create a new ``ALIYUN::SAE::SlbBinding``.
Param scope - scope in which this resource is defined
Param id - scoped id of the resource
Param props - resource properties
:param scope: -
:param id: -
:param props: -
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__e94ea6860f49e6112ade5deaba335a4c5eb22b6fcd60739d49408115833678d0)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@builtins.property
@jsii.member(jsii_name="attrAppId")
def attr_app_id(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute AppId: Successful application deployment target ID.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrAppId"))
@builtins.property
@jsii.member(jsii_name="attrChangeOrderId")
def attr_change_order_id(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute ChangeOrderId: Return to release a single ID, used to query task execution status.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrChangeOrderId"))
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-sae.SlbBindingProps",
jsii_struct_bases=[],
name_mapping={
"app_id": "appId",
"internet": "internet",
"internet_slb_id": "internetSlbId",
"intranet": "intranet",
"intranet_slb_id": "intranetSlbId",
},
)
class SlbBindingProps:
def __init__(
self,
*,
app_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
internet: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
internet_slb_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
intranet: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
intranet_slb_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::SAE::SlbBinding``.
:param app_id: Property appId: Successful application deployment target ID.
:param internet: Property internet: Binding public SLB. For example: [{ "port": 80, "targetPort": 8080, "protocol": "TCP"}], shows a container port 8080 through port 80 slb exposed service, the protocol is TCP, the blank is ignored.
:param internet_slb_id: Property internetSlbId: Use SLB purchased specified, currently only supports non-shared examples.
:param intranet: Property intranet: Bind private SLB. For example: [{ "port": 80, "targetPort": 8080, "protocol": "TCP"}], shows a container port 8080 through port 80 slb exposed service, the protocol is TCP, the blank is ignored.
:param intranet_slb_id: Property intranetSlbId: Use SLB purchased specified, currently only supports non-shared examples.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__f9817069c9ab48a70950a4985d39f2c85d33ec18200d162415308c81c9af811a)
check_type(argname="argument app_id", value=app_id, expected_type=type_hints["app_id"])
check_type(argname="argument internet", value=internet, expected_type=type_hints["internet"])
check_type(argname="argument internet_slb_id", value=internet_slb_id, expected_type=type_hints["internet_slb_id"])
check_type(argname="argument intranet", value=intranet, expected_type=type_hints["intranet"])
check_type(argname="argument intranet_slb_id", value=intranet_slb_id, expected_type=type_hints["intranet_slb_id"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"app_id": app_id,
}
if internet is not None:
self._values["internet"] = internet
if internet_slb_id is not None:
self._values["internet_slb_id"] = internet_slb_id
if intranet is not None:
self._values["intranet"] = intranet
if intranet_slb_id is not None:
self._values["intranet_slb_id"] = intranet_slb_id
@builtins.property
def app_id(self) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property appId: Successful application deployment target ID.'''
result = self._values.get("app_id")
assert result is not None, "Required property 'app_id' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def internet(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property internet: Binding public SLB.
For example: [{ "port": 80, "targetPort": 8080, "protocol": "TCP"}], shows a container port 8080 through port 80 slb exposed service, the protocol is TCP, the blank is ignored.
'''
result = self._values.get("internet")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def internet_slb_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property internetSlbId: Use SLB purchased specified, currently only supports non-shared examples.'''
result = self._values.get("internet_slb_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def intranet(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property intranet: Bind private SLB.
For example: [{ "port": 80, "targetPort": 8080, "protocol": "TCP"}], shows a container port 8080 through port 80 slb exposed service, the protocol is TCP, the blank is ignored.
'''
result = self._values.get("intranet")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def intranet_slb_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property intranetSlbId: Use SLB purchased specified, currently only supports non-shared examples.'''
result = self._values.get("intranet_slb_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "SlbBindingProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
__all__ = [
"Application",
"ApplicationProps",
"Namespace",
"NamespaceProps",
"RosApplication",
"RosApplicationProps",
"RosNamespace",
"RosNamespaceProps",
"RosSlbBinding",
"RosSlbBindingProps",
"SlbBinding",
"SlbBindingProps",
"datasource",
]
publication.publish()
# Loading modules to ensure their types are registered with the jsii runtime library
from . import datasource
def _typecheckingstub__f40e4e0dc21b5530d850ac62cc0ec37d92bd5e584281413caabd068c72ee536d(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[ApplicationProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__9e0809ad432939d33626184efbc5fc3baf4368e4c612a52467ac68e941027e8f(
*,
app_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
cpu: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
memory: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
namespace_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
package_type: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
replicas: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
app_description: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
command: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
command_args: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
custom_host_alias: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
deploy: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
edas_container_version: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
envs: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
image_url: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
jar_start_args: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
jar_start_options: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
jdk: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
liveness: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
mount_desc: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
mount_host: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
nas_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
package_url: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
package_version: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
post_start: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
pre_stop: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
readiness: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
security_group_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
sls_configs: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
tags: typing.Optional[typing.Sequence[typing.Union[RosApplication.TagsProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
timezone: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
vpc_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
v_switch_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
war_start_options: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
web_container: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__f3f5a3b3a5bb50b41c8347823790f2a6e0c342121b76c178ab306a6124c6ed0d(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[NamespaceProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__3b485e9afeb6d7962b252f0119e24ac9d51e6da5f0f3c36903b5cc97feb5113d(
*,
namespace_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
namespace_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
namespace_description: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__0c1ab3203db4f9a1da714c700215a6c337b7f1ad1132fd0ca6890604cd6bf929(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[RosApplicationProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__a922c8161e8f9e49f5d63e2ea3fe9a698c4aa80ad6ac78974a209b4befb2c66d(
props: typing.Mapping[builtins.str, typing.Any],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__b3d86995c21c86a4debd788a70ab20c9ff77940b1057cffbc078bd675f9dffc0(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__9afce2aab31020fd3125cb0cdff507b235b953c0a4bdec465ef92c5b2664d8e0(
value: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__b971010065f6dccc0c659884efcdb0bdf98bd84080efaa6757d1a9442fe06107(
value: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__274f287b31834db9d901486785f88fea8bf061446a631a8704dcec2d515be9e8(
value: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__d90690996fe24527ef0cc5e3d17bec3ea30242370a4877edabede7fbeb8d6216(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__a4d49c765eb959bf619695505932285ece77e895292471016264d3ecbfed81be(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__0b5a879d6eed27264cc1173cef1c78008345198d048be53c18aab4f07b513a14(
value: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__44b73e6612f1a6319f73a995f8bffb83f1292f1b18c622bd85b0038448d726a1(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__8b8e1b11b60d6cc7af8a85cfef24dc3d3b27f375961b4737363217d017fa7225(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__fab9baebb3937b437ab5c1b1b8a764c0b58296ff1fdf1162be8e957bab66e5d8(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__69e502b7f583c59139da6fefa7fd3c4e4edcc34a0693d69164d3f9097b277e17(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__62a56b828b0775c64b0f6205cee85421e514d707779c40ef901f72f3d872e7b8(
value: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__26ff260790e5e70b09f4a667e34338ab6f9342d45a018a3f4164c386e93d2b5b(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__9829cc7d852a42250c2224cfc57ad1eb6ab6922065482e8945df14694a0282a8(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__4331d88d7f21128d9cf6abc3223a97fa1ada83796ff36125dfbc693314b49f88(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__ca61b554fb34e2e904e8d1ae9f2d261d9d93a916fce703176cb272d1e40edb4b(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__69856ed5fe95b9e615b6a9c413b7061af1bce763a24ff55d35e907d1a91f3d89(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__07f3d362b7becba32d414f1cf3c251d8953afdd1698a6ae4eb50ff3bfba66b1b(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__183d37776b468b778ce55cf09edebe71e639b56fc711fc9e89a1870b63f3c783(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__494b0fdbe0e3a07f261ef76829a1081e86225f96f622ccf1b796724d4720a42b(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__4258555e4d3c8274e21366579b9af5f2eb31ecdcd1a8c036a48f0aa25fd8ce86(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__e1c94c35d79244abf1289c00f0f892cae5b6a984884304a1067250ad2de01c74(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__78b4538b42f95387212d94c9eed3d073f6254005b3813d96df5ff2e33fc0896a(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__f5faf2cd874e6003daab00c1012b214add97a867395d90d160b7fa5fddb19498(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__45b49596d8ec100f2b41594fa583ec9314058196b1948be7ec5ed8318565799b(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__cc9620a59954baf6fc324c7bf059d32303aa5e281fcfbac9426df0da86701564(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__287eea9772792ae58a8e2a137164b8b244ac6bff880bafb14c8d34a5a4f8a818(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__af32b8eea2efa3cfa4daba653a2801c5c8ac4a9bec4912c342c2919a3dc67778(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__547dca69a5f43e2a98f326603afd6517f5fc6b40c369b012b2ce73786332afd2(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__441091f3eb212761c411129f18585fc21940b52552609093eeaf031ee33ec42b(
value: typing.Optional[typing.List[RosApplication.TagsProperty]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__bd51df4a485ca02763e035d9ff22a252dce4e3eef02bf1b218f8c06148846b57(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__c7e0d8213ad19f8767dfb51bf368df178dd50ebf50c25d0583e5971d5e4e3d1e(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__40b0affc3a4ba9751a84d57fd38c49c16985270cabf93b655fee98c18b0fbe55(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__2e4d87811349da12553158b6936d1f01163c17d41bf7cf650d402071f84251ae(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__431185569ef7168590bf23fc2ef060b720247d494123b4f17ec46951c093a3e6(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__e69f60863b35c099eb075f4bc11f90e1940104113f5c268720a2d2fb1ccd7a76(
*,
key: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__b1cf0573cab520f93bd965580156a106306a6abd8a95a6252af4b3b133ed5644(
*,
app_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
cpu: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
memory: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
namespace_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
package_type: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
replicas: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
app_description: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
command: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
command_args: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
custom_host_alias: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
deploy: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
edas_container_version: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
envs: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
image_url: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
jar_start_args: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
jar_start_options: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
jdk: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
liveness: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
mount_desc: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
mount_host: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
nas_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
package_url: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
package_version: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
post_start: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
pre_stop: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
readiness: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
security_group_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
sls_configs: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
tags: typing.Optional[typing.Sequence[typing.Union[RosApplication.TagsProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
timezone: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
vpc_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
v_switch_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
war_start_options: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
web_container: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__15a8e45635617a9683594fc8dcb4419f8350787eb38c78f222dde758a42980fb(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[RosNamespaceProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__7e8ee023c0f95304cf7acc360eed41f2d9079274b796937e9be7c751a37275d2(
props: typing.Mapping[builtins.str, typing.Any],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__9521ee8c9c402fb6cc06ba0b29c811e4c97b401bbba3e573800bc7b7a58faca4(
value: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__7be6b67baaccf4950b527774e4d0df8af926966616a8db1d6100f684add2c386(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__68b31d2a2dc5c2cdee47e29ba29505b06e2a98d5be0c81865e70fe51975997cd(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__c290c52b5e7e8c39e8bb112d577c29041b3b2c32d7b374cac887956b36d335e9(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__72b60bd7e7c943ee569b32df806fe13b811a07025835018b13cd2b4d31ea75fb(
*,
namespace_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
namespace_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
namespace_description: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__fc528f258b9def1f2a5a16f5349e2aa027c742f748b4de154375c91c77698b18(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[RosSlbBindingProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__09f60df871539a0a0600bb4d2c955bdd8bee1b4dc990c05fcafd7cb9af180195(
props: typing.Mapping[builtins.str, typing.Any],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__bd0119dcee94bfd1aced3cf0508f60138fbef7de4e26599b45f188a94625bc14(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__c8175baa1186a68d863607c163d20c902b3965c73e7e3985fc257f8a5a917fa2(
value: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__65c9a2171164d5d8b96f83b0a619e9d6b77599323bb1e9c8ca513a9920b286e0(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__836e3d2e22df9689daa13e1a4fe8c6ce4e0ee2393ed628f850b0be0d710aedbf(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__6532d6a5b690645250fb6c7b93989387218d97eb230d5a6b73b694150a95d47d(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__bb2dc16e2400d4b03c34fb48eeeff5ead2d2cb81b1f9b1c519c67b932dac5e11(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__10581af792f56a8204bc2a77f33f8523f265a00bf3b93bc2b02c2bf660d619f8(
*,
app_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
internet: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
internet_slb_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
intranet: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
intranet_slb_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__e94ea6860f49e6112ade5deaba335a4c5eb22b6fcd60739d49408115833678d0(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[SlbBindingProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__f9817069c9ab48a70950a4985d39f2c85d33ec18200d162415308c81c9af811a(
*,
app_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
internet: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
internet_slb_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
intranet: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
intranet_slb_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass | /ros-cdk-sae-1.0.17.tar.gz/ros-cdk-sae-1.0.17/src/ros_cdk_sae/__init__.py | 0.574634 | 0.156137 | __init__.py | pypi |
import abc
import builtins
import datetime
import enum
import typing
import jsii
import publication
import typing_extensions
from typeguard import check_type
from .._jsii import *
import ros_cdk_core as _ros_cdk_core_7adfd82f
class Applications(
_ros_cdk_core_7adfd82f.Resource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-sae.datasource.Applications",
):
'''A ROS resource type: ``DATASOURCE::SAE::Applications``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Optional[typing.Union["ApplicationsProps", typing.Dict[builtins.str, typing.Any]]] = None,
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
'''Create a new ``DATASOURCE::SAE::Applications``.
Param scope - scope in which this resource is defined
Param id - scoped id of the resource
Param props - resource properties
:param scope: -
:param id: -
:param props: -
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__49e4bdef3296bb428c28483753fbbd7dd1293d56f3f1538ada008d4a5ba66df6)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@builtins.property
@jsii.member(jsii_name="attrApplicationIds")
def attr_application_ids(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute ApplicationIds: The list of application IDs.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrApplicationIds"))
@builtins.property
@jsii.member(jsii_name="attrApplications")
def attr_applications(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute Applications: The list of applications.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrApplications"))
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-sae.datasource.ApplicationsProps",
jsii_struct_bases=[],
name_mapping={
"app_name": "appName",
"field_type": "fieldType",
"field_value": "fieldValue",
"namespace_id": "namespaceId",
},
)
class ApplicationsProps:
def __init__(
self,
*,
app_name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
field_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
field_value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
namespace_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``DATASOURCE::SAE::Applications``.
:param app_name: Property appName: The name of application.
:param field_type: Property fieldType: Set the dimension of the filter application. Valid values: appName: The application name. appIds: App IDs. slbIps: SLB IP address. instanceIps: Instance IP address.
:param field_value: Property fieldValue: Enter the application name, application ID, SLB IP address, or instance IP address of the target application.
:param namespace_id: Property namespaceId: The ID of namespace.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__29025daf38cb152179805d861e9ccdb1a4c5ee6beb68a52bf71c7a702b88800c)
check_type(argname="argument app_name", value=app_name, expected_type=type_hints["app_name"])
check_type(argname="argument field_type", value=field_type, expected_type=type_hints["field_type"])
check_type(argname="argument field_value", value=field_value, expected_type=type_hints["field_value"])
check_type(argname="argument namespace_id", value=namespace_id, expected_type=type_hints["namespace_id"])
self._values: typing.Dict[builtins.str, typing.Any] = {}
if app_name is not None:
self._values["app_name"] = app_name
if field_type is not None:
self._values["field_type"] = field_type
if field_value is not None:
self._values["field_value"] = field_value
if namespace_id is not None:
self._values["namespace_id"] = namespace_id
@builtins.property
def app_name(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property appName: The name of application.'''
result = self._values.get("app_name")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def field_type(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property fieldType: Set the dimension of the filter application.
Valid values:
appName: The application name.
appIds: App IDs.
slbIps: SLB IP address.
instanceIps: Instance IP address.
'''
result = self._values.get("field_type")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def field_value(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property fieldValue: Enter the application name, application ID, SLB IP address, or instance IP address of the target application.'''
result = self._values.get("field_value")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def namespace_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property namespaceId: The ID of namespace.'''
result = self._values.get("namespace_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "ApplicationsProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class Namespaces(
_ros_cdk_core_7adfd82f.Resource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-sae.datasource.Namespaces",
):
'''A ROS resource type: ``DATASOURCE::SAE::Namespaces``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Optional[typing.Union["NamespacesProps", typing.Dict[builtins.str, typing.Any]]] = None,
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
'''Create a new ``DATASOURCE::SAE::Namespaces``.
Param scope - scope in which this resource is defined
Param id - scoped id of the resource
Param props - resource properties
:param scope: -
:param id: -
:param props: -
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__d2cbd1d5b6d0e8fc52717b08522ad3e2ae966017a3ad269075ae581656043c67)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@builtins.property
@jsii.member(jsii_name="attrNamespaceIds")
def attr_namespace_ids(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute NamespaceIds: The list of namespace names.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrNamespaceIds"))
@builtins.property
@jsii.member(jsii_name="attrNamespaces")
def attr_namespaces(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute Namespaces: The list of namespaces.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrNamespaces"))
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-sae.datasource.NamespacesProps",
jsii_struct_bases=[],
name_mapping={},
)
class NamespacesProps:
def __init__(self) -> None:
'''Properties for defining a ``DATASOURCE::SAE::Namespaces``.'''
self._values: typing.Dict[builtins.str, typing.Any] = {}
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "NamespacesProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class RosApplications(
_ros_cdk_core_7adfd82f.RosResource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-sae.datasource.RosApplications",
):
'''A ROS template type: ``DATASOURCE::SAE::Applications``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["RosApplicationsProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
'''Create a new ``DATASOURCE::SAE::Applications``.
:param scope: - scope in which this resource is defined.
:param id: - scoped id of the resource.
:param props: - resource properties.
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__6f465b1e13341a2c47d6841f4870f0d4f7c0839045cef299109b93f1d9792818)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@jsii.member(jsii_name="renderProperties")
def _render_properties(
self,
props: typing.Mapping[builtins.str, typing.Any],
) -> typing.Mapping[builtins.str, typing.Any]:
'''
:param props: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__86262fb439b0807c0cd63bd5bb248bc9b42f3a2ef52389a1a2ea00bd7b75c1fc)
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))
@jsii.python.classproperty
@jsii.member(jsii_name="ROS_RESOURCE_TYPE_NAME")
def ROS_RESOURCE_TYPE_NAME(cls) -> builtins.str:
'''The resource type name for this resource class.'''
return typing.cast(builtins.str, jsii.sget(cls, "ROS_RESOURCE_TYPE_NAME"))
@builtins.property
@jsii.member(jsii_name="attrApplicationIds")
def attr_application_ids(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: ApplicationIds: The list of application IDs.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrApplicationIds"))
@builtins.property
@jsii.member(jsii_name="attrApplications")
def attr_applications(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: Applications: The list of applications.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrApplications"))
@builtins.property
@jsii.member(jsii_name="rosProperties")
def _ros_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "rosProperties"))
@builtins.property
@jsii.member(jsii_name="enableResourcePropertyConstraint")
def enable_resource_property_constraint(self) -> builtins.bool:
return typing.cast(builtins.bool, jsii.get(self, "enableResourcePropertyConstraint"))
@enable_resource_property_constraint.setter
def enable_resource_property_constraint(self, value: builtins.bool) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__2778a636f0689727a19a5b1152f8cc9de8e65c2163b547f81f4bfb16aac63c04)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "enableResourcePropertyConstraint", value)
@builtins.property
@jsii.member(jsii_name="appName")
def app_name(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: appName: The name of application.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "appName"))
@app_name.setter
def app_name(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__37990fdbcdd8566b8ea653bf5d4050d35d777f3a64b842822be50a906e0209f3)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "appName", value)
@builtins.property
@jsii.member(jsii_name="fieldType")
def field_type(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
fieldType: Set the dimension of the filter application. Valid values:
appName: The application name.
appIds: App IDs.
slbIps: SLB IP address.
instanceIps: Instance IP address.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "fieldType"))
@field_type.setter
def field_type(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__03d423a36b1bb2b71f0aeeab4761dbc8e7b2acb14cceeb0c4dd8cbb642b80257)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "fieldType", value)
@builtins.property
@jsii.member(jsii_name="fieldValue")
def field_value(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: fieldValue: Enter the application name, application ID, SLB IP address, or instance IP address of the target application.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "fieldValue"))
@field_value.setter
def field_value(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__3aff474fb2c60e61121af14a9b6e5acf26f48dcc76a1f887a2e422b9e843657e)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "fieldValue", value)
@builtins.property
@jsii.member(jsii_name="namespaceId")
def namespace_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: namespaceId: The ID of namespace.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "namespaceId"))
@namespace_id.setter
def namespace_id(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__58f4cd8740096e123558fd63b4ebe41259a802cd919876cdc792162f5312386f)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "namespaceId", value)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-sae.datasource.RosApplicationsProps",
jsii_struct_bases=[],
name_mapping={
"app_name": "appName",
"field_type": "fieldType",
"field_value": "fieldValue",
"namespace_id": "namespaceId",
},
)
class RosApplicationsProps:
def __init__(
self,
*,
app_name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
field_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
field_value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
namespace_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``DATASOURCE::SAE::Applications``.
:param app_name:
:param field_type:
:param field_value:
:param namespace_id:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__41436a3fb9a498c7b477b581d38665f95f2c6a86145c923bf54b9e3e4156d7f8)
check_type(argname="argument app_name", value=app_name, expected_type=type_hints["app_name"])
check_type(argname="argument field_type", value=field_type, expected_type=type_hints["field_type"])
check_type(argname="argument field_value", value=field_value, expected_type=type_hints["field_value"])
check_type(argname="argument namespace_id", value=namespace_id, expected_type=type_hints["namespace_id"])
self._values: typing.Dict[builtins.str, typing.Any] = {}
if app_name is not None:
self._values["app_name"] = app_name
if field_type is not None:
self._values["field_type"] = field_type
if field_value is not None:
self._values["field_value"] = field_value
if namespace_id is not None:
self._values["namespace_id"] = namespace_id
@builtins.property
def app_name(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: appName: The name of application.
'''
result = self._values.get("app_name")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def field_type(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
fieldType: Set the dimension of the filter application. Valid values:
appName: The application name.
appIds: App IDs.
slbIps: SLB IP address.
instanceIps: Instance IP address.
'''
result = self._values.get("field_type")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def field_value(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: fieldValue: Enter the application name, application ID, SLB IP address, or instance IP address of the target application.
'''
result = self._values.get("field_value")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def namespace_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: namespaceId: The ID of namespace.
'''
result = self._values.get("namespace_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "RosApplicationsProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class RosNamespaces(
_ros_cdk_core_7adfd82f.RosResource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-sae.datasource.RosNamespaces",
):
'''A ROS template type: ``DATASOURCE::SAE::Namespaces``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["RosNamespacesProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
'''Create a new ``DATASOURCE::SAE::Namespaces``.
:param scope: - scope in which this resource is defined.
:param id: - scoped id of the resource.
:param props: - resource properties.
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__c993238fee32dd4ddf8f464c9ea32f62bb53ae5ca387a4d26193cecd55b241a2)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@jsii.member(jsii_name="renderProperties")
def _render_properties(
self,
props: typing.Mapping[builtins.str, typing.Any],
) -> typing.Mapping[builtins.str, typing.Any]:
'''
:param props: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__af35a163775e76eb21ea8ce463a52afed71b548a0eb9fe5cf1603519617f0d96)
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))
@jsii.python.classproperty
@jsii.member(jsii_name="ROS_RESOURCE_TYPE_NAME")
def ROS_RESOURCE_TYPE_NAME(cls) -> builtins.str:
'''The resource type name for this resource class.'''
return typing.cast(builtins.str, jsii.sget(cls, "ROS_RESOURCE_TYPE_NAME"))
@builtins.property
@jsii.member(jsii_name="attrNamespaceIds")
def attr_namespace_ids(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: NamespaceIds: The list of namespace names.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrNamespaceIds"))
@builtins.property
@jsii.member(jsii_name="attrNamespaces")
def attr_namespaces(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: Namespaces: The list of namespaces.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrNamespaces"))
@builtins.property
@jsii.member(jsii_name="rosProperties")
def _ros_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "rosProperties"))
@builtins.property
@jsii.member(jsii_name="enableResourcePropertyConstraint")
def enable_resource_property_constraint(self) -> builtins.bool:
return typing.cast(builtins.bool, jsii.get(self, "enableResourcePropertyConstraint"))
@enable_resource_property_constraint.setter
def enable_resource_property_constraint(self, value: builtins.bool) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__3a45b9fdc90b4fabfa71b2e4844ba30e9352d30429ad655debb1800ff581598d)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "enableResourcePropertyConstraint", value)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-sae.datasource.RosNamespacesProps",
jsii_struct_bases=[],
name_mapping={},
)
class RosNamespacesProps:
def __init__(self) -> None:
'''Properties for defining a ``DATASOURCE::SAE::Namespaces``.'''
self._values: typing.Dict[builtins.str, typing.Any] = {}
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "RosNamespacesProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
__all__ = [
"Applications",
"ApplicationsProps",
"Namespaces",
"NamespacesProps",
"RosApplications",
"RosApplicationsProps",
"RosNamespaces",
"RosNamespacesProps",
]
publication.publish()
def _typecheckingstub__49e4bdef3296bb428c28483753fbbd7dd1293d56f3f1538ada008d4a5ba66df6(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Optional[typing.Union[ApplicationsProps, typing.Dict[builtins.str, typing.Any]]] = None,
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__29025daf38cb152179805d861e9ccdb1a4c5ee6beb68a52bf71c7a702b88800c(
*,
app_name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
field_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
field_value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
namespace_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__d2cbd1d5b6d0e8fc52717b08522ad3e2ae966017a3ad269075ae581656043c67(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Optional[typing.Union[NamespacesProps, typing.Dict[builtins.str, typing.Any]]] = None,
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__6f465b1e13341a2c47d6841f4870f0d4f7c0839045cef299109b93f1d9792818(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[RosApplicationsProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__86262fb439b0807c0cd63bd5bb248bc9b42f3a2ef52389a1a2ea00bd7b75c1fc(
props: typing.Mapping[builtins.str, typing.Any],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__2778a636f0689727a19a5b1152f8cc9de8e65c2163b547f81f4bfb16aac63c04(
value: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__37990fdbcdd8566b8ea653bf5d4050d35d777f3a64b842822be50a906e0209f3(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__03d423a36b1bb2b71f0aeeab4761dbc8e7b2acb14cceeb0c4dd8cbb642b80257(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__3aff474fb2c60e61121af14a9b6e5acf26f48dcc76a1f887a2e422b9e843657e(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__58f4cd8740096e123558fd63b4ebe41259a802cd919876cdc792162f5312386f(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__41436a3fb9a498c7b477b581d38665f95f2c6a86145c923bf54b9e3e4156d7f8(
*,
app_name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
field_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
field_value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
namespace_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__c993238fee32dd4ddf8f464c9ea32f62bb53ae5ca387a4d26193cecd55b241a2(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[RosNamespacesProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__af35a163775e76eb21ea8ce463a52afed71b548a0eb9fe5cf1603519617f0d96(
props: typing.Mapping[builtins.str, typing.Any],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__3a45b9fdc90b4fabfa71b2e4844ba30e9352d30429ad655debb1800ff581598d(
value: builtins.bool,
) -> None:
"""Type checking stubs"""
pass | /ros-cdk-sae-1.0.17.tar.gz/ros-cdk-sae-1.0.17/src/ros_cdk_sae/datasource/__init__.py | 0.640299 | 0.154663 | __init__.py | pypi |
import abc
import builtins
import datetime
import enum
import typing
import jsii
import publication
import typing_extensions
from typeguard import check_type
from ._jsii import *
import ros_cdk_core as _ros_cdk_core_7adfd82f
class AccessControl(
_ros_cdk_core_7adfd82f.Resource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-slb.AccessControl",
):
'''A ROS resource type: ``ALIYUN::SLB::AccessControl``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["AccessControlProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
'''Create a new ``ALIYUN::SLB::AccessControl``.
Param scope - scope in which this resource is defined
Param id - scoped id of the resource
Param props - resource properties
:param scope: -
:param id: -
:param props: -
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__32a956c3ef43a14333968f8229f0d7116d55dad7cb2d8c920d99a092cc4d2653)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@builtins.property
@jsii.member(jsii_name="attrAclId")
def attr_acl_id(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute AclId: The ID of the access control list.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrAclId"))
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-slb.AccessControlProps",
jsii_struct_bases=[],
name_mapping={
"acl_name": "aclName",
"acl_entries": "aclEntries",
"address_ip_version": "addressIpVersion",
"resource_group_id": "resourceGroupId",
"tags": "tags",
},
)
class AccessControlProps:
def __init__(
self,
*,
acl_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
acl_entries: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union["RosAccessControl.AclEntriesProperty", typing.Dict[builtins.str, typing.Any]]]]]] = None,
address_ip_version: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
resource_group_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
tags: typing.Optional[typing.Sequence[typing.Union["RosAccessControl.TagsProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::SLB::AccessControl``.
:param acl_name: Property aclName: The name of the access control list.
:param acl_entries: Property aclEntries: A list of acl entries. Each entry can be IP addresses or CIDR blocks. Max length: 50.
:param address_ip_version: Property addressIpVersion: IP version. Could be "ipv4" or "ipv6".
:param resource_group_id: Property resourceGroupId: Resource group id.
:param tags: Property tags: Tags to attach to instance. Max support 20 tags to add during create instance. Each tag with two properties Key and Value, and Key is required.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__c1c7183293eca0c3b4b02f340d7a4e2c6d4d85e9411b7e7727eeef0adb33ea5b)
check_type(argname="argument acl_name", value=acl_name, expected_type=type_hints["acl_name"])
check_type(argname="argument acl_entries", value=acl_entries, expected_type=type_hints["acl_entries"])
check_type(argname="argument address_ip_version", value=address_ip_version, expected_type=type_hints["address_ip_version"])
check_type(argname="argument resource_group_id", value=resource_group_id, expected_type=type_hints["resource_group_id"])
check_type(argname="argument tags", value=tags, expected_type=type_hints["tags"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"acl_name": acl_name,
}
if acl_entries is not None:
self._values["acl_entries"] = acl_entries
if address_ip_version is not None:
self._values["address_ip_version"] = address_ip_version
if resource_group_id is not None:
self._values["resource_group_id"] = resource_group_id
if tags is not None:
self._values["tags"] = tags
@builtins.property
def acl_name(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property aclName: The name of the access control list.'''
result = self._values.get("acl_name")
assert result is not None, "Required property 'acl_name' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def acl_entries(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosAccessControl.AclEntriesProperty"]]]]:
'''Property aclEntries: A list of acl entries.
Each entry can be IP addresses or CIDR blocks. Max length: 50.
'''
result = self._values.get("acl_entries")
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosAccessControl.AclEntriesProperty"]]]], result)
@builtins.property
def address_ip_version(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property addressIpVersion: IP version.
Could be "ipv4" or "ipv6".
'''
result = self._values.get("address_ip_version")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def resource_group_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property resourceGroupId: Resource group id.'''
result = self._values.get("resource_group_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def tags(self) -> typing.Optional[typing.List["RosAccessControl.TagsProperty"]]:
'''Property tags: Tags to attach to instance.
Max support 20 tags to add during create instance. Each tag with two properties Key and Value, and Key is required.
'''
result = self._values.get("tags")
return typing.cast(typing.Optional[typing.List["RosAccessControl.TagsProperty"]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "AccessControlProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class BackendServerAttachment(
_ros_cdk_core_7adfd82f.Resource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-slb.BackendServerAttachment",
):
'''A ROS resource type: ``ALIYUN::SLB::BackendServerAttachment``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["BackendServerAttachmentProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
'''Create a new ``ALIYUN::SLB::BackendServerAttachment``.
Param scope - scope in which this resource is defined
Param id - scoped id of the resource
Param props - resource properties
:param scope: -
:param id: -
:param props: -
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__740242b36f0a9a36e145fd30d2c7f83cb26719ec58aafb1352aad92bfa16b731)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@builtins.property
@jsii.member(jsii_name="attrBackendServers")
def attr_backend_servers(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute BackendServers: The collection of attached backend server.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrBackendServers"))
@builtins.property
@jsii.member(jsii_name="attrLoadBalancerId")
def attr_load_balancer_id(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute LoadBalancerId: The id of load balancer.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrLoadBalancerId"))
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-slb.BackendServerAttachmentProps",
jsii_struct_bases=[],
name_mapping={
"load_balancer_id": "loadBalancerId",
"backend_server_list": "backendServerList",
"backend_servers": "backendServers",
"backend_server_weight_list": "backendServerWeightList",
},
)
class BackendServerAttachmentProps:
def __init__(
self,
*,
load_balancer_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
backend_server_list: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]] = None,
backend_servers: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union["RosBackendServerAttachment.BackendServersProperty", typing.Dict[builtins.str, typing.Any]]]]]] = None,
backend_server_weight_list: typing.Optional[typing.Union[typing.Sequence[typing.Any], _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::SLB::BackendServerAttachment``.
:param load_balancer_id: Property loadBalancerId: The id of load balancer.
:param backend_server_list: Property backendServerList: The comma delimited instance id list.If the property "BackendServers" is setting, this property will be ignored.
:param backend_servers: Property backendServers: The list of ECS instance, which will attached to load balancer.
:param backend_server_weight_list: Property backendServerWeightList: The comma delimited weight list. If no value specified will use 100. If the length is small than "BackendServerList", it will copy the last one to fill the array.If the property "BackendServers" is setting, this property will be ignored.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__02fd1d549c244f46a5382d4091d6a07bac33ae63e08f5b2e88e33380720e9a1e)
check_type(argname="argument load_balancer_id", value=load_balancer_id, expected_type=type_hints["load_balancer_id"])
check_type(argname="argument backend_server_list", value=backend_server_list, expected_type=type_hints["backend_server_list"])
check_type(argname="argument backend_servers", value=backend_servers, expected_type=type_hints["backend_servers"])
check_type(argname="argument backend_server_weight_list", value=backend_server_weight_list, expected_type=type_hints["backend_server_weight_list"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"load_balancer_id": load_balancer_id,
}
if backend_server_list is not None:
self._values["backend_server_list"] = backend_server_list
if backend_servers is not None:
self._values["backend_servers"] = backend_servers
if backend_server_weight_list is not None:
self._values["backend_server_weight_list"] = backend_server_weight_list
@builtins.property
def load_balancer_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property loadBalancerId: The id of load balancer.'''
result = self._values.get("load_balancer_id")
assert result is not None, "Required property 'load_balancer_id' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def backend_server_list(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]]:
'''Property backendServerList: The comma delimited instance id list.If the property "BackendServers" is setting, this property will be ignored.'''
result = self._values.get("backend_server_list")
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]], result)
@builtins.property
def backend_servers(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosBackendServerAttachment.BackendServersProperty"]]]]:
'''Property backendServers: The list of ECS instance, which will attached to load balancer.'''
result = self._values.get("backend_servers")
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosBackendServerAttachment.BackendServersProperty"]]]], result)
@builtins.property
def backend_server_weight_list(
self,
) -> typing.Optional[typing.Union[typing.List[typing.Any], _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property backendServerWeightList: The comma delimited weight list.
If no value specified will use 100. If the length is small than "BackendServerList", it will copy the last one to fill the array.If the property "BackendServers" is setting, this property will be ignored.
'''
result = self._values.get("backend_server_weight_list")
return typing.cast(typing.Optional[typing.Union[typing.List[typing.Any], _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "BackendServerAttachmentProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class BackendServerToVServerGroupAddition(
_ros_cdk_core_7adfd82f.Resource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-slb.BackendServerToVServerGroupAddition",
):
'''A ROS resource type: ``ALIYUN::SLB::BackendServerToVServerGroupAddition``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["BackendServerToVServerGroupAdditionProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
'''Create a new ``ALIYUN::SLB::BackendServerToVServerGroupAddition``.
Param scope - scope in which this resource is defined
Param id - scoped id of the resource
Param props - resource properties
:param scope: -
:param id: -
:param props: -
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__608f8e871d117a9f8ef313d7610c628a9fe7c18d185917a3d7f638927a6abc97)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@builtins.property
@jsii.member(jsii_name="attrVServerGroupId")
def attr_v_server_group_id(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute VServerGroupId: The ID of virtual server group.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrVServerGroupId"))
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-slb.BackendServerToVServerGroupAdditionProps",
jsii_struct_bases=[],
name_mapping={
"backend_servers": "backendServers",
"v_server_group_id": "vServerGroupId",
},
)
class BackendServerToVServerGroupAdditionProps:
def __init__(
self,
*,
backend_servers: typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union["RosBackendServerToVServerGroupAddition.BackendServersProperty", typing.Dict[builtins.str, typing.Any]]]]],
v_server_group_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
'''Properties for defining a ``ALIYUN::SLB::BackendServerToVServerGroupAddition``.
:param backend_servers: Property backendServers: The list of a combination of ECS Instance-Port-Weight.Same ecs instance with different port is allowed, but same ecs instance with same port isn't.
:param v_server_group_id: Property vServerGroupId: The ID of virtual server group.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__a98a4993f3ea63e5fd57b85edbc771753ff77cdcc8b899e785db738504496030)
check_type(argname="argument backend_servers", value=backend_servers, expected_type=type_hints["backend_servers"])
check_type(argname="argument v_server_group_id", value=v_server_group_id, expected_type=type_hints["v_server_group_id"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"backend_servers": backend_servers,
"v_server_group_id": v_server_group_id,
}
@builtins.property
def backend_servers(
self,
) -> typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosBackendServerToVServerGroupAddition.BackendServersProperty"]]]:
'''Property backendServers: The list of a combination of ECS Instance-Port-Weight.Same ecs instance with different port is allowed, but same ecs instance with same port isn't.'''
result = self._values.get("backend_servers")
assert result is not None, "Required property 'backend_servers' is missing"
return typing.cast(typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosBackendServerToVServerGroupAddition.BackendServersProperty"]]], result)
@builtins.property
def v_server_group_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property vServerGroupId: The ID of virtual server group.'''
result = self._values.get("v_server_group_id")
assert result is not None, "Required property 'v_server_group_id' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "BackendServerToVServerGroupAdditionProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class Certificate(
_ros_cdk_core_7adfd82f.Resource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-slb.Certificate",
):
'''A ROS resource type: ``ALIYUN::SLB::Certificate``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Optional[typing.Union["CertificateProps", typing.Dict[builtins.str, typing.Any]]] = None,
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
'''Create a new ``ALIYUN::SLB::Certificate``.
Param scope - scope in which this resource is defined
Param id - scoped id of the resource
Param props - resource properties
:param scope: -
:param id: -
:param props: -
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__7c8fc66ab11f0764614174a5f8788439426cbf2274890fc962a480cf9cae117a)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@builtins.property
@jsii.member(jsii_name="attrCertificateId")
def attr_certificate_id(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute CertificateId: The ID of the certificate.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrCertificateId"))
@builtins.property
@jsii.member(jsii_name="attrFingerprint")
def attr_fingerprint(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute Fingerprint: The fingerprint of the certificate.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrFingerprint"))
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-slb.CertificateProps",
jsii_struct_bases=[],
name_mapping={
"ali_cloud_certificate_id": "aliCloudCertificateId",
"ali_cloud_certificate_name": "aliCloudCertificateName",
"certificate": "certificate",
"certificate_name": "certificateName",
"certificate_type": "certificateType",
"private_key": "privateKey",
"resource_group_id": "resourceGroupId",
"tags": "tags",
},
)
class CertificateProps:
def __init__(
self,
*,
ali_cloud_certificate_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
ali_cloud_certificate_name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
certificate: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
certificate_name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
certificate_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
private_key: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
resource_group_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
tags: typing.Optional[typing.Sequence[typing.Union["RosCertificate.TagsProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::SLB::Certificate``.
:param ali_cloud_certificate_id: Property aliCloudCertificateId: The ID of the Alibaba Cloud certificate.
:param ali_cloud_certificate_name: Property aliCloudCertificateName: The name of the Alibaba Cloud certificate.
:param certificate: Property certificate: The content of the certificate public key.
:param certificate_name: Property certificateName: The name of the certificate.
:param certificate_type: Property certificateType: The type of the certificate.
:param private_key: Property privateKey: The private key.
:param resource_group_id: Property resourceGroupId: Resource group id.
:param tags: Property tags: Tags to attach to instance. Max support 20 tags to add during create instance. Each tag with two properties Key and Value, and Key is required.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__e08ce0ccadd779ef96f0da73a4e29df0de57d7c43d5d820c4dab9d177ce4d59f)
check_type(argname="argument ali_cloud_certificate_id", value=ali_cloud_certificate_id, expected_type=type_hints["ali_cloud_certificate_id"])
check_type(argname="argument ali_cloud_certificate_name", value=ali_cloud_certificate_name, expected_type=type_hints["ali_cloud_certificate_name"])
check_type(argname="argument certificate", value=certificate, expected_type=type_hints["certificate"])
check_type(argname="argument certificate_name", value=certificate_name, expected_type=type_hints["certificate_name"])
check_type(argname="argument certificate_type", value=certificate_type, expected_type=type_hints["certificate_type"])
check_type(argname="argument private_key", value=private_key, expected_type=type_hints["private_key"])
check_type(argname="argument resource_group_id", value=resource_group_id, expected_type=type_hints["resource_group_id"])
check_type(argname="argument tags", value=tags, expected_type=type_hints["tags"])
self._values: typing.Dict[builtins.str, typing.Any] = {}
if ali_cloud_certificate_id is not None:
self._values["ali_cloud_certificate_id"] = ali_cloud_certificate_id
if ali_cloud_certificate_name is not None:
self._values["ali_cloud_certificate_name"] = ali_cloud_certificate_name
if certificate is not None:
self._values["certificate"] = certificate
if certificate_name is not None:
self._values["certificate_name"] = certificate_name
if certificate_type is not None:
self._values["certificate_type"] = certificate_type
if private_key is not None:
self._values["private_key"] = private_key
if resource_group_id is not None:
self._values["resource_group_id"] = resource_group_id
if tags is not None:
self._values["tags"] = tags
@builtins.property
def ali_cloud_certificate_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property aliCloudCertificateId: The ID of the Alibaba Cloud certificate.'''
result = self._values.get("ali_cloud_certificate_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def ali_cloud_certificate_name(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property aliCloudCertificateName: The name of the Alibaba Cloud certificate.'''
result = self._values.get("ali_cloud_certificate_name")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def certificate(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property certificate: The content of the certificate public key.'''
result = self._values.get("certificate")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def certificate_name(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property certificateName: The name of the certificate.'''
result = self._values.get("certificate_name")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def certificate_type(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property certificateType: The type of the certificate.'''
result = self._values.get("certificate_type")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def private_key(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property privateKey: The private key.'''
result = self._values.get("private_key")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def resource_group_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property resourceGroupId: Resource group id.'''
result = self._values.get("resource_group_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def tags(self) -> typing.Optional[typing.List["RosCertificate.TagsProperty"]]:
'''Property tags: Tags to attach to instance.
Max support 20 tags to add during create instance. Each tag with two properties Key and Value, and Key is required.
'''
result = self._values.get("tags")
return typing.cast(typing.Optional[typing.List["RosCertificate.TagsProperty"]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "CertificateProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class DomainExtension(
_ros_cdk_core_7adfd82f.Resource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-slb.DomainExtension",
):
'''A ROS resource type: ``ALIYUN::SLB::DomainExtension``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["DomainExtensionProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
'''Create a new ``ALIYUN::SLB::DomainExtension``.
Param scope - scope in which this resource is defined
Param id - scoped id of the resource
Param props - resource properties
:param scope: -
:param id: -
:param props: -
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__f075a4b99b0d235401fd54cfd59da8a26b061310758c0ce3baea2e025a66018e)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@builtins.property
@jsii.member(jsii_name="attrDomainExtensionId")
def attr_domain_extension_id(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute DomainExtensionId: The ID of the created domain name extension.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrDomainExtensionId"))
@builtins.property
@jsii.member(jsii_name="attrListenerPort")
def attr_listener_port(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute ListenerPort: The front-end HTTPS listener port of the Server Load Balancer instance.
Valid value:
1-65535
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrListenerPort"))
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-slb.DomainExtensionProps",
jsii_struct_bases=[],
name_mapping={
"domain": "domain",
"listener_port": "listenerPort",
"load_balancer_id": "loadBalancerId",
"server_certificate_id": "serverCertificateId",
},
)
class DomainExtensionProps:
def __init__(
self,
*,
domain: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
listener_port: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
load_balancer_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
server_certificate_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
'''Properties for defining a ``ALIYUN::SLB::DomainExtension``.
:param domain: Property domain: The domain name.
:param listener_port: Property listenerPort: The front-end HTTPS listener port of the Server Load Balancer instance. Valid value: 1-65535
:param load_balancer_id: Property loadBalancerId: The ID of Server Load Balancer instance.
:param server_certificate_id: Property serverCertificateId: The ID of the certificate corresponding to the domain name.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__e93ec881b1960b1b062cf14ba12453d6067add0b39f2c325ffcd98b36abf65c6)
check_type(argname="argument domain", value=domain, expected_type=type_hints["domain"])
check_type(argname="argument listener_port", value=listener_port, expected_type=type_hints["listener_port"])
check_type(argname="argument load_balancer_id", value=load_balancer_id, expected_type=type_hints["load_balancer_id"])
check_type(argname="argument server_certificate_id", value=server_certificate_id, expected_type=type_hints["server_certificate_id"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"domain": domain,
"listener_port": listener_port,
"load_balancer_id": load_balancer_id,
"server_certificate_id": server_certificate_id,
}
@builtins.property
def domain(self) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property domain: The domain name.'''
result = self._values.get("domain")
assert result is not None, "Required property 'domain' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def listener_port(
self,
) -> typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property listenerPort: The front-end HTTPS listener port of the Server Load Balancer instance.
Valid value:
1-65535
'''
result = self._values.get("listener_port")
assert result is not None, "Required property 'listener_port' is missing"
return typing.cast(typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def load_balancer_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property loadBalancerId: The ID of Server Load Balancer instance.'''
result = self._values.get("load_balancer_id")
assert result is not None, "Required property 'load_balancer_id' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def server_certificate_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property serverCertificateId: The ID of the certificate corresponding to the domain name.'''
result = self._values.get("server_certificate_id")
assert result is not None, "Required property 'server_certificate_id' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "DomainExtensionProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class Listener(
_ros_cdk_core_7adfd82f.Resource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-slb.Listener",
):
'''A ROS resource type: ``ALIYUN::SLB::Listener``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["ListenerProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
'''Create a new ``ALIYUN::SLB::Listener``.
Param scope - scope in which this resource is defined
Param id - scoped id of the resource
Param props - resource properties
:param scope: -
:param id: -
:param props: -
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__1b5f96846837d0c3ac0e5d668025bfb7c14f2e093ad738ef2d4e8ac499a76f2c)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@builtins.property
@jsii.member(jsii_name="attrListenerPortsAndProtocol")
def attr_listener_ports_and_protocol(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute ListenerPortsAndProtocol: The collection of listener.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrListenerPortsAndProtocol"))
@builtins.property
@jsii.member(jsii_name="attrLoadBalancerId")
def attr_load_balancer_id(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute LoadBalancerId: The id of load balancer.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrLoadBalancerId"))
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-slb.ListenerProps",
jsii_struct_bases=[],
name_mapping={
"bandwidth": "bandwidth",
"listener_port": "listenerPort",
"load_balancer_id": "loadBalancerId",
"protocol": "protocol",
"acl_id": "aclId",
"acl_status": "aclStatus",
"acl_type": "aclType",
"backend_server_port": "backendServerPort",
"ca_certificate_id": "caCertificateId",
"description": "description",
"enable_http2": "enableHttp2",
"gzip": "gzip",
"health_check": "healthCheck",
"http_config": "httpConfig",
"idle_timeout": "idleTimeout",
"master_slave_server_group_id": "masterSlaveServerGroupId",
"persistence": "persistence",
"port_range": "portRange",
"request_timeout": "requestTimeout",
"scheduler": "scheduler",
"server_certificate_id": "serverCertificateId",
"start_listener": "startListener",
"tls_cipher_policy": "tlsCipherPolicy",
"v_server_group_id": "vServerGroupId",
},
)
class ListenerProps:
def __init__(
self,
*,
bandwidth: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
listener_port: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
load_balancer_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
protocol: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
acl_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
acl_status: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
acl_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
backend_server_port: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
ca_certificate_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
description: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
enable_http2: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
gzip: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
health_check: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union["RosListener.HealthCheckProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
http_config: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union["RosListener.HttpConfigProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
idle_timeout: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
master_slave_server_group_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
persistence: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union["RosListener.PersistenceProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
port_range: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union["RosListener.PortRangeProperty", typing.Dict[builtins.str, typing.Any]]]]]] = None,
request_timeout: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
scheduler: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
server_certificate_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
start_listener: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
tls_cipher_policy: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
v_server_group_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::SLB::Listener``.
:param bandwidth: Property bandwidth: The bandwidth of network, unit in Mbps(Million bits per second). If the specified load balancer with "LOAD_BALANCE_ID" is charged by "paybybandwidth" and is created in classic network, each Listener's bandwidth must be greater than 0 and the sum of all of its Listeners' bandwidth can't be greater than the bandwidth of the load balancer.
:param listener_port: Property listenerPort: Port for front listener. Range from 0 to 65535.
:param load_balancer_id: Property loadBalancerId: The id of load balancer to create listener.
:param protocol: Property protocol: The load balancer transport protocol to use for routing: http, https, tcp, or udp.
:param acl_id: Property aclId: The ID of the access control list associated with the listener to be created. If the value of the AclStatus parameter is on, this parameter is required.
:param acl_status: Property aclStatus: Indicates whether to enable access control. Valid values: on | off. Default value: off
:param acl_type: Property aclType: The access control type: * white: Indicates a whitelist. Only requests from IP addresses or CIDR blocks in the selected access control lists are forwarded. This applies to scenarios in which an application only allows access from specific IP addresses. Enabling a whitelist poses some risks to your services. After a whitelist is enabled, only the IP addresses in the list can access the listener. If you enable a whitelist without adding any IP addresses in the list, no requests are forwarded. - black: Indicates a blacklist. Requests from IP addresses or CIDR blocks in the selected access control lists are not forwarded (that is, they are blocked). This applies to scenarios in which an application only denies access from specific IP addresses. If you enable a blacklist without adding any IP addresses in the list, all requests are forwarded. If the value of the AclStatus parameter is on, this parameter is required.
:param backend_server_port: Property backendServerPort: Backend server can listen on ports from 1 to 65535.
:param ca_certificate_id: Property caCertificateId: CA server certificate id, for https listener only.
:param description: Property description: The description of the listener.It must be 1 to 80 characters in length and can contain letters, digits, hyphens (-), forward slashes (/), periods (.), and underscores (_). Chinese characters are supported.
:param enable_http2: Property enableHttp2: Specifies whether to use HTTP/2. It takes effect when Protocol=https. Valid values: on: yes off: no
:param gzip: Property gzip: Specifies whether to enable Gzip compression to compress specific types of files. Valid values: on (default): yes off: no
:param health_check: Property healthCheck: The properties of health checking setting.
:param http_config: Property httpConfig: Config for http protocol.
:param idle_timeout: Property idleTimeout: Specify the idle connection timeout in seconds. Valid value: 1-60 If no request is received during the specified timeout period, Server Load Balancer will temporarily terminate the connection and restart the connection when the next request comes.
:param master_slave_server_group_id: Property masterSlaveServerGroupId: The id of the MasterSlaveServerGroup which use in listener.
:param persistence: Property persistence: The properties of persistence.
:param port_range: Property portRange: Port range, only supports TCP or UDP listener. ListenerPort should be 0 when PortRange is specified.
:param request_timeout: Property requestTimeout: Specify the request timeout in seconds. Valid value: 1-180 If no response is received from the backend server during the specified timeout period, Server Load Balancer will stop waiting and send an HTTP 504 error to the client.
:param scheduler: Property scheduler: The scheduling algorithm. Valid values: wrr: Backend servers that have higher weights receive more requests than those that have lower weights. wlc: Requests are distributed based on the combination of the weights and connections to backend servers. If two backend servers have the same weight, the backend server that has fewer connections receives more requests. rr: Requests are distributed to backend servers in sequence. sch: specifies consistent hashing that is based on source IP addresses. Requests from the same source IP address are distributed to the same backend server. tch: specifies consistent hashing that is based on four factors: source IP address, destination IP address, source port number, and destination port number. Requests that contain the same preceding information are distributed to the same backend server. Default: wrr
:param server_certificate_id: Property serverCertificateId: Server certificate id, for https listener only, this properties is required.
:param start_listener: Property startListener: Whether start listener after listener created. Default True.
:param tls_cipher_policy: Property tlsCipherPolicy: The Transport Layer Security (TLS) security policy. Each security policy contains TLS protocol versions and cipher suites available for HTTPS. It takes effect when Protocol=https.
:param v_server_group_id: Property vServerGroupId: The id of the VServerGroup which use in listener.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__833f6e5162e2986432e31fab06356e33cbaecfa04c65ef36b467797465fd3efa)
check_type(argname="argument bandwidth", value=bandwidth, expected_type=type_hints["bandwidth"])
check_type(argname="argument listener_port", value=listener_port, expected_type=type_hints["listener_port"])
check_type(argname="argument load_balancer_id", value=load_balancer_id, expected_type=type_hints["load_balancer_id"])
check_type(argname="argument protocol", value=protocol, expected_type=type_hints["protocol"])
check_type(argname="argument acl_id", value=acl_id, expected_type=type_hints["acl_id"])
check_type(argname="argument acl_status", value=acl_status, expected_type=type_hints["acl_status"])
check_type(argname="argument acl_type", value=acl_type, expected_type=type_hints["acl_type"])
check_type(argname="argument backend_server_port", value=backend_server_port, expected_type=type_hints["backend_server_port"])
check_type(argname="argument ca_certificate_id", value=ca_certificate_id, expected_type=type_hints["ca_certificate_id"])
check_type(argname="argument description", value=description, expected_type=type_hints["description"])
check_type(argname="argument enable_http2", value=enable_http2, expected_type=type_hints["enable_http2"])
check_type(argname="argument gzip", value=gzip, expected_type=type_hints["gzip"])
check_type(argname="argument health_check", value=health_check, expected_type=type_hints["health_check"])
check_type(argname="argument http_config", value=http_config, expected_type=type_hints["http_config"])
check_type(argname="argument idle_timeout", value=idle_timeout, expected_type=type_hints["idle_timeout"])
check_type(argname="argument master_slave_server_group_id", value=master_slave_server_group_id, expected_type=type_hints["master_slave_server_group_id"])
check_type(argname="argument persistence", value=persistence, expected_type=type_hints["persistence"])
check_type(argname="argument port_range", value=port_range, expected_type=type_hints["port_range"])
check_type(argname="argument request_timeout", value=request_timeout, expected_type=type_hints["request_timeout"])
check_type(argname="argument scheduler", value=scheduler, expected_type=type_hints["scheduler"])
check_type(argname="argument server_certificate_id", value=server_certificate_id, expected_type=type_hints["server_certificate_id"])
check_type(argname="argument start_listener", value=start_listener, expected_type=type_hints["start_listener"])
check_type(argname="argument tls_cipher_policy", value=tls_cipher_policy, expected_type=type_hints["tls_cipher_policy"])
check_type(argname="argument v_server_group_id", value=v_server_group_id, expected_type=type_hints["v_server_group_id"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"bandwidth": bandwidth,
"listener_port": listener_port,
"load_balancer_id": load_balancer_id,
"protocol": protocol,
}
if acl_id is not None:
self._values["acl_id"] = acl_id
if acl_status is not None:
self._values["acl_status"] = acl_status
if acl_type is not None:
self._values["acl_type"] = acl_type
if backend_server_port is not None:
self._values["backend_server_port"] = backend_server_port
if ca_certificate_id is not None:
self._values["ca_certificate_id"] = ca_certificate_id
if description is not None:
self._values["description"] = description
if enable_http2 is not None:
self._values["enable_http2"] = enable_http2
if gzip is not None:
self._values["gzip"] = gzip
if health_check is not None:
self._values["health_check"] = health_check
if http_config is not None:
self._values["http_config"] = http_config
if idle_timeout is not None:
self._values["idle_timeout"] = idle_timeout
if master_slave_server_group_id is not None:
self._values["master_slave_server_group_id"] = master_slave_server_group_id
if persistence is not None:
self._values["persistence"] = persistence
if port_range is not None:
self._values["port_range"] = port_range
if request_timeout is not None:
self._values["request_timeout"] = request_timeout
if scheduler is not None:
self._values["scheduler"] = scheduler
if server_certificate_id is not None:
self._values["server_certificate_id"] = server_certificate_id
if start_listener is not None:
self._values["start_listener"] = start_listener
if tls_cipher_policy is not None:
self._values["tls_cipher_policy"] = tls_cipher_policy
if v_server_group_id is not None:
self._values["v_server_group_id"] = v_server_group_id
@builtins.property
def bandwidth(
self,
) -> typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property bandwidth: The bandwidth of network, unit in Mbps(Million bits per second).
If the specified load balancer with "LOAD_BALANCE_ID" is charged by "paybybandwidth" and is created in classic network, each Listener's bandwidth must be greater than 0 and the sum of all of its Listeners' bandwidth can't be greater than the bandwidth of the load balancer.
'''
result = self._values.get("bandwidth")
assert result is not None, "Required property 'bandwidth' is missing"
return typing.cast(typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def listener_port(
self,
) -> typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property listenerPort: Port for front listener.
Range from 0 to 65535.
'''
result = self._values.get("listener_port")
assert result is not None, "Required property 'listener_port' is missing"
return typing.cast(typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def load_balancer_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property loadBalancerId: The id of load balancer to create listener.'''
result = self._values.get("load_balancer_id")
assert result is not None, "Required property 'load_balancer_id' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def protocol(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property protocol: The load balancer transport protocol to use for routing: http, https, tcp, or udp.'''
result = self._values.get("protocol")
assert result is not None, "Required property 'protocol' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def acl_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property aclId: The ID of the access control list associated with the listener to be created.
If the value of the AclStatus parameter is on, this parameter is required.
'''
result = self._values.get("acl_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def acl_status(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property aclStatus: Indicates whether to enable access control.
Valid values: on | off. Default value: off
'''
result = self._values.get("acl_status")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def acl_type(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property aclType: The access control type: * white: Indicates a whitelist.
Only requests from IP addresses or CIDR blocks in the selected access control lists are forwarded. This applies to scenarios in which an application only allows access from specific IP addresses.
Enabling a whitelist poses some risks to your services.
After a whitelist is enabled, only the IP addresses in the list can access the listener.
If you enable a whitelist without adding any IP addresses in the list, no requests are forwarded.
- black: Indicates a blacklist. Requests from IP addresses or CIDR blocks in the selected access control lists are not forwarded (that is, they are blocked). This applies to scenarios in which an application only denies access from specific IP addresses.
If you enable a blacklist without adding any IP addresses in the list, all requests are forwarded.
If the value of the AclStatus parameter is on, this parameter is required.
'''
result = self._values.get("acl_type")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def backend_server_port(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property backendServerPort: Backend server can listen on ports from 1 to 65535.'''
result = self._values.get("backend_server_port")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def ca_certificate_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property caCertificateId: CA server certificate id, for https listener only.'''
result = self._values.get("ca_certificate_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def description(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property description: The description of the listener.It must be 1 to 80 characters in length and can contain letters, digits, hyphens (-), forward slashes (/), periods (.), and underscores (_). Chinese characters are supported.'''
result = self._values.get("description")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def enable_http2(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property enableHttp2: Specifies whether to use HTTP/2.
It takes effect when Protocol=https. Valid values:
on: yes
off: no
'''
result = self._values.get("enable_http2")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def gzip(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property gzip: Specifies whether to enable Gzip compression to compress specific types of files.
Valid values:
on (default): yes
off: no
'''
result = self._values.get("gzip")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def health_check(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosListener.HealthCheckProperty"]]:
'''Property healthCheck: The properties of health checking setting.'''
result = self._values.get("health_check")
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosListener.HealthCheckProperty"]], result)
@builtins.property
def http_config(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosListener.HttpConfigProperty"]]:
'''Property httpConfig: Config for http protocol.'''
result = self._values.get("http_config")
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosListener.HttpConfigProperty"]], result)
@builtins.property
def idle_timeout(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property idleTimeout: Specify the idle connection timeout in seconds.
Valid value: 1-60 If no request is received during the specified timeout period, Server Load Balancer will temporarily terminate the connection and restart the connection when the next request comes.
'''
result = self._values.get("idle_timeout")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def master_slave_server_group_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property masterSlaveServerGroupId: The id of the MasterSlaveServerGroup which use in listener.'''
result = self._values.get("master_slave_server_group_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def persistence(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosListener.PersistenceProperty"]]:
'''Property persistence: The properties of persistence.'''
result = self._values.get("persistence")
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosListener.PersistenceProperty"]], result)
@builtins.property
def port_range(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosListener.PortRangeProperty"]]]]:
'''Property portRange: Port range, only supports TCP or UDP listener.
ListenerPort should be 0 when PortRange is specified.
'''
result = self._values.get("port_range")
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosListener.PortRangeProperty"]]]], result)
@builtins.property
def request_timeout(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property requestTimeout: Specify the request timeout in seconds.
Valid value: 1-180 If no response is received from the backend server during the specified timeout period, Server Load Balancer will stop waiting and send an HTTP 504 error to the client.
'''
result = self._values.get("request_timeout")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def scheduler(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property scheduler: The scheduling algorithm.
Valid values:
wrr: Backend servers that have higher weights receive more requests than those that have lower weights.
wlc: Requests are distributed based on the combination of the weights and connections to backend servers. If two backend servers have the same weight, the backend server that has fewer connections receives more requests.
rr: Requests are distributed to backend servers in sequence.
sch: specifies consistent hashing that is based on source IP addresses. Requests from the same source IP address are distributed to the same backend server.
tch: specifies consistent hashing that is based on four factors: source IP address, destination IP address, source port number, and destination port number. Requests that contain the same preceding information are distributed to the same backend server.
Default: wrr
'''
result = self._values.get("scheduler")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def server_certificate_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property serverCertificateId: Server certificate id, for https listener only, this properties is required.'''
result = self._values.get("server_certificate_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def start_listener(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property startListener: Whether start listener after listener created.
Default True.
'''
result = self._values.get("start_listener")
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def tls_cipher_policy(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property tlsCipherPolicy: The Transport Layer Security (TLS) security policy.
Each security policy contains TLS protocol versions and cipher suites available for HTTPS. It takes effect when Protocol=https.
'''
result = self._values.get("tls_cipher_policy")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def v_server_group_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property vServerGroupId: The id of the VServerGroup which use in listener.'''
result = self._values.get("v_server_group_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "ListenerProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class LoadBalancer(
_ros_cdk_core_7adfd82f.Resource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-slb.LoadBalancer",
):
'''A ROS resource type: ``ALIYUN::SLB::LoadBalancer``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Optional[typing.Union["LoadBalancerProps", typing.Dict[builtins.str, typing.Any]]] = None,
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
'''Create a new ``ALIYUN::SLB::LoadBalancer``.
Param scope - scope in which this resource is defined
Param id - scoped id of the resource
Param props - resource properties
:param scope: -
:param id: -
:param props: -
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__8cd0aabfc6504c1c8f1619c3401270e978664dbcc2d0bc8fe002d95604294ae0)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@builtins.property
@jsii.member(jsii_name="attrAddressIpVersion")
def attr_address_ip_version(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute AddressIPVersion: IP version.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrAddressIpVersion"))
@builtins.property
@jsii.member(jsii_name="attrAddressType")
def attr_address_type(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute AddressType: The address type of the load balancer.
"intranet" or "internet".
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrAddressType"))
@builtins.property
@jsii.member(jsii_name="attrBandwidth")
def attr_bandwidth(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute Bandwidth: The bandwidth for network.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrBandwidth"))
@builtins.property
@jsii.member(jsii_name="attrIpAddress")
def attr_ip_address(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute IpAddress: The ip address of the load balancer.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrIpAddress"))
@builtins.property
@jsii.member(jsii_name="attrLoadBalancerId")
def attr_load_balancer_id(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute LoadBalancerId: The id of load balance created.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrLoadBalancerId"))
@builtins.property
@jsii.member(jsii_name="attrLoadBalancerName")
def attr_load_balancer_name(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute LoadBalancerName: Name of created load balancer.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrLoadBalancerName"))
@builtins.property
@jsii.member(jsii_name="attrLoadBalancerSpec")
def attr_load_balancer_spec(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute LoadBalancerSpec: The specification of the Server Load Balancer instance.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrLoadBalancerSpec"))
@builtins.property
@jsii.member(jsii_name="attrMasterZoneId")
def attr_master_zone_id(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute MasterZoneId: The master zone id to create load balancer instance.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrMasterZoneId"))
@builtins.property
@jsii.member(jsii_name="attrNetworkType")
def attr_network_type(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute NetworkType: The network type of the load balancer.
"vpc" or "classic" network.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrNetworkType"))
@builtins.property
@jsii.member(jsii_name="attrOrderId")
def attr_order_id(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute OrderId: The order ID.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrOrderId"))
@builtins.property
@jsii.member(jsii_name="attrPayType")
def attr_pay_type(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute PayType: The billing method of the instance to be created.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrPayType"))
@builtins.property
@jsii.member(jsii_name="attrResourceGroupId")
def attr_resource_group_id(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute ResourceGroupId: Resource group id.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrResourceGroupId"))
@builtins.property
@jsii.member(jsii_name="attrSlaveZoneId")
def attr_slave_zone_id(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute SlaveZoneId: The slave zone id to create load balancer instance.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrSlaveZoneId"))
@builtins.property
@jsii.member(jsii_name="attrVpcId")
def attr_vpc_id(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute VpcId: Vpc id.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrVpcId"))
@builtins.property
@jsii.member(jsii_name="attrVSwitchId")
def attr_v_switch_id(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute VSwitchId: VSwitch id.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrVSwitchId"))
class LoadBalancerClone(
_ros_cdk_core_7adfd82f.Resource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-slb.LoadBalancerClone",
):
'''A ROS resource type: ``ALIYUN::SLB::LoadBalancerClone``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["LoadBalancerCloneProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
'''Create a new ``ALIYUN::SLB::LoadBalancerClone``.
Param scope - scope in which this resource is defined
Param id - scoped id of the resource
Param props - resource properties
:param scope: -
:param id: -
:param props: -
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__5d459d5c385260d41c64adc07d3acbacb63cde27ac1ca8722859c1d4827bbc3e)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@builtins.property
@jsii.member(jsii_name="attrLoadBalancerId")
def attr_load_balancer_id(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute LoadBalancerId: The id of load balance generated.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrLoadBalancerId"))
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-slb.LoadBalancerCloneProps",
jsii_struct_bases=[],
name_mapping={
"source_load_balancer_id": "sourceLoadBalancerId",
"backend_servers": "backendServers",
"backend_servers_policy": "backendServersPolicy",
"instance_charge_type": "instanceChargeType",
"load_balancer_name": "loadBalancerName",
"load_balancer_spec": "loadBalancerSpec",
"resource_group_id": "resourceGroupId",
"tags": "tags",
"tags_policy": "tagsPolicy",
"v_switch_id": "vSwitchId",
},
)
class LoadBalancerCloneProps:
def __init__(
self,
*,
source_load_balancer_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
backend_servers: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union["RosLoadBalancerClone.BackendServersProperty", typing.Dict[builtins.str, typing.Any]]]]]] = None,
backend_servers_policy: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
instance_charge_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
load_balancer_name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
load_balancer_spec: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
resource_group_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
tags: typing.Optional[typing.Sequence[typing.Union["RosLoadBalancerClone.TagsProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
tags_policy: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
v_switch_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::SLB::LoadBalancerClone``.
:param source_load_balancer_id: Property sourceLoadBalancerId: Source load balancer id to clone.
:param backend_servers: Property backendServers: The list of ECS instance, which will attached to load balancer.
:param backend_servers_policy: Property backendServersPolicy: Solution for handle the backend server and weights. If select 'clone', it will clone from source load balancer. If select 'empty' it will not attach any backend servers. If select 'append' it will append the new backend server list to source backed servers. If select 'replace' it will only attach new backend server list. Default is 'clone'.
:param instance_charge_type: Property instanceChargeType: Instance billing method. Value:PayBySpec: Pay by spec. PayByCLCU: billed by usage. If not specified, it is same with the source load balancer.
:param load_balancer_name: Property loadBalancerName: Name of created load balancer. Length is limited to 1-80 characters, allowed to contain letters, numbers, '-, /, _,.' When not specified, a default name will be assigned.
:param load_balancer_spec: Property loadBalancerSpec: The specification of the load balancer. If not specified, it is same with the source load balancer. Note If InstanceChargeType is set to PayByCLCU, the LoadBalancerSpec parameter is invalid and you do not need to set this parameter.
:param resource_group_id: Property resourceGroupId: Resource group id.
:param tags: Property tags: Tags to attach to slb. Max support 5 tags to add during create slb. Each tag with two properties Key and Value, and Key is required.
:param tags_policy: Property tagsPolicy: Solution for handle the tags. If select 'clone', it will clone from source load balancer. If select 'empty' it will not copy tags. If select 'append' it will append the new tags. If select 'replace' it will add new tags. Default is 'empty'.
:param v_switch_id: Property vSwitchId: The new VSwitch ID to create load balancer instance. For VPC network only and the VSwitch should belong to the VPC which source load balancer is located.When not specified, source load balancer VSwitch ID will be used.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__f8469484bc4459b59972d21dd27adcec279c397f08f30ae7fb368f548d2a8a94)
check_type(argname="argument source_load_balancer_id", value=source_load_balancer_id, expected_type=type_hints["source_load_balancer_id"])
check_type(argname="argument backend_servers", value=backend_servers, expected_type=type_hints["backend_servers"])
check_type(argname="argument backend_servers_policy", value=backend_servers_policy, expected_type=type_hints["backend_servers_policy"])
check_type(argname="argument instance_charge_type", value=instance_charge_type, expected_type=type_hints["instance_charge_type"])
check_type(argname="argument load_balancer_name", value=load_balancer_name, expected_type=type_hints["load_balancer_name"])
check_type(argname="argument load_balancer_spec", value=load_balancer_spec, expected_type=type_hints["load_balancer_spec"])
check_type(argname="argument resource_group_id", value=resource_group_id, expected_type=type_hints["resource_group_id"])
check_type(argname="argument tags", value=tags, expected_type=type_hints["tags"])
check_type(argname="argument tags_policy", value=tags_policy, expected_type=type_hints["tags_policy"])
check_type(argname="argument v_switch_id", value=v_switch_id, expected_type=type_hints["v_switch_id"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"source_load_balancer_id": source_load_balancer_id,
}
if backend_servers is not None:
self._values["backend_servers"] = backend_servers
if backend_servers_policy is not None:
self._values["backend_servers_policy"] = backend_servers_policy
if instance_charge_type is not None:
self._values["instance_charge_type"] = instance_charge_type
if load_balancer_name is not None:
self._values["load_balancer_name"] = load_balancer_name
if load_balancer_spec is not None:
self._values["load_balancer_spec"] = load_balancer_spec
if resource_group_id is not None:
self._values["resource_group_id"] = resource_group_id
if tags is not None:
self._values["tags"] = tags
if tags_policy is not None:
self._values["tags_policy"] = tags_policy
if v_switch_id is not None:
self._values["v_switch_id"] = v_switch_id
@builtins.property
def source_load_balancer_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property sourceLoadBalancerId: Source load balancer id to clone.'''
result = self._values.get("source_load_balancer_id")
assert result is not None, "Required property 'source_load_balancer_id' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def backend_servers(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosLoadBalancerClone.BackendServersProperty"]]]]:
'''Property backendServers: The list of ECS instance, which will attached to load balancer.'''
result = self._values.get("backend_servers")
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosLoadBalancerClone.BackendServersProperty"]]]], result)
@builtins.property
def backend_servers_policy(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property backendServersPolicy: Solution for handle the backend server and weights.
If select 'clone', it will clone from source load balancer. If select 'empty' it will not attach any backend servers. If select 'append' it will append the new backend server list to source backed servers. If select 'replace' it will only attach new backend server list. Default is 'clone'.
'''
result = self._values.get("backend_servers_policy")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def instance_charge_type(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property instanceChargeType: Instance billing method.
Value:PayBySpec: Pay by spec.
PayByCLCU: billed by usage.
If not specified, it is same with the source load balancer.
'''
result = self._values.get("instance_charge_type")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def load_balancer_name(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property loadBalancerName: Name of created load balancer.
Length is limited to 1-80 characters, allowed to contain letters, numbers, '-, /, _,.' When not specified, a default name will be assigned.
'''
result = self._values.get("load_balancer_name")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def load_balancer_spec(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property loadBalancerSpec: The specification of the load balancer.
If not specified, it is same with the source load balancer.
Note If InstanceChargeType is set to PayByCLCU, the LoadBalancerSpec parameter is invalid and you do not need to set this parameter.
'''
result = self._values.get("load_balancer_spec")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def resource_group_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property resourceGroupId: Resource group id.'''
result = self._values.get("resource_group_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def tags(self) -> typing.Optional[typing.List["RosLoadBalancerClone.TagsProperty"]]:
'''Property tags: Tags to attach to slb.
Max support 5 tags to add during create slb. Each tag with two properties Key and Value, and Key is required.
'''
result = self._values.get("tags")
return typing.cast(typing.Optional[typing.List["RosLoadBalancerClone.TagsProperty"]], result)
@builtins.property
def tags_policy(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property tagsPolicy: Solution for handle the tags.
If select 'clone', it will clone from source load balancer. If select 'empty' it will not copy tags. If select 'append' it will append the new tags. If select 'replace' it will add new tags.
Default is 'empty'.
'''
result = self._values.get("tags_policy")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def v_switch_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property vSwitchId: The new VSwitch ID to create load balancer instance.
For VPC network only and the VSwitch should belong to the VPC which source load balancer is located.When not specified, source load balancer VSwitch ID will be used.
'''
result = self._values.get("v_switch_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "LoadBalancerCloneProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-slb.LoadBalancerProps",
jsii_struct_bases=[],
name_mapping={
"address_ip_version": "addressIpVersion",
"address_type": "addressType",
"auto_pay": "autoPay",
"auto_renew": "autoRenew",
"auto_renew_period": "autoRenewPeriod",
"bandwidth": "bandwidth",
"deletion_protection": "deletionProtection",
"duration": "duration",
"instance_charge_type": "instanceChargeType",
"internet_charge_type": "internetChargeType",
"load_balancer_name": "loadBalancerName",
"load_balancer_spec": "loadBalancerSpec",
"master_zone_id": "masterZoneId",
"modification_protection_reason": "modificationProtectionReason",
"modification_protection_status": "modificationProtectionStatus",
"pay_type": "payType",
"pricing_cycle": "pricingCycle",
"resource_group_id": "resourceGroupId",
"slave_zone_id": "slaveZoneId",
"tags": "tags",
"vpc_id": "vpcId",
"v_switch_id": "vSwitchId",
},
)
class LoadBalancerProps:
def __init__(
self,
*,
address_ip_version: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
address_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
auto_pay: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
auto_renew: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
auto_renew_period: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
bandwidth: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
deletion_protection: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
duration: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
instance_charge_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
internet_charge_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
load_balancer_name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
load_balancer_spec: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
master_zone_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
modification_protection_reason: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
modification_protection_status: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
pay_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
pricing_cycle: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
resource_group_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
slave_zone_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
tags: typing.Optional[typing.Sequence[typing.Union["RosLoadBalancer.TagsProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
vpc_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
v_switch_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::SLB::LoadBalancer``.
:param address_ip_version: Property addressIpVersion: IP version, support 'ipv4' or 'ipv6'. If 'ipv6' is selected, please note that the zone and the specification are supported.
:param address_type: Property addressType: The network type of the CLB instance. Valid values: - **internet** (default): After an internet-facing CLB instance is created, the system assigns a public IP address to the CLB instance. Then, the CLB instance can forward requests over the Internet. - **intranet**: After an internal-facing CLB instance is created, the system assigns a private IP address to the CLB instance. Then, the CLB instance can forward requests only over the internal networks.
:param auto_pay: Property autoPay: Specifies whether to automatically pay for the subscription Internet-facing CLB instance. Valid values: - **true**: automatically pays for the CLB instance. After you call this operation, the system automatically completes the payment and creates the CLB instance.- **false** (default): After you call the operation, the order is created but the payment is not completed. You can view the pending order in the console. The CLB instance will not be created until you complete the payment.**Note** This parameter is supported only by subscription instances created on the Alibaba Cloud China site.
:param auto_renew: Property autoRenew: Indicates whether automatic renewal is enabled for the instance. Valid values:- **true**: Automatic renewal is enabled.- **false** (default): Automatic renewal is not enabled. You must renew the instance manually.
:param auto_renew_period: Property autoRenewPeriod: Automatic renewal cycle, which takes effect when AutoRenew is true, and is required: When PricingCycle = month, the value range is 1 to 9 or 12, 24, 36. When PeriodUnit = year, the value range is 1-3.
:param bandwidth: Property bandwidth: The bandwidth for network, unit in Mbps(Mega bit per second). Default is 1. If InternetChargeType is specified as "paybytraffic", this property will be ignore and please specify the "Bandwidth" in ALIYUN::SLB::Listener.
:param deletion_protection: Property deletionProtection: Whether to enable deletion protection.
:param duration: Property duration: Optional. The subscription duration of a Subscription Internet instance. Valid values: If PricingCycle is month, the valid range is 1 to 9 or 12, 24, 36, 48, 60. If PricingCycle is year, the value range is 1 to 5.
:param instance_charge_type: Property instanceChargeType: Instance billing method. Valid value: - **PayBySpec** (default): Pay by spec. - **PayByCLCU**: billed by usage.
:param internet_charge_type: Property internetChargeType: The metering method of the Internet-facing CLB instance. Valid values: - **paybytraffic** (default): If you set the value to paybytraffic, you do not need to specify Bandwidth. Even if you specify Bandwidth, the value does not take effect. - **paybybandwidth**: pay-by-bandwidth. **Note** If you set PayType to PayOnDemand and set InstanceChargeType to PayByCLCU, you must set InternetChargeType to paybytraffic.
:param load_balancer_name: Property loadBalancerName: Name of created load balancer. Length is limited to 1-80 characters, allowed to contain letters, numbers, '-, /, _,.' When not specified, a default name will be assigned.
:param load_balancer_spec: Property loadBalancerSpec: The specification of the CLB instance. Valid values: - **slb.s1.small** - **slb.s2.small** - **slb.s2.medium** - **slb.s3.small** - **slb.s3.medium** - **slb.s3.large** **Note** If you do not specify this parameter, a shared-resource CLB instance is created. Shared-resource CLB instances are no longer available for purchase. Therefore, you must specify this parameter. If InstanceChargeType is set to PayByCLCU, this parameter is invalid and you do not need to specify this parameter.
:param master_zone_id: Property masterZoneId: The master zone id to create load balancer instance.
:param modification_protection_reason: Property modificationProtectionReason: Set the reason for modifying the protection status. The length is 1-80 English or Chinese characters, must start with upper and lower letters or Chinese, and can include numbers, periods (.), underscores (_) and dashes (-). Only valid when ModificationProtectionStatus is ConsoleProtection.
:param modification_protection_status: Property modificationProtectionStatus: NonProtection or empty: means no restriction on modification protection ConsoleProtection: Modify instance protection status by console Default value is empty.
:param pay_type: Property payType: Optional. The billing method of the instance to be created. Valid value: PayOnDemand (Pay-As-You-Go) | PrePay (Subscription)
:param pricing_cycle: Property pricingCycle: Optional. The duration of the Subscription-billed Internet instance to be created. Valid values: month | year.
:param resource_group_id: Property resourceGroupId: Resource group id.
:param slave_zone_id: Property slaveZoneId: The slave zone id to create load balancer instance.
:param tags: Property tags: Tags to attach to slb. Max support 5 tags to add during create slb. Each tag with two properties Key and Value, and Key is required.
:param vpc_id: Property vpcId: The VPC id to create load balancer instance. For VPC network only.
:param v_switch_id: Property vSwitchId: The VSwitch id to create load balancer instance. For VPC network only.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__a4a7083494ae715443133830be3bb8ff556bfa79afc1e887e4d712b9bb1e2b06)
check_type(argname="argument address_ip_version", value=address_ip_version, expected_type=type_hints["address_ip_version"])
check_type(argname="argument address_type", value=address_type, expected_type=type_hints["address_type"])
check_type(argname="argument auto_pay", value=auto_pay, expected_type=type_hints["auto_pay"])
check_type(argname="argument auto_renew", value=auto_renew, expected_type=type_hints["auto_renew"])
check_type(argname="argument auto_renew_period", value=auto_renew_period, expected_type=type_hints["auto_renew_period"])
check_type(argname="argument bandwidth", value=bandwidth, expected_type=type_hints["bandwidth"])
check_type(argname="argument deletion_protection", value=deletion_protection, expected_type=type_hints["deletion_protection"])
check_type(argname="argument duration", value=duration, expected_type=type_hints["duration"])
check_type(argname="argument instance_charge_type", value=instance_charge_type, expected_type=type_hints["instance_charge_type"])
check_type(argname="argument internet_charge_type", value=internet_charge_type, expected_type=type_hints["internet_charge_type"])
check_type(argname="argument load_balancer_name", value=load_balancer_name, expected_type=type_hints["load_balancer_name"])
check_type(argname="argument load_balancer_spec", value=load_balancer_spec, expected_type=type_hints["load_balancer_spec"])
check_type(argname="argument master_zone_id", value=master_zone_id, expected_type=type_hints["master_zone_id"])
check_type(argname="argument modification_protection_reason", value=modification_protection_reason, expected_type=type_hints["modification_protection_reason"])
check_type(argname="argument modification_protection_status", value=modification_protection_status, expected_type=type_hints["modification_protection_status"])
check_type(argname="argument pay_type", value=pay_type, expected_type=type_hints["pay_type"])
check_type(argname="argument pricing_cycle", value=pricing_cycle, expected_type=type_hints["pricing_cycle"])
check_type(argname="argument resource_group_id", value=resource_group_id, expected_type=type_hints["resource_group_id"])
check_type(argname="argument slave_zone_id", value=slave_zone_id, expected_type=type_hints["slave_zone_id"])
check_type(argname="argument tags", value=tags, expected_type=type_hints["tags"])
check_type(argname="argument vpc_id", value=vpc_id, expected_type=type_hints["vpc_id"])
check_type(argname="argument v_switch_id", value=v_switch_id, expected_type=type_hints["v_switch_id"])
self._values: typing.Dict[builtins.str, typing.Any] = {}
if address_ip_version is not None:
self._values["address_ip_version"] = address_ip_version
if address_type is not None:
self._values["address_type"] = address_type
if auto_pay is not None:
self._values["auto_pay"] = auto_pay
if auto_renew is not None:
self._values["auto_renew"] = auto_renew
if auto_renew_period is not None:
self._values["auto_renew_period"] = auto_renew_period
if bandwidth is not None:
self._values["bandwidth"] = bandwidth
if deletion_protection is not None:
self._values["deletion_protection"] = deletion_protection
if duration is not None:
self._values["duration"] = duration
if instance_charge_type is not None:
self._values["instance_charge_type"] = instance_charge_type
if internet_charge_type is not None:
self._values["internet_charge_type"] = internet_charge_type
if load_balancer_name is not None:
self._values["load_balancer_name"] = load_balancer_name
if load_balancer_spec is not None:
self._values["load_balancer_spec"] = load_balancer_spec
if master_zone_id is not None:
self._values["master_zone_id"] = master_zone_id
if modification_protection_reason is not None:
self._values["modification_protection_reason"] = modification_protection_reason
if modification_protection_status is not None:
self._values["modification_protection_status"] = modification_protection_status
if pay_type is not None:
self._values["pay_type"] = pay_type
if pricing_cycle is not None:
self._values["pricing_cycle"] = pricing_cycle
if resource_group_id is not None:
self._values["resource_group_id"] = resource_group_id
if slave_zone_id is not None:
self._values["slave_zone_id"] = slave_zone_id
if tags is not None:
self._values["tags"] = tags
if vpc_id is not None:
self._values["vpc_id"] = vpc_id
if v_switch_id is not None:
self._values["v_switch_id"] = v_switch_id
@builtins.property
def address_ip_version(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property addressIpVersion: IP version, support 'ipv4' or 'ipv6'.
If 'ipv6' is selected, please note that the zone and the specification are supported.
'''
result = self._values.get("address_ip_version")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def address_type(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property addressType: The network type of the CLB instance.
Valid values:
- **internet** (default): After an internet-facing CLB instance is created, the system assigns a public IP address to the CLB instance. Then, the CLB instance can forward requests over the Internet.
- **intranet**: After an internal-facing CLB instance is created, the system assigns a private IP address to the CLB instance. Then, the CLB instance can forward requests only over the internal networks.
'''
result = self._values.get("address_type")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def auto_pay(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property autoPay: Specifies whether to automatically pay for the subscription Internet-facing CLB instance.
Valid values:
- **true**: automatically pays for the CLB instance. After you call this operation, the system automatically completes the payment and creates the CLB instance.- **false** (default): After you call the operation, the order is created but the payment is not completed. You can view the pending order in the console. The CLB instance will not be created until you complete the payment.**Note** This parameter is supported only by subscription instances created on the Alibaba Cloud China site.
'''
result = self._values.get("auto_pay")
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def auto_renew(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property autoRenew: Indicates whether automatic renewal is enabled for the instance.
Valid values:- **true**: Automatic renewal is enabled.- **false** (default): Automatic renewal is not enabled. You must renew the instance manually.
'''
result = self._values.get("auto_renew")
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def auto_renew_period(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property autoRenewPeriod: Automatic renewal cycle, which takes effect when AutoRenew is true, and is required: When PricingCycle = month, the value range is 1 to 9 or 12, 24, 36.
When PeriodUnit = year, the value range is 1-3.
'''
result = self._values.get("auto_renew_period")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def bandwidth(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property bandwidth: The bandwidth for network, unit in Mbps(Mega bit per second).
Default is 1. If InternetChargeType is specified as "paybytraffic", this property will be ignore and please specify the "Bandwidth" in ALIYUN::SLB::Listener.
'''
result = self._values.get("bandwidth")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def deletion_protection(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property deletionProtection: Whether to enable deletion protection.'''
result = self._values.get("deletion_protection")
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def duration(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property duration: Optional.
The subscription duration of a Subscription Internet instance.
Valid values:
If PricingCycle is month, the valid range is 1 to 9 or 12, 24, 36, 48, 60.
If PricingCycle is year, the value range is 1 to 5.
'''
result = self._values.get("duration")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def instance_charge_type(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property instanceChargeType: Instance billing method.
Valid value:
- **PayBySpec** (default): Pay by spec.
- **PayByCLCU**: billed by usage.
'''
result = self._values.get("instance_charge_type")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def internet_charge_type(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property internetChargeType: The metering method of the Internet-facing CLB instance.
Valid values:
- **paybytraffic** (default): If you set the value to paybytraffic, you do not need to specify Bandwidth. Even if you specify Bandwidth, the value does not take effect.
- **paybybandwidth**: pay-by-bandwidth.
**Note** If you set PayType to PayOnDemand and set InstanceChargeType to PayByCLCU, you must set InternetChargeType to paybytraffic.
'''
result = self._values.get("internet_charge_type")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def load_balancer_name(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property loadBalancerName: Name of created load balancer.
Length is limited to 1-80 characters, allowed to contain letters, numbers, '-, /, _,.' When not specified, a default name will be assigned.
'''
result = self._values.get("load_balancer_name")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def load_balancer_spec(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property loadBalancerSpec: The specification of the CLB instance.
Valid values:
- **slb.s1.small**
- **slb.s2.small**
- **slb.s2.medium**
- **slb.s3.small**
- **slb.s3.medium**
- **slb.s3.large**
**Note** If you do not specify this parameter, a shared-resource CLB instance is created. Shared-resource CLB instances are no longer available for purchase. Therefore, you must specify this parameter.
If InstanceChargeType is set to PayByCLCU, this parameter is invalid and you do not need to specify this parameter.
'''
result = self._values.get("load_balancer_spec")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def master_zone_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property masterZoneId: The master zone id to create load balancer instance.'''
result = self._values.get("master_zone_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def modification_protection_reason(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property modificationProtectionReason: Set the reason for modifying the protection status.
The length is 1-80 English or Chinese characters, must start with upper and lower letters or Chinese, and can include numbers, periods (.), underscores (_) and dashes (-).
Only valid when ModificationProtectionStatus is ConsoleProtection.
'''
result = self._values.get("modification_protection_reason")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def modification_protection_status(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property modificationProtectionStatus: NonProtection or empty: means no restriction on modification protection ConsoleProtection: Modify instance protection status by console Default value is empty.'''
result = self._values.get("modification_protection_status")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def pay_type(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property payType: Optional.
The billing method of the instance to be created.
Valid value: PayOnDemand (Pay-As-You-Go) | PrePay (Subscription)
'''
result = self._values.get("pay_type")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def pricing_cycle(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property pricingCycle: Optional.
The duration of the Subscription-billed Internet instance to be created.
Valid values: month | year.
'''
result = self._values.get("pricing_cycle")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def resource_group_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property resourceGroupId: Resource group id.'''
result = self._values.get("resource_group_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def slave_zone_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property slaveZoneId: The slave zone id to create load balancer instance.'''
result = self._values.get("slave_zone_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def tags(self) -> typing.Optional[typing.List["RosLoadBalancer.TagsProperty"]]:
'''Property tags: Tags to attach to slb.
Max support 5 tags to add during create slb. Each tag with two properties Key and Value, and Key is required.
'''
result = self._values.get("tags")
return typing.cast(typing.Optional[typing.List["RosLoadBalancer.TagsProperty"]], result)
@builtins.property
def vpc_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property vpcId: The VPC id to create load balancer instance.
For VPC network only.
'''
result = self._values.get("vpc_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def v_switch_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property vSwitchId: The VSwitch id to create load balancer instance.
For VPC network only.
'''
result = self._values.get("v_switch_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "LoadBalancerProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class MasterSlaveServerGroup(
_ros_cdk_core_7adfd82f.Resource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-slb.MasterSlaveServerGroup",
):
'''A ROS resource type: ``ALIYUN::SLB::MasterSlaveServerGroup``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["MasterSlaveServerGroupProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
'''Create a new ``ALIYUN::SLB::MasterSlaveServerGroup``.
Param scope - scope in which this resource is defined
Param id - scoped id of the resource
Param props - resource properties
:param scope: -
:param id: -
:param props: -
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__6d5ba0c12773b56874ebafc1ca87ff70891c314834e4f3670157daa8896fbbf6)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@builtins.property
@jsii.member(jsii_name="attrMasterSlaveServerGroupId")
def attr_master_slave_server_group_id(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute MasterSlaveServerGroupId: Active/standby server group ID.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrMasterSlaveServerGroupId"))
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-slb.MasterSlaveServerGroupProps",
jsii_struct_bases=[],
name_mapping={
"load_balancer_id": "loadBalancerId",
"master_slave_backend_servers": "masterSlaveBackendServers",
"master_slave_server_group_name": "masterSlaveServerGroupName",
},
)
class MasterSlaveServerGroupProps:
def __init__(
self,
*,
load_balancer_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
master_slave_backend_servers: typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union["RosMasterSlaveServerGroup.MasterSlaveBackendServersProperty", typing.Dict[builtins.str, typing.Any]]]]],
master_slave_server_group_name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::SLB::MasterSlaveServerGroup``.
:param load_balancer_id: Property loadBalancerId: The ID of the Server Load Balancer instance.
:param master_slave_backend_servers: Property masterSlaveBackendServers: A list of active/standby server group. An active/standby server group can only contain two backend servers.
:param master_slave_server_group_name: Property masterSlaveServerGroupName: The name of the active/standby server group.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__9ba17813f95ad5905513888e77f640c74d85fae7cba6878cee95f3dd8aa8bef1)
check_type(argname="argument load_balancer_id", value=load_balancer_id, expected_type=type_hints["load_balancer_id"])
check_type(argname="argument master_slave_backend_servers", value=master_slave_backend_servers, expected_type=type_hints["master_slave_backend_servers"])
check_type(argname="argument master_slave_server_group_name", value=master_slave_server_group_name, expected_type=type_hints["master_slave_server_group_name"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"load_balancer_id": load_balancer_id,
"master_slave_backend_servers": master_slave_backend_servers,
}
if master_slave_server_group_name is not None:
self._values["master_slave_server_group_name"] = master_slave_server_group_name
@builtins.property
def load_balancer_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property loadBalancerId: The ID of the Server Load Balancer instance.'''
result = self._values.get("load_balancer_id")
assert result is not None, "Required property 'load_balancer_id' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def master_slave_backend_servers(
self,
) -> typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosMasterSlaveServerGroup.MasterSlaveBackendServersProperty"]]]:
'''Property masterSlaveBackendServers: A list of active/standby server group.
An active/standby server group can only contain two backend servers.
'''
result = self._values.get("master_slave_backend_servers")
assert result is not None, "Required property 'master_slave_backend_servers' is missing"
return typing.cast(typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosMasterSlaveServerGroup.MasterSlaveBackendServersProperty"]]], result)
@builtins.property
def master_slave_server_group_name(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property masterSlaveServerGroupName: The name of the active/standby server group.'''
result = self._values.get("master_slave_server_group_name")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "MasterSlaveServerGroupProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class RosAccessControl(
_ros_cdk_core_7adfd82f.RosResource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-slb.RosAccessControl",
):
'''A ROS template type: ``ALIYUN::SLB::AccessControl``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["RosAccessControlProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
'''Create a new ``ALIYUN::SLB::AccessControl``.
:param scope: - scope in which this resource is defined.
:param id: - scoped id of the resource.
:param props: - resource properties.
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__847fc2f16e9a47f66c7243731f63c9f1d52310abd4e857246964461aaeee30dd)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@jsii.member(jsii_name="renderProperties")
def _render_properties(
self,
props: typing.Mapping[builtins.str, typing.Any],
) -> typing.Mapping[builtins.str, typing.Any]:
'''
:param props: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__9a8f42ca1e8a3aef91e81077f3b911b07e57d15342bcd7306df9ad0ee85f5c7f)
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))
@jsii.python.classproperty
@jsii.member(jsii_name="ROS_RESOURCE_TYPE_NAME")
def ROS_RESOURCE_TYPE_NAME(cls) -> builtins.str:
'''The resource type name for this resource class.'''
return typing.cast(builtins.str, jsii.sget(cls, "ROS_RESOURCE_TYPE_NAME"))
@builtins.property
@jsii.member(jsii_name="attrAclId")
def attr_acl_id(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: AclId: The ID of the access control list.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrAclId"))
@builtins.property
@jsii.member(jsii_name="rosProperties")
def _ros_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "rosProperties"))
@builtins.property
@jsii.member(jsii_name="aclName")
def acl_name(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: aclName: The name of the access control list.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "aclName"))
@acl_name.setter
def acl_name(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__31809101fe1427cb1d90e7dae97aa0ddf0f81f290d1d1661dae5d089feeb124a)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "aclName", value)
@builtins.property
@jsii.member(jsii_name="enableResourcePropertyConstraint")
def enable_resource_property_constraint(self) -> builtins.bool:
return typing.cast(builtins.bool, jsii.get(self, "enableResourcePropertyConstraint"))
@enable_resource_property_constraint.setter
def enable_resource_property_constraint(self, value: builtins.bool) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__9f5e93da08ab7c5f50ebe45e85a75f0dc5e103fd1b96f5f66103ed57e3f3f280)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "enableResourcePropertyConstraint", value)
@builtins.property
@jsii.member(jsii_name="aclEntries")
def acl_entries(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosAccessControl.AclEntriesProperty"]]]]:
'''
:Property: aclEntries: A list of acl entries. Each entry can be IP addresses or CIDR blocks. Max length: 50.
'''
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosAccessControl.AclEntriesProperty"]]]], jsii.get(self, "aclEntries"))
@acl_entries.setter
def acl_entries(
self,
value: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosAccessControl.AclEntriesProperty"]]]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__ed9c17cff27dd7b53e8049ea8480da359f2743634197701dc588421d9da957e9)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "aclEntries", value)
@builtins.property
@jsii.member(jsii_name="addressIpVersion")
def address_ip_version(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: addressIpVersion: IP version. Could be "ipv4" or "ipv6".
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "addressIpVersion"))
@address_ip_version.setter
def address_ip_version(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__099830a6a860a21255da2bbd16856d0e345a2e2802d479794f929caee4247f2b)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "addressIpVersion", value)
@builtins.property
@jsii.member(jsii_name="resourceGroupId")
def resource_group_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: resourceGroupId: Resource group id.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "resourceGroupId"))
@resource_group_id.setter
def resource_group_id(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__c403fe390927d5a9d737985410764d6eb0e62b874c79364aeb9cfff49d5a01f2)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "resourceGroupId", value)
@builtins.property
@jsii.member(jsii_name="tags")
def tags(self) -> typing.Optional[typing.List["RosAccessControl.TagsProperty"]]:
'''
:Property: tags: Tags to attach to instance. Max support 20 tags to add during create instance. Each tag with two properties Key and Value, and Key is required.
'''
return typing.cast(typing.Optional[typing.List["RosAccessControl.TagsProperty"]], jsii.get(self, "tags"))
@tags.setter
def tags(
self,
value: typing.Optional[typing.List["RosAccessControl.TagsProperty"]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__24d3ff97d12583710993d1cf63e4ecfc5a2bdad76612458b7d382df8886c357c)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "tags", value)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-slb.RosAccessControl.AclEntriesProperty",
jsii_struct_bases=[],
name_mapping={"entry": "entry", "comment": "comment"},
)
class AclEntriesProperty:
def __init__(
self,
*,
entry: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
comment: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''
:param entry:
:param comment:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__aed7ffb080eb23aa1da440e8612f4a40305b3f8d32414e3cc3aebaab292d98d3)
check_type(argname="argument entry", value=entry, expected_type=type_hints["entry"])
check_type(argname="argument comment", value=comment, expected_type=type_hints["comment"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"entry": entry,
}
if comment is not None:
self._values["comment"] = comment
@builtins.property
def entry(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: entry: IP addresses or CIDR blocks. For example: "10.0.0.1" or "192.168.0.0/16"
'''
result = self._values.get("entry")
assert result is not None, "Required property 'entry' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def comment(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: comment: Description of the entry.
'''
result = self._values.get("comment")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "AclEntriesProperty(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-slb.RosAccessControl.TagsProperty",
jsii_struct_bases=[],
name_mapping={"key": "key", "value": "value"},
)
class TagsProperty:
def __init__(
self,
*,
key: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''
:param key:
:param value:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__76dd5903d6dbcea456f6cf5e6c00a7ffba4ffa260101a98b451b041f5adfe028)
check_type(argname="argument key", value=key, expected_type=type_hints["key"])
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"key": key,
}
if value is not None:
self._values["value"] = value
@builtins.property
def key(self) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: key: undefined
'''
result = self._values.get("key")
assert result is not None, "Required property 'key' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def value(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: value: undefined
'''
result = self._values.get("value")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "TagsProperty(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-slb.RosAccessControlProps",
jsii_struct_bases=[],
name_mapping={
"acl_name": "aclName",
"acl_entries": "aclEntries",
"address_ip_version": "addressIpVersion",
"resource_group_id": "resourceGroupId",
"tags": "tags",
},
)
class RosAccessControlProps:
def __init__(
self,
*,
acl_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
acl_entries: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union[RosAccessControl.AclEntriesProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
address_ip_version: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
resource_group_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
tags: typing.Optional[typing.Sequence[typing.Union[RosAccessControl.TagsProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::SLB::AccessControl``.
:param acl_name:
:param acl_entries:
:param address_ip_version:
:param resource_group_id:
:param tags:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__fa6e5f0360b09d4efc644e3d658b7fd5e8a3c254825920954f2e53e1680c13ce)
check_type(argname="argument acl_name", value=acl_name, expected_type=type_hints["acl_name"])
check_type(argname="argument acl_entries", value=acl_entries, expected_type=type_hints["acl_entries"])
check_type(argname="argument address_ip_version", value=address_ip_version, expected_type=type_hints["address_ip_version"])
check_type(argname="argument resource_group_id", value=resource_group_id, expected_type=type_hints["resource_group_id"])
check_type(argname="argument tags", value=tags, expected_type=type_hints["tags"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"acl_name": acl_name,
}
if acl_entries is not None:
self._values["acl_entries"] = acl_entries
if address_ip_version is not None:
self._values["address_ip_version"] = address_ip_version
if resource_group_id is not None:
self._values["resource_group_id"] = resource_group_id
if tags is not None:
self._values["tags"] = tags
@builtins.property
def acl_name(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: aclName: The name of the access control list.
'''
result = self._values.get("acl_name")
assert result is not None, "Required property 'acl_name' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def acl_entries(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, RosAccessControl.AclEntriesProperty]]]]:
'''
:Property: aclEntries: A list of acl entries. Each entry can be IP addresses or CIDR blocks. Max length: 50.
'''
result = self._values.get("acl_entries")
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, RosAccessControl.AclEntriesProperty]]]], result)
@builtins.property
def address_ip_version(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: addressIpVersion: IP version. Could be "ipv4" or "ipv6".
'''
result = self._values.get("address_ip_version")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def resource_group_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: resourceGroupId: Resource group id.
'''
result = self._values.get("resource_group_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def tags(self) -> typing.Optional[typing.List[RosAccessControl.TagsProperty]]:
'''
:Property: tags: Tags to attach to instance. Max support 20 tags to add during create instance. Each tag with two properties Key and Value, and Key is required.
'''
result = self._values.get("tags")
return typing.cast(typing.Optional[typing.List[RosAccessControl.TagsProperty]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "RosAccessControlProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class RosBackendServerAttachment(
_ros_cdk_core_7adfd82f.RosResource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-slb.RosBackendServerAttachment",
):
'''A ROS template type: ``ALIYUN::SLB::BackendServerAttachment``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["RosBackendServerAttachmentProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
'''Create a new ``ALIYUN::SLB::BackendServerAttachment``.
:param scope: - scope in which this resource is defined.
:param id: - scoped id of the resource.
:param props: - resource properties.
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__1297df82ec7f888d361a67b9b70e86d801bb81be27637104e1445d8aa56413fa)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@jsii.member(jsii_name="renderProperties")
def _render_properties(
self,
props: typing.Mapping[builtins.str, typing.Any],
) -> typing.Mapping[builtins.str, typing.Any]:
'''
:param props: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__6ded85dafeb5f3ba0ee9b2a00a1b4bac91ba4ee2bec58b7c654e37e57d81f022)
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))
@jsii.python.classproperty
@jsii.member(jsii_name="ROS_RESOURCE_TYPE_NAME")
def ROS_RESOURCE_TYPE_NAME(cls) -> builtins.str:
'''The resource type name for this resource class.'''
return typing.cast(builtins.str, jsii.sget(cls, "ROS_RESOURCE_TYPE_NAME"))
@builtins.property
@jsii.member(jsii_name="attrBackendServers")
def attr_backend_servers(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: BackendServers: The collection of attached backend server.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrBackendServers"))
@builtins.property
@jsii.member(jsii_name="attrLoadBalancerId")
def attr_load_balancer_id(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: LoadBalancerId: The id of load balancer.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrLoadBalancerId"))
@builtins.property
@jsii.member(jsii_name="rosProperties")
def _ros_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "rosProperties"))
@builtins.property
@jsii.member(jsii_name="enableResourcePropertyConstraint")
def enable_resource_property_constraint(self) -> builtins.bool:
return typing.cast(builtins.bool, jsii.get(self, "enableResourcePropertyConstraint"))
@enable_resource_property_constraint.setter
def enable_resource_property_constraint(self, value: builtins.bool) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__5f617203d5362870f678f3e89a9c1993a6fa0bc363e7da6560b435f86ddcc5dc)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "enableResourcePropertyConstraint", value)
@builtins.property
@jsii.member(jsii_name="loadBalancerId")
def load_balancer_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: loadBalancerId: The id of load balancer.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "loadBalancerId"))
@load_balancer_id.setter
def load_balancer_id(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__1b3603fe811c59ee8b09724cfa746218c8cbed55c58775d5e15e4c9d84c2e50d)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "loadBalancerId", value)
@builtins.property
@jsii.member(jsii_name="backendServerList")
def backend_server_list(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]]:
'''
:Property: backendServerList: The comma delimited instance id list.If the property "BackendServers" is setting, this property will be ignored.
'''
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]], jsii.get(self, "backendServerList"))
@backend_server_list.setter
def backend_server_list(
self,
value: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__6b75fbb1826bf52c6902373a9c3b153e4237ac49658b54ab88364addbf6fec7a)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "backendServerList", value)
@builtins.property
@jsii.member(jsii_name="backendServers")
def backend_servers(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosBackendServerAttachment.BackendServersProperty"]]]]:
'''
:Property: backendServers: The list of ECS instance, which will attached to load balancer.
'''
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosBackendServerAttachment.BackendServersProperty"]]]], jsii.get(self, "backendServers"))
@backend_servers.setter
def backend_servers(
self,
value: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosBackendServerAttachment.BackendServersProperty"]]]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__9c2106b21fc641a5315dc6560db831d4b1f99453da01fcc499f8ad04cddfb27a)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "backendServers", value)
@builtins.property
@jsii.member(jsii_name="backendServerWeightList")
def backend_server_weight_list(
self,
) -> typing.Optional[typing.Union[typing.List[typing.Any], _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: backendServerWeightList: The comma delimited weight list. If no value specified will use 100. If the length is small than "BackendServerList", it will copy the last one to fill the array.If the property "BackendServers" is setting, this property will be ignored.
'''
return typing.cast(typing.Optional[typing.Union[typing.List[typing.Any], _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "backendServerWeightList"))
@backend_server_weight_list.setter
def backend_server_weight_list(
self,
value: typing.Optional[typing.Union[typing.List[typing.Any], _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__efb133348a6cca28b5641464ae207e3cf43a0d0d51d3c8cf7ca53012da111f7f)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "backendServerWeightList", value)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-slb.RosBackendServerAttachment.BackendServersProperty",
jsii_struct_bases=[],
name_mapping={
"server_id": "serverId",
"weight": "weight",
"description": "description",
"server_ip": "serverIp",
"type": "type",
},
)
class BackendServersProperty:
def __init__(
self,
*,
server_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
weight: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
description: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
server_ip: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''
:param server_id:
:param weight:
:param description:
:param server_ip:
:param type:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__6de1a2d97858568e4fa17a871129e58381ad9535ee19bca9d35ce805c8f23ad3)
check_type(argname="argument server_id", value=server_id, expected_type=type_hints["server_id"])
check_type(argname="argument weight", value=weight, expected_type=type_hints["weight"])
check_type(argname="argument description", value=description, expected_type=type_hints["description"])
check_type(argname="argument server_ip", value=server_ip, expected_type=type_hints["server_ip"])
check_type(argname="argument type", value=type, expected_type=type_hints["type"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"server_id": server_id,
"weight": weight,
}
if description is not None:
self._values["description"] = description
if server_ip is not None:
self._values["server_ip"] = server_ip
if type is not None:
self._values["type"] = type
@builtins.property
def server_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: serverId: Need one valid instance id. The instance status should running.
'''
result = self._values.get("server_id")
assert result is not None, "Required property 'server_id' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def weight(
self,
) -> typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: weight: The weight of backend server of load balancer. From 0 to 100, 0 means offline. Default is 100.
'''
result = self._values.get("weight")
assert result is not None, "Required property 'weight' is missing"
return typing.cast(typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def description(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: description: A description of the backend server.
'''
result = self._values.get("description")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def server_ip(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: serverIp: The IP of the instance.
'''
result = self._values.get("server_ip")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def type(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: type: The backend server type. Valid values:ecs: ECS instance (default)eni: Elastic Network Interface (ENI)
'''
result = self._values.get("type")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "BackendServersProperty(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-slb.RosBackendServerAttachmentProps",
jsii_struct_bases=[],
name_mapping={
"load_balancer_id": "loadBalancerId",
"backend_server_list": "backendServerList",
"backend_servers": "backendServers",
"backend_server_weight_list": "backendServerWeightList",
},
)
class RosBackendServerAttachmentProps:
def __init__(
self,
*,
load_balancer_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
backend_server_list: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]] = None,
backend_servers: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union[RosBackendServerAttachment.BackendServersProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
backend_server_weight_list: typing.Optional[typing.Union[typing.Sequence[typing.Any], _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::SLB::BackendServerAttachment``.
:param load_balancer_id:
:param backend_server_list:
:param backend_servers:
:param backend_server_weight_list:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__7e764e3cf866d942d6842a6fe7178f9cc8fc442ccc648cbb6fe59583f92e5134)
check_type(argname="argument load_balancer_id", value=load_balancer_id, expected_type=type_hints["load_balancer_id"])
check_type(argname="argument backend_server_list", value=backend_server_list, expected_type=type_hints["backend_server_list"])
check_type(argname="argument backend_servers", value=backend_servers, expected_type=type_hints["backend_servers"])
check_type(argname="argument backend_server_weight_list", value=backend_server_weight_list, expected_type=type_hints["backend_server_weight_list"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"load_balancer_id": load_balancer_id,
}
if backend_server_list is not None:
self._values["backend_server_list"] = backend_server_list
if backend_servers is not None:
self._values["backend_servers"] = backend_servers
if backend_server_weight_list is not None:
self._values["backend_server_weight_list"] = backend_server_weight_list
@builtins.property
def load_balancer_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: loadBalancerId: The id of load balancer.
'''
result = self._values.get("load_balancer_id")
assert result is not None, "Required property 'load_balancer_id' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def backend_server_list(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]]:
'''
:Property: backendServerList: The comma delimited instance id list.If the property "BackendServers" is setting, this property will be ignored.
'''
result = self._values.get("backend_server_list")
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]], result)
@builtins.property
def backend_servers(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, RosBackendServerAttachment.BackendServersProperty]]]]:
'''
:Property: backendServers: The list of ECS instance, which will attached to load balancer.
'''
result = self._values.get("backend_servers")
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, RosBackendServerAttachment.BackendServersProperty]]]], result)
@builtins.property
def backend_server_weight_list(
self,
) -> typing.Optional[typing.Union[typing.List[typing.Any], _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: backendServerWeightList: The comma delimited weight list. If no value specified will use 100. If the length is small than "BackendServerList", it will copy the last one to fill the array.If the property "BackendServers" is setting, this property will be ignored.
'''
result = self._values.get("backend_server_weight_list")
return typing.cast(typing.Optional[typing.Union[typing.List[typing.Any], _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "RosBackendServerAttachmentProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class RosBackendServerToVServerGroupAddition(
_ros_cdk_core_7adfd82f.RosResource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-slb.RosBackendServerToVServerGroupAddition",
):
'''A ROS template type: ``ALIYUN::SLB::BackendServerToVServerGroupAddition``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["RosBackendServerToVServerGroupAdditionProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
'''Create a new ``ALIYUN::SLB::BackendServerToVServerGroupAddition``.
:param scope: - scope in which this resource is defined.
:param id: - scoped id of the resource.
:param props: - resource properties.
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__593b28df9c0f0b456f530fc332714b320e70941a906ca8d117acb85ce6dd1c9d)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@jsii.member(jsii_name="renderProperties")
def _render_properties(
self,
props: typing.Mapping[builtins.str, typing.Any],
) -> typing.Mapping[builtins.str, typing.Any]:
'''
:param props: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__acf9d29063e3563a0077b19af37dda331f136d189ab60948da535af70c1fcab7)
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))
@jsii.python.classproperty
@jsii.member(jsii_name="ROS_RESOURCE_TYPE_NAME")
def ROS_RESOURCE_TYPE_NAME(cls) -> builtins.str:
'''The resource type name for this resource class.'''
return typing.cast(builtins.str, jsii.sget(cls, "ROS_RESOURCE_TYPE_NAME"))
@builtins.property
@jsii.member(jsii_name="attrVServerGroupId")
def attr_v_server_group_id(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: VServerGroupId: The ID of virtual server group.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrVServerGroupId"))
@builtins.property
@jsii.member(jsii_name="rosProperties")
def _ros_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "rosProperties"))
@builtins.property
@jsii.member(jsii_name="backendServers")
def backend_servers(
self,
) -> typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosBackendServerToVServerGroupAddition.BackendServersProperty"]]]:
'''
:Property: backendServers: The list of a combination of ECS Instance-Port-Weight.Same ecs instance with different port is allowed, but same ecs instance with same port isn't.
'''
return typing.cast(typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosBackendServerToVServerGroupAddition.BackendServersProperty"]]], jsii.get(self, "backendServers"))
@backend_servers.setter
def backend_servers(
self,
value: typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosBackendServerToVServerGroupAddition.BackendServersProperty"]]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__b3f7f1e0b5c61bef9fe316f8d8e0b911dabda91047999d58e251bde716992246)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "backendServers", value)
@builtins.property
@jsii.member(jsii_name="enableResourcePropertyConstraint")
def enable_resource_property_constraint(self) -> builtins.bool:
return typing.cast(builtins.bool, jsii.get(self, "enableResourcePropertyConstraint"))
@enable_resource_property_constraint.setter
def enable_resource_property_constraint(self, value: builtins.bool) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__8f9cd633291cc4535208b3b886f2e3d4a2dae70bd666d0d8454df8702bb274ab)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "enableResourcePropertyConstraint", value)
@builtins.property
@jsii.member(jsii_name="vServerGroupId")
def v_server_group_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: vServerGroupId: The ID of virtual server group.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "vServerGroupId"))
@v_server_group_id.setter
def v_server_group_id(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__33efd890e1f47cd176201389153fe678326b23ad2c238220a12f775ac9a74ded)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "vServerGroupId", value)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-slb.RosBackendServerToVServerGroupAddition.BackendServersProperty",
jsii_struct_bases=[],
name_mapping={
"port": "port",
"server_id": "serverId",
"description": "description",
"server_ip": "serverIp",
"type": "type",
"weight": "weight",
},
)
class BackendServersProperty:
def __init__(
self,
*,
port: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
server_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
description: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
server_ip: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
weight: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''
:param port:
:param server_id:
:param description:
:param server_ip:
:param type:
:param weight:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__52b88569c0f1e1467cb1ea14550e40a91c94d852b52dbfa4885def5151e3c4ee)
check_type(argname="argument port", value=port, expected_type=type_hints["port"])
check_type(argname="argument server_id", value=server_id, expected_type=type_hints["server_id"])
check_type(argname="argument description", value=description, expected_type=type_hints["description"])
check_type(argname="argument server_ip", value=server_ip, expected_type=type_hints["server_ip"])
check_type(argname="argument type", value=type, expected_type=type_hints["type"])
check_type(argname="argument weight", value=weight, expected_type=type_hints["weight"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"port": port,
"server_id": server_id,
}
if description is not None:
self._values["description"] = description
if server_ip is not None:
self._values["server_ip"] = server_ip
if type is not None:
self._values["type"] = type
if weight is not None:
self._values["weight"] = weight
@builtins.property
def port(self) -> typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: port: The port of backend server. From 1 to 65535.
'''
result = self._values.get("port")
assert result is not None, "Required property 'port' is missing"
return typing.cast(typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def server_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: serverId: The ID of the backend server. You can specify the ID of an Elastic Compute Service (ECS) instance,an elastic network interface (ENI) or elastic container instance (ECI).
'''
result = self._values.get("server_id")
assert result is not None, "Required property 'server_id' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def description(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: description: The description of the backend server. The description must be 1 to 80 characters in length, and can contain letters, digits, hyphens (-), forward slashes (/), periods (.), and underscores (_).
'''
result = self._values.get("description")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def server_ip(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: serverIp: The IP address of an ECS instance, ENI or ECI
'''
result = self._values.get("server_ip")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def type(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
type: The instance type of the backend server. This parameter must be set to a string. Valid values:
ecs: ECS instance. This is the default value.
eni: ENI.
eci: ECI.
'''
result = self._values.get("type")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def weight(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: weight: The weight of backend server of load balancer. From 0 to 100, 0 means offline. Default is 100.
'''
result = self._values.get("weight")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "BackendServersProperty(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-slb.RosBackendServerToVServerGroupAdditionProps",
jsii_struct_bases=[],
name_mapping={
"backend_servers": "backendServers",
"v_server_group_id": "vServerGroupId",
},
)
class RosBackendServerToVServerGroupAdditionProps:
def __init__(
self,
*,
backend_servers: typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union[RosBackendServerToVServerGroupAddition.BackendServersProperty, typing.Dict[builtins.str, typing.Any]]]]],
v_server_group_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
'''Properties for defining a ``ALIYUN::SLB::BackendServerToVServerGroupAddition``.
:param backend_servers:
:param v_server_group_id:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__d4e0325e11e8bc298a9d48fc3f85253f3a4a2c3ea862a6ea71d7e7f360d9f3bb)
check_type(argname="argument backend_servers", value=backend_servers, expected_type=type_hints["backend_servers"])
check_type(argname="argument v_server_group_id", value=v_server_group_id, expected_type=type_hints["v_server_group_id"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"backend_servers": backend_servers,
"v_server_group_id": v_server_group_id,
}
@builtins.property
def backend_servers(
self,
) -> typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, RosBackendServerToVServerGroupAddition.BackendServersProperty]]]:
'''
:Property: backendServers: The list of a combination of ECS Instance-Port-Weight.Same ecs instance with different port is allowed, but same ecs instance with same port isn't.
'''
result = self._values.get("backend_servers")
assert result is not None, "Required property 'backend_servers' is missing"
return typing.cast(typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, RosBackendServerToVServerGroupAddition.BackendServersProperty]]], result)
@builtins.property
def v_server_group_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: vServerGroupId: The ID of virtual server group.
'''
result = self._values.get("v_server_group_id")
assert result is not None, "Required property 'v_server_group_id' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "RosBackendServerToVServerGroupAdditionProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class RosCertificate(
_ros_cdk_core_7adfd82f.RosResource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-slb.RosCertificate",
):
'''A ROS template type: ``ALIYUN::SLB::Certificate``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["RosCertificateProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
'''Create a new ``ALIYUN::SLB::Certificate``.
:param scope: - scope in which this resource is defined.
:param id: - scoped id of the resource.
:param props: - resource properties.
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__f7c79b67c543726d7ae20d7245f9264f6136fcf58b5b726d9eea181b77511c99)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@jsii.member(jsii_name="renderProperties")
def _render_properties(
self,
props: typing.Mapping[builtins.str, typing.Any],
) -> typing.Mapping[builtins.str, typing.Any]:
'''
:param props: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__525d8ef886383b275baed218f264f4c90bad610ac8126945bb07af65b068354a)
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))
@jsii.python.classproperty
@jsii.member(jsii_name="ROS_RESOURCE_TYPE_NAME")
def ROS_RESOURCE_TYPE_NAME(cls) -> builtins.str:
'''The resource type name for this resource class.'''
return typing.cast(builtins.str, jsii.sget(cls, "ROS_RESOURCE_TYPE_NAME"))
@builtins.property
@jsii.member(jsii_name="attrCertificateId")
def attr_certificate_id(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: CertificateId: The ID of the certificate.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrCertificateId"))
@builtins.property
@jsii.member(jsii_name="attrFingerprint")
def attr_fingerprint(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: Fingerprint: The fingerprint of the certificate.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrFingerprint"))
@builtins.property
@jsii.member(jsii_name="rosProperties")
def _ros_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "rosProperties"))
@builtins.property
@jsii.member(jsii_name="enableResourcePropertyConstraint")
def enable_resource_property_constraint(self) -> builtins.bool:
return typing.cast(builtins.bool, jsii.get(self, "enableResourcePropertyConstraint"))
@enable_resource_property_constraint.setter
def enable_resource_property_constraint(self, value: builtins.bool) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__6474487ec4158c05182b85939e66b48a4b1602b7f78a92e13034ce3b1af0e078)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "enableResourcePropertyConstraint", value)
@builtins.property
@jsii.member(jsii_name="aliCloudCertificateId")
def ali_cloud_certificate_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: aliCloudCertificateId: The ID of the Alibaba Cloud certificate.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "aliCloudCertificateId"))
@ali_cloud_certificate_id.setter
def ali_cloud_certificate_id(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__a9cb3731fee8e80d3256db508b818c4477e04bb713d12cd3efd13dd57557a564)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "aliCloudCertificateId", value)
@builtins.property
@jsii.member(jsii_name="aliCloudCertificateName")
def ali_cloud_certificate_name(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: aliCloudCertificateName: The name of the Alibaba Cloud certificate.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "aliCloudCertificateName"))
@ali_cloud_certificate_name.setter
def ali_cloud_certificate_name(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__737731f6acdc011aa78640ef2eac75013ecf4eee218b8c3984589c6e9119b8a6)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "aliCloudCertificateName", value)
@builtins.property
@jsii.member(jsii_name="certificate")
def certificate(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: certificate: The content of the certificate public key.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "certificate"))
@certificate.setter
def certificate(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__e12658e10510fa209c5d684182982e34f99a061f37e821468cfd0656b38b1a0a)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "certificate", value)
@builtins.property
@jsii.member(jsii_name="certificateName")
def certificate_name(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: certificateName: The name of the certificate.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "certificateName"))
@certificate_name.setter
def certificate_name(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__5292361599bc615e2c552e3ef23d8c44b0909bb6d569db3bc123da6a048e6a10)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "certificateName", value)
@builtins.property
@jsii.member(jsii_name="certificateType")
def certificate_type(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: certificateType: The type of the certificate.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "certificateType"))
@certificate_type.setter
def certificate_type(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__b0b0954c32af9b710f7edbf5af0357141bb728d91d12e9b91aae6ead156c62a3)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "certificateType", value)
@builtins.property
@jsii.member(jsii_name="privateKey")
def private_key(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: privateKey: The private key.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "privateKey"))
@private_key.setter
def private_key(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__b96b2b66b6694d2bb06b8ae1217200216b7b91587de424e5344409bf362c3bbb)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "privateKey", value)
@builtins.property
@jsii.member(jsii_name="resourceGroupId")
def resource_group_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: resourceGroupId: Resource group id.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "resourceGroupId"))
@resource_group_id.setter
def resource_group_id(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__b9a0d718e443a2ac70fe46e47dd895acea53962559343f1098918b09a3085da6)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "resourceGroupId", value)
@builtins.property
@jsii.member(jsii_name="tags")
def tags(self) -> typing.Optional[typing.List["RosCertificate.TagsProperty"]]:
'''
:Property: tags: Tags to attach to instance. Max support 20 tags to add during create instance. Each tag with two properties Key and Value, and Key is required.
'''
return typing.cast(typing.Optional[typing.List["RosCertificate.TagsProperty"]], jsii.get(self, "tags"))
@tags.setter
def tags(
self,
value: typing.Optional[typing.List["RosCertificate.TagsProperty"]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__4cfeca3ea70eacfadde311116975e863ba1c933f4b6da7c06607c9cd9c77dc69)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "tags", value)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-slb.RosCertificate.TagsProperty",
jsii_struct_bases=[],
name_mapping={"key": "key", "value": "value"},
)
class TagsProperty:
def __init__(
self,
*,
key: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''
:param key:
:param value:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__4a0778ef6490b87318c4c8193b11347468e8262447f6da1bfdd21268a6283385)
check_type(argname="argument key", value=key, expected_type=type_hints["key"])
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"key": key,
}
if value is not None:
self._values["value"] = value
@builtins.property
def key(self) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: key: undefined
'''
result = self._values.get("key")
assert result is not None, "Required property 'key' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def value(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: value: undefined
'''
result = self._values.get("value")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "TagsProperty(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-slb.RosCertificateProps",
jsii_struct_bases=[],
name_mapping={
"ali_cloud_certificate_id": "aliCloudCertificateId",
"ali_cloud_certificate_name": "aliCloudCertificateName",
"certificate": "certificate",
"certificate_name": "certificateName",
"certificate_type": "certificateType",
"private_key": "privateKey",
"resource_group_id": "resourceGroupId",
"tags": "tags",
},
)
class RosCertificateProps:
def __init__(
self,
*,
ali_cloud_certificate_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
ali_cloud_certificate_name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
certificate: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
certificate_name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
certificate_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
private_key: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
resource_group_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
tags: typing.Optional[typing.Sequence[typing.Union[RosCertificate.TagsProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::SLB::Certificate``.
:param ali_cloud_certificate_id:
:param ali_cloud_certificate_name:
:param certificate:
:param certificate_name:
:param certificate_type:
:param private_key:
:param resource_group_id:
:param tags:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__7e01ca041985f2287c83ba2b5708b2fa9878f085ed7bc08d083e986dd7c2b462)
check_type(argname="argument ali_cloud_certificate_id", value=ali_cloud_certificate_id, expected_type=type_hints["ali_cloud_certificate_id"])
check_type(argname="argument ali_cloud_certificate_name", value=ali_cloud_certificate_name, expected_type=type_hints["ali_cloud_certificate_name"])
check_type(argname="argument certificate", value=certificate, expected_type=type_hints["certificate"])
check_type(argname="argument certificate_name", value=certificate_name, expected_type=type_hints["certificate_name"])
check_type(argname="argument certificate_type", value=certificate_type, expected_type=type_hints["certificate_type"])
check_type(argname="argument private_key", value=private_key, expected_type=type_hints["private_key"])
check_type(argname="argument resource_group_id", value=resource_group_id, expected_type=type_hints["resource_group_id"])
check_type(argname="argument tags", value=tags, expected_type=type_hints["tags"])
self._values: typing.Dict[builtins.str, typing.Any] = {}
if ali_cloud_certificate_id is not None:
self._values["ali_cloud_certificate_id"] = ali_cloud_certificate_id
if ali_cloud_certificate_name is not None:
self._values["ali_cloud_certificate_name"] = ali_cloud_certificate_name
if certificate is not None:
self._values["certificate"] = certificate
if certificate_name is not None:
self._values["certificate_name"] = certificate_name
if certificate_type is not None:
self._values["certificate_type"] = certificate_type
if private_key is not None:
self._values["private_key"] = private_key
if resource_group_id is not None:
self._values["resource_group_id"] = resource_group_id
if tags is not None:
self._values["tags"] = tags
@builtins.property
def ali_cloud_certificate_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: aliCloudCertificateId: The ID of the Alibaba Cloud certificate.
'''
result = self._values.get("ali_cloud_certificate_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def ali_cloud_certificate_name(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: aliCloudCertificateName: The name of the Alibaba Cloud certificate.
'''
result = self._values.get("ali_cloud_certificate_name")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def certificate(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: certificate: The content of the certificate public key.
'''
result = self._values.get("certificate")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def certificate_name(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: certificateName: The name of the certificate.
'''
result = self._values.get("certificate_name")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def certificate_type(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: certificateType: The type of the certificate.
'''
result = self._values.get("certificate_type")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def private_key(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: privateKey: The private key.
'''
result = self._values.get("private_key")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def resource_group_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: resourceGroupId: Resource group id.
'''
result = self._values.get("resource_group_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def tags(self) -> typing.Optional[typing.List[RosCertificate.TagsProperty]]:
'''
:Property: tags: Tags to attach to instance. Max support 20 tags to add during create instance. Each tag with two properties Key and Value, and Key is required.
'''
result = self._values.get("tags")
return typing.cast(typing.Optional[typing.List[RosCertificate.TagsProperty]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "RosCertificateProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class RosDomainExtension(
_ros_cdk_core_7adfd82f.RosResource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-slb.RosDomainExtension",
):
'''A ROS template type: ``ALIYUN::SLB::DomainExtension``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["RosDomainExtensionProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
'''Create a new ``ALIYUN::SLB::DomainExtension``.
:param scope: - scope in which this resource is defined.
:param id: - scoped id of the resource.
:param props: - resource properties.
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__7ae95996ee1773356b83e45d8a8d75ac575ab3678422c9d12f9378859a935edf)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@jsii.member(jsii_name="renderProperties")
def _render_properties(
self,
props: typing.Mapping[builtins.str, typing.Any],
) -> typing.Mapping[builtins.str, typing.Any]:
'''
:param props: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__983c9ce0930c5c51ca60c5f28b59be18a36b463de725860cd7ab65530338832b)
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))
@jsii.python.classproperty
@jsii.member(jsii_name="ROS_RESOURCE_TYPE_NAME")
def ROS_RESOURCE_TYPE_NAME(cls) -> builtins.str:
'''The resource type name for this resource class.'''
return typing.cast(builtins.str, jsii.sget(cls, "ROS_RESOURCE_TYPE_NAME"))
@builtins.property
@jsii.member(jsii_name="attrDomainExtensionId")
def attr_domain_extension_id(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: DomainExtensionId: The ID of the created domain name extension.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrDomainExtensionId"))
@builtins.property
@jsii.member(jsii_name="attrListenerPort")
def attr_listener_port(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute:
ListenerPort: The front-end HTTPS listener port of the Server Load Balancer instance. Valid value:
1-65535
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrListenerPort"))
@builtins.property
@jsii.member(jsii_name="rosProperties")
def _ros_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "rosProperties"))
@builtins.property
@jsii.member(jsii_name="domain")
def domain(self) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: domain: The domain name.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "domain"))
@domain.setter
def domain(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__69708cdf696a442f4a9182443e89b1dc19f7b2e9453658bb531b4d6cde2e490a)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "domain", value)
@builtins.property
@jsii.member(jsii_name="enableResourcePropertyConstraint")
def enable_resource_property_constraint(self) -> builtins.bool:
return typing.cast(builtins.bool, jsii.get(self, "enableResourcePropertyConstraint"))
@enable_resource_property_constraint.setter
def enable_resource_property_constraint(self, value: builtins.bool) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__8b46d288e43e152eccb96f29313a9ed9ec4a3da61aedfbe028a8bfee8636a18a)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "enableResourcePropertyConstraint", value)
@builtins.property
@jsii.member(jsii_name="listenerPort")
def listener_port(
self,
) -> typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
listenerPort: The front-end HTTPS listener port of the Server Load Balancer instance. Valid value:
1-65535
'''
return typing.cast(typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "listenerPort"))
@listener_port.setter
def listener_port(
self,
value: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__50f17f12c9d459b5e2323f34ed9270145a016e6c710549107f2f5e2f6247f741)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "listenerPort", value)
@builtins.property
@jsii.member(jsii_name="loadBalancerId")
def load_balancer_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: loadBalancerId: The ID of Server Load Balancer instance.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "loadBalancerId"))
@load_balancer_id.setter
def load_balancer_id(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__46a1b8ce5e00d299225dd665e9eab7bc2f9ca6e0f8cc7f00378e923ba09a5a92)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "loadBalancerId", value)
@builtins.property
@jsii.member(jsii_name="serverCertificateId")
def server_certificate_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: serverCertificateId: The ID of the certificate corresponding to the domain name.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "serverCertificateId"))
@server_certificate_id.setter
def server_certificate_id(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__b2d6d37707d7c5593cefaed35d4bf3497351b57892605803aaff478416b6f09b)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "serverCertificateId", value)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-slb.RosDomainExtensionProps",
jsii_struct_bases=[],
name_mapping={
"domain": "domain",
"listener_port": "listenerPort",
"load_balancer_id": "loadBalancerId",
"server_certificate_id": "serverCertificateId",
},
)
class RosDomainExtensionProps:
def __init__(
self,
*,
domain: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
listener_port: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
load_balancer_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
server_certificate_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
'''Properties for defining a ``ALIYUN::SLB::DomainExtension``.
:param domain:
:param listener_port:
:param load_balancer_id:
:param server_certificate_id:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__5910ec9bc329b736bc2ff762a3fcd91f184bf32fc1a8f5a3871e31d8d0f4d478)
check_type(argname="argument domain", value=domain, expected_type=type_hints["domain"])
check_type(argname="argument listener_port", value=listener_port, expected_type=type_hints["listener_port"])
check_type(argname="argument load_balancer_id", value=load_balancer_id, expected_type=type_hints["load_balancer_id"])
check_type(argname="argument server_certificate_id", value=server_certificate_id, expected_type=type_hints["server_certificate_id"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"domain": domain,
"listener_port": listener_port,
"load_balancer_id": load_balancer_id,
"server_certificate_id": server_certificate_id,
}
@builtins.property
def domain(self) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: domain: The domain name.
'''
result = self._values.get("domain")
assert result is not None, "Required property 'domain' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def listener_port(
self,
) -> typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
listenerPort: The front-end HTTPS listener port of the Server Load Balancer instance. Valid value:
1-65535
'''
result = self._values.get("listener_port")
assert result is not None, "Required property 'listener_port' is missing"
return typing.cast(typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def load_balancer_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: loadBalancerId: The ID of Server Load Balancer instance.
'''
result = self._values.get("load_balancer_id")
assert result is not None, "Required property 'load_balancer_id' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def server_certificate_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: serverCertificateId: The ID of the certificate corresponding to the domain name.
'''
result = self._values.get("server_certificate_id")
assert result is not None, "Required property 'server_certificate_id' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "RosDomainExtensionProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class RosListener(
_ros_cdk_core_7adfd82f.RosResource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-slb.RosListener",
):
'''A ROS template type: ``ALIYUN::SLB::Listener``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["RosListenerProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
'''Create a new ``ALIYUN::SLB::Listener``.
:param scope: - scope in which this resource is defined.
:param id: - scoped id of the resource.
:param props: - resource properties.
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__751bc5618e98ab72ea98d725a26bfbe9060ade092357018dbbb0600a3865c503)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@jsii.member(jsii_name="renderProperties")
def _render_properties(
self,
props: typing.Mapping[builtins.str, typing.Any],
) -> typing.Mapping[builtins.str, typing.Any]:
'''
:param props: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__d6e9c154bda923d441b1e6a47fea30053a4d787a072f2f7847d877ab72beee1a)
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))
@jsii.python.classproperty
@jsii.member(jsii_name="ROS_RESOURCE_TYPE_NAME")
def ROS_RESOURCE_TYPE_NAME(cls) -> builtins.str:
'''The resource type name for this resource class.'''
return typing.cast(builtins.str, jsii.sget(cls, "ROS_RESOURCE_TYPE_NAME"))
@builtins.property
@jsii.member(jsii_name="attrListenerPortsAndProtocol")
def attr_listener_ports_and_protocol(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: ListenerPortsAndProtocol: The collection of listener.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrListenerPortsAndProtocol"))
@builtins.property
@jsii.member(jsii_name="attrLoadBalancerId")
def attr_load_balancer_id(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: LoadBalancerId: The id of load balancer
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrLoadBalancerId"))
@builtins.property
@jsii.member(jsii_name="rosProperties")
def _ros_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "rosProperties"))
@builtins.property
@jsii.member(jsii_name="bandwidth")
def bandwidth(
self,
) -> typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: bandwidth: The bandwidth of network, unit in Mbps(Million bits per second). If the specified load balancer with "LOAD_BALANCE_ID" is charged by "paybybandwidth" and is created in classic network, each Listener's bandwidth must be greater than 0 and the sum of all of its Listeners' bandwidth can't be greater than the bandwidth of the load balancer.
'''
return typing.cast(typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "bandwidth"))
@bandwidth.setter
def bandwidth(
self,
value: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__080364c22d736e7e6c8aca87febbd9115c4b16a7d0117a550112f4a12287b62a)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "bandwidth", value)
@builtins.property
@jsii.member(jsii_name="enableResourcePropertyConstraint")
def enable_resource_property_constraint(self) -> builtins.bool:
return typing.cast(builtins.bool, jsii.get(self, "enableResourcePropertyConstraint"))
@enable_resource_property_constraint.setter
def enable_resource_property_constraint(self, value: builtins.bool) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__a171a54669f1918b4ce2397ceece399eca0d3c7b32913b1c5e7c5724c510a757)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "enableResourcePropertyConstraint", value)
@builtins.property
@jsii.member(jsii_name="listenerPort")
def listener_port(
self,
) -> typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: listenerPort: Port for front listener. Range from 0 to 65535.
'''
return typing.cast(typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "listenerPort"))
@listener_port.setter
def listener_port(
self,
value: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__5959eb784c01f16f68c991941bd11a2c7fb7dd2ee22dfcdf65e54f8524db3016)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "listenerPort", value)
@builtins.property
@jsii.member(jsii_name="loadBalancerId")
def load_balancer_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: loadBalancerId: The id of load balancer to create listener.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "loadBalancerId"))
@load_balancer_id.setter
def load_balancer_id(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__3fa1e2b77d36d34cf2afa826bf1089142152cb6937dc950d299f834b43e41316)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "loadBalancerId", value)
@builtins.property
@jsii.member(jsii_name="protocol")
def protocol(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: protocol: The load balancer transport protocol to use for routing: http, https, tcp, or udp.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "protocol"))
@protocol.setter
def protocol(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__d838f8ed8ceb88352442206a401a683577754f7c757665484ff1387c652a162d)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "protocol", value)
@builtins.property
@jsii.member(jsii_name="aclId")
def acl_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
aclId: The ID of the access control list associated with the listener to be created.
If the value of the AclStatus parameter is on, this parameter is required.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "aclId"))
@acl_id.setter
def acl_id(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__c72336f8d5cf733ba925086b1a91f938181f6d036ed5fe3cbd7ca2e1c29ecbd9)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "aclId", value)
@builtins.property
@jsii.member(jsii_name="aclStatus")
def acl_status(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
aclStatus: Indicates whether to enable access control.
Valid values: on | off. Default value: off
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "aclStatus"))
@acl_status.setter
def acl_status(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__8b186ff0000b32e6e03dd28ebefa20e632c39189233127355c97ca6711f38742)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "aclStatus", value)
@builtins.property
@jsii.member(jsii_name="aclType")
def acl_type(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
aclType: The access control type:
- white: Indicates a whitelist. Only requests from IP addresses or CIDR blocks in the selected access control lists are forwarded. This applies to scenarios in which an application only allows access from specific IP addresses.
Enabling a whitelist poses some risks to your services.
After a whitelist is enabled, only the IP addresses in the list can access the listener.
If you enable a whitelist without adding any IP addresses in the list, no requests are forwarded.
- black: Indicates a blacklist. Requests from IP addresses or CIDR blocks in the selected access control lists are not forwarded (that is, they are blocked). This applies to scenarios in which an application only denies access from specific IP addresses.
If you enable a blacklist without adding any IP addresses in the list, all requests are forwarded.
If the value of the AclStatus parameter is on, this parameter is required.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "aclType"))
@acl_type.setter
def acl_type(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__fdd15311d5c389793d5d0effdf35aaae33d0bb0bd32055097b041581bddfcf4c)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "aclType", value)
@builtins.property
@jsii.member(jsii_name="backendServerPort")
def backend_server_port(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: backendServerPort: Backend server can listen on ports from 1 to 65535.
'''
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "backendServerPort"))
@backend_server_port.setter
def backend_server_port(
self,
value: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__dcdff56130779b973ce4664c24af785a0c58c11126410eb4deeca93cfc769f5f)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "backendServerPort", value)
@builtins.property
@jsii.member(jsii_name="caCertificateId")
def ca_certificate_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: caCertificateId: CA server certificate id, for https listener only.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "caCertificateId"))
@ca_certificate_id.setter
def ca_certificate_id(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__1d65999633df7706029659714ddfa3b5c9ff0f2faec6ca27476c75949de1c662)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "caCertificateId", value)
@builtins.property
@jsii.member(jsii_name="description")
def description(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: description: The description of the listener.It must be 1 to 80 characters in length and can contain letters, digits, hyphens (-), forward slashes (/), periods (.), and underscores (_). Chinese characters are supported.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "description"))
@description.setter
def description(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__deacde491ff1e99a8e6e95efadf83c246edc449f2a8fd8ad1be4d958dbcb1954)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "description", value)
@builtins.property
@jsii.member(jsii_name="enableHttp2")
def enable_http2(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
enableHttp2: Specifies whether to use HTTP/2. It takes effect when Protocol=https. Valid values:
on: yes
off: no
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "enableHttp2"))
@enable_http2.setter
def enable_http2(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__57ecd60cf3ce01487939bba9d178f20c5cd80bbe9e5d5d5b4652abb9f3382374)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "enableHttp2", value)
@builtins.property
@jsii.member(jsii_name="gzip")
def gzip(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
gzip: Specifies whether to enable Gzip compression to compress specific types of files. Valid values:
on (default): yes
off: no
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "gzip"))
@gzip.setter
def gzip(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__b95d2e00bd7c68a783df86ab409ae9dee2d48f12290cdb969b4d0080f74cb554)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "gzip", value)
@builtins.property
@jsii.member(jsii_name="healthCheck")
def health_check(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosListener.HealthCheckProperty"]]:
'''
:Property: healthCheck: The properties of health checking setting.
'''
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosListener.HealthCheckProperty"]], jsii.get(self, "healthCheck"))
@health_check.setter
def health_check(
self,
value: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosListener.HealthCheckProperty"]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__235939a8a3a75a15579937a6a76b158b410c9551955c832aa18014fadbf3aa25)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "healthCheck", value)
@builtins.property
@jsii.member(jsii_name="httpConfig")
def http_config(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosListener.HttpConfigProperty"]]:
'''
:Property: httpConfig: Config for http protocol.
'''
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosListener.HttpConfigProperty"]], jsii.get(self, "httpConfig"))
@http_config.setter
def http_config(
self,
value: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosListener.HttpConfigProperty"]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__d8e87688141d6935d6a699efa054cbd09127c9e3f05eefbf81bd16a3b5810a0f)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "httpConfig", value)
@builtins.property
@jsii.member(jsii_name="idleTimeout")
def idle_timeout(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: idleTimeout: Specify the idle connection timeout in seconds. Valid value: 1-60 If no request is received during the specified timeout period, Server Load Balancer will temporarily terminate the connection and restart the connection when the next request comes.
'''
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "idleTimeout"))
@idle_timeout.setter
def idle_timeout(
self,
value: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__d42590f52bb7a7352ba27e22ed8aee699d78e72a399fb261e45e1ce4242d0e25)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "idleTimeout", value)
@builtins.property
@jsii.member(jsii_name="masterSlaveServerGroupId")
def master_slave_server_group_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: masterSlaveServerGroupId: The id of the MasterSlaveServerGroup which use in listener.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "masterSlaveServerGroupId"))
@master_slave_server_group_id.setter
def master_slave_server_group_id(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__84cb2bd88e393c16ba8875a98530c0a5022f35e314b9c2a4a0e0a8e6e157eec4)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "masterSlaveServerGroupId", value)
@builtins.property
@jsii.member(jsii_name="persistence")
def persistence(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosListener.PersistenceProperty"]]:
'''
:Property: persistence: The properties of persistence.
'''
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosListener.PersistenceProperty"]], jsii.get(self, "persistence"))
@persistence.setter
def persistence(
self,
value: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosListener.PersistenceProperty"]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__8118c2c75a8f04d376feb26c8ba931f384ae8ee4f0006bde4b2ffeeee22c26f3)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "persistence", value)
@builtins.property
@jsii.member(jsii_name="portRange")
def port_range(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosListener.PortRangeProperty"]]]]:
'''
:Property: portRange: Port range, only supports TCP or UDP listener. ListenerPort should be 0 when PortRange is specified.
'''
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosListener.PortRangeProperty"]]]], jsii.get(self, "portRange"))
@port_range.setter
def port_range(
self,
value: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosListener.PortRangeProperty"]]]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__c9ce8f2fe70c315990ecd31b3fa74bc1f50dc23e42905a521bf291b8b58944b1)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "portRange", value)
@builtins.property
@jsii.member(jsii_name="requestTimeout")
def request_timeout(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: requestTimeout: Specify the request timeout in seconds. Valid value: 1-180 If no response is received from the backend server during the specified timeout period, Server Load Balancer will stop waiting and send an HTTP 504 error to the client.
'''
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "requestTimeout"))
@request_timeout.setter
def request_timeout(
self,
value: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__0edbf23cd8f1c622ffeb49b11ff06347a3431fb76f63c81a5993ba83590e1b34)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "requestTimeout", value)
@builtins.property
@jsii.member(jsii_name="scheduler")
def scheduler(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
scheduler: The scheduling algorithm. Valid values:
wrr: Backend servers that have higher weights receive more requests than those that have lower weights.
wlc: Requests are distributed based on the combination of the weights and connections to backend servers. If two backend servers have the same weight, the backend server that has fewer connections receives more requests.
rr: Requests are distributed to backend servers in sequence.
sch: specifies consistent hashing that is based on source IP addresses. Requests from the same source IP address are distributed to the same backend server.
tch: specifies consistent hashing that is based on four factors: source IP address, destination IP address, source port number, and destination port number. Requests that contain the same preceding information are distributed to the same backend server.
Default: wrr
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "scheduler"))
@scheduler.setter
def scheduler(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__0726316d42070a5bf5be5a8d44981d13a658c112548bdfd7fe00e8fbdd8419e9)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "scheduler", value)
@builtins.property
@jsii.member(jsii_name="serverCertificateId")
def server_certificate_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: serverCertificateId: Server certificate id, for https listener only, this properties is required.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "serverCertificateId"))
@server_certificate_id.setter
def server_certificate_id(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__f9afdacf8f1db95ba480b05b3b643774056198c1c29d2ab2ca2b5da5d66a1ba2)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "serverCertificateId", value)
@builtins.property
@jsii.member(jsii_name="startListener")
def start_listener(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: startListener: Whether start listener after listener created. Default True.
'''
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "startListener"))
@start_listener.setter
def start_listener(
self,
value: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__f33b607b770417212837e09fce7f0834cc6092a9f761754fe089504c9654b7bf)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "startListener", value)
@builtins.property
@jsii.member(jsii_name="tlsCipherPolicy")
def tls_cipher_policy(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: tlsCipherPolicy: The Transport Layer Security (TLS) security policy. Each security policy contains TLS protocol versions and cipher suites available for HTTPS. It takes effect when Protocol=https.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "tlsCipherPolicy"))
@tls_cipher_policy.setter
def tls_cipher_policy(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__d38354b4e8158a49d7d4418844c722e178634b61a40683177cd1230b47ce4fa3)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "tlsCipherPolicy", value)
@builtins.property
@jsii.member(jsii_name="vServerGroupId")
def v_server_group_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: vServerGroupId: The id of the VServerGroup which use in listener.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "vServerGroupId"))
@v_server_group_id.setter
def v_server_group_id(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__9dedd683a1c4602a3398684772ed8d510c2efc312b6dee42eb4e62de0d7f6456)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "vServerGroupId", value)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-slb.RosListener.HealthCheckProperty",
jsii_struct_bases=[],
name_mapping={
"domain": "domain",
"health_check_method": "healthCheckMethod",
"health_check_type": "healthCheckType",
"healthy_threshold": "healthyThreshold",
"http_code": "httpCode",
"interval": "interval",
"port": "port",
"switch": "switch",
"timeout": "timeout",
"unhealthy_threshold": "unhealthyThreshold",
"uri": "uri",
},
)
class HealthCheckProperty:
def __init__(
self,
*,
domain: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
health_check_method: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
health_check_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
healthy_threshold: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
http_code: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
interval: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
port: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
switch: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
timeout: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
unhealthy_threshold: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
uri: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''
:param domain:
:param health_check_method:
:param health_check_type:
:param healthy_threshold:
:param http_code:
:param interval:
:param port:
:param switch:
:param timeout:
:param unhealthy_threshold:
:param uri:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__f7bb472dd5f75b293476d1d83cb77c4a18fa448f24ef3141472603f9d5f6425f)
check_type(argname="argument domain", value=domain, expected_type=type_hints["domain"])
check_type(argname="argument health_check_method", value=health_check_method, expected_type=type_hints["health_check_method"])
check_type(argname="argument health_check_type", value=health_check_type, expected_type=type_hints["health_check_type"])
check_type(argname="argument healthy_threshold", value=healthy_threshold, expected_type=type_hints["healthy_threshold"])
check_type(argname="argument http_code", value=http_code, expected_type=type_hints["http_code"])
check_type(argname="argument interval", value=interval, expected_type=type_hints["interval"])
check_type(argname="argument port", value=port, expected_type=type_hints["port"])
check_type(argname="argument switch", value=switch, expected_type=type_hints["switch"])
check_type(argname="argument timeout", value=timeout, expected_type=type_hints["timeout"])
check_type(argname="argument unhealthy_threshold", value=unhealthy_threshold, expected_type=type_hints["unhealthy_threshold"])
check_type(argname="argument uri", value=uri, expected_type=type_hints["uri"])
self._values: typing.Dict[builtins.str, typing.Any] = {}
if domain is not None:
self._values["domain"] = domain
if health_check_method is not None:
self._values["health_check_method"] = health_check_method
if health_check_type is not None:
self._values["health_check_type"] = health_check_type
if healthy_threshold is not None:
self._values["healthy_threshold"] = healthy_threshold
if http_code is not None:
self._values["http_code"] = http_code
if interval is not None:
self._values["interval"] = interval
if port is not None:
self._values["port"] = port
if switch is not None:
self._values["switch"] = switch
if timeout is not None:
self._values["timeout"] = timeout
if unhealthy_threshold is not None:
self._values["unhealthy_threshold"] = unhealthy_threshold
if uri is not None:
self._values["uri"] = uri
@builtins.property
def domain(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: domain: The domain of health check target.
'''
result = self._values.get("domain")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def health_check_method(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: healthCheckMethod: The health check method used in HTTP or HTTPS health checks. Valid values: head and get.
'''
result = self._values.get("health_check_method")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def health_check_type(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: healthCheckType: The type of health check. It takes effect when Protocol=tcp. Valid values: tcp and http. Default value: tcp.
'''
result = self._values.get("health_check_type")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def healthy_threshold(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: healthyThreshold: The number of consecutive health checks successes required,before identified the backend server in Healthy status.
'''
result = self._values.get("healthy_threshold")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def http_code(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: httpCode: The expect status of health check result. Any answer other than referred status within the timeout period is considered unhealthy.
'''
result = self._values.get("http_code")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def interval(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: interval: The approximate interval, unit in seconds, between health checks of an backend server.
'''
result = self._values.get("interval")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def port(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: port: The port being checked. The range of valid ports is 0 through 65535.
'''
result = self._values.get("port")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def switch(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
switch: Whether to enable health check. Valid value: on, off.
If value is on, turn on the health check. If value is off, turn off the health checkIf value is not set, the health check is disabled by default, unless any health check items are configured.
'''
result = self._values.get("switch")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def timeout(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: timeout: The amount of time, in seconds, during which no response means a failed health check.
'''
result = self._values.get("timeout")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def unhealthy_threshold(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: unhealthyThreshold: The number of consecutive health checks failures required,before identified the backend server in Unhealthy status.
'''
result = self._values.get("unhealthy_threshold")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def uri(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: uri: The url of health check target.
'''
result = self._values.get("uri")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "HealthCheckProperty(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-slb.RosListener.HttpConfigProperty",
jsii_struct_bases=[],
name_mapping={
"forward_port": "forwardPort",
"listener_forward": "listenerForward",
},
)
class HttpConfigProperty:
def __init__(
self,
*,
forward_port: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
listener_forward: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''
:param forward_port:
:param listener_forward:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__2fed72d5bbd2e4710dde65ab405172307d15127aeaa39f672b65c93b3632c0cf)
check_type(argname="argument forward_port", value=forward_port, expected_type=type_hints["forward_port"])
check_type(argname="argument listener_forward", value=listener_forward, expected_type=type_hints["listener_forward"])
self._values: typing.Dict[builtins.str, typing.Any] = {}
if forward_port is not None:
self._values["forward_port"] = forward_port
if listener_forward is not None:
self._values["listener_forward"] = listener_forward
@builtins.property
def forward_port(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
forwardPort: HTTP to HTTPS listening forwarding port.
Default value: 443.
'''
result = self._values.get("forward_port")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def listener_forward(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
listenerForward: Whether to enable HTTP to HTTPS forwarding.
Valid values: on | off. Default value: off.
'''
result = self._values.get("listener_forward")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "HttpConfigProperty(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-slb.RosListener.PersistenceProperty",
jsii_struct_bases=[],
name_mapping={
"cookie": "cookie",
"cookie_timeout": "cookieTimeout",
"persistence_timeout": "persistenceTimeout",
"sticky_session": "stickySession",
"sticky_session_type": "stickySessionType",
"x_forwarded_for": "xForwardedFor",
"x_forwarded_for_client_src_port": "xForwardedForClientSrcPort",
"x_forwarded_for_proto": "xForwardedForProto",
"x_forwarded_for_slbid": "xForwardedForSlbid",
"x_forwarded_for_slbip": "xForwardedForSlbip",
"x_forwarded_for_slbport": "xForwardedForSlbport",
},
)
class PersistenceProperty:
def __init__(
self,
*,
cookie: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
cookie_timeout: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
persistence_timeout: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
sticky_session: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
sticky_session_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
x_forwarded_for: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
x_forwarded_for_client_src_port: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
x_forwarded_for_proto: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
x_forwarded_for_slbid: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
x_forwarded_for_slbip: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
x_forwarded_for_slbport: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''
:param cookie:
:param cookie_timeout:
:param persistence_timeout:
:param sticky_session:
:param sticky_session_type:
:param x_forwarded_for:
:param x_forwarded_for_client_src_port:
:param x_forwarded_for_proto:
:param x_forwarded_for_slbid:
:param x_forwarded_for_slbip:
:param x_forwarded_for_slbport:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__4241bd702b9bc2b4bb8e465291abf9233ef9c5d1af927aa073011b4233b9dae6)
check_type(argname="argument cookie", value=cookie, expected_type=type_hints["cookie"])
check_type(argname="argument cookie_timeout", value=cookie_timeout, expected_type=type_hints["cookie_timeout"])
check_type(argname="argument persistence_timeout", value=persistence_timeout, expected_type=type_hints["persistence_timeout"])
check_type(argname="argument sticky_session", value=sticky_session, expected_type=type_hints["sticky_session"])
check_type(argname="argument sticky_session_type", value=sticky_session_type, expected_type=type_hints["sticky_session_type"])
check_type(argname="argument x_forwarded_for", value=x_forwarded_for, expected_type=type_hints["x_forwarded_for"])
check_type(argname="argument x_forwarded_for_client_src_port", value=x_forwarded_for_client_src_port, expected_type=type_hints["x_forwarded_for_client_src_port"])
check_type(argname="argument x_forwarded_for_proto", value=x_forwarded_for_proto, expected_type=type_hints["x_forwarded_for_proto"])
check_type(argname="argument x_forwarded_for_slbid", value=x_forwarded_for_slbid, expected_type=type_hints["x_forwarded_for_slbid"])
check_type(argname="argument x_forwarded_for_slbip", value=x_forwarded_for_slbip, expected_type=type_hints["x_forwarded_for_slbip"])
check_type(argname="argument x_forwarded_for_slbport", value=x_forwarded_for_slbport, expected_type=type_hints["x_forwarded_for_slbport"])
self._values: typing.Dict[builtins.str, typing.Any] = {}
if cookie is not None:
self._values["cookie"] = cookie
if cookie_timeout is not None:
self._values["cookie_timeout"] = cookie_timeout
if persistence_timeout is not None:
self._values["persistence_timeout"] = persistence_timeout
if sticky_session is not None:
self._values["sticky_session"] = sticky_session
if sticky_session_type is not None:
self._values["sticky_session_type"] = sticky_session_type
if x_forwarded_for is not None:
self._values["x_forwarded_for"] = x_forwarded_for
if x_forwarded_for_client_src_port is not None:
self._values["x_forwarded_for_client_src_port"] = x_forwarded_for_client_src_port
if x_forwarded_for_proto is not None:
self._values["x_forwarded_for_proto"] = x_forwarded_for_proto
if x_forwarded_for_slbid is not None:
self._values["x_forwarded_for_slbid"] = x_forwarded_for_slbid
if x_forwarded_for_slbip is not None:
self._values["x_forwarded_for_slbip"] = x_forwarded_for_slbip
if x_forwarded_for_slbport is not None:
self._values["x_forwarded_for_slbport"] = x_forwarded_for_slbport
@builtins.property
def cookie(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: cookie: The type of session persistence.
'''
result = self._values.get("cookie")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def cookie_timeout(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: cookieTimeout: The timeout for cookie setting, in seconds. It only take effect while StickySession is setting to 'on' and StickySessionType is setting to 'insert'.
'''
result = self._values.get("cookie_timeout")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def persistence_timeout(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: persistenceTimeout: The timeout number of persistence, in seconds.
'''
result = self._values.get("persistence_timeout")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def sticky_session(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: stickySession: The switch of session persistence. Support 'on' and 'off'.
'''
result = self._values.get("sticky_session")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def sticky_session_type(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: stickySessionType: The type of session persistence. Depends on parameter StickySession, if it is set to off, this parameter will be ignored.
'''
result = self._values.get("sticky_session_type")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def x_forwarded_for(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: xForwardedFor: Use 'X-Forwarded-For' to get real ip of accessor. On for open, off for close.
'''
result = self._values.get("x_forwarded_for")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def x_forwarded_for_client_src_port(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: xForwardedForClientSrcPort: Optional. Indicates whether to use the X-Forwarded-Client-srcport header field to retrieve the port used by a client to connect to the SLB instance. Valid values: on | off. Default value: offIf you do not set this parameter, the default value is used.
'''
result = self._values.get("x_forwarded_for_client_src_port")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def x_forwarded_for_proto(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: xForwardedForProto: Optional. Indicates whether to use the X-Forwarded-Proto header field to obtainthe listening protocol used by the SLB instance. Valid values: on | off. Default value: offIf you do not set this parameter, the default value is used.
'''
result = self._values.get("x_forwarded_for_proto")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def x_forwarded_for_slbid(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: xForwardedForSlbid: Optional. Indicates whether to use the SLB-ID header field to obtain the SLB instance ID. Valid values: on | off. Default value: off If you do not set this parameter, the default value is used.
'''
result = self._values.get("x_forwarded_for_slbid")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def x_forwarded_for_slbip(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: xForwardedForSlbip: Optional. Indicates whether to use the SLB-IP header field to obtainthe real IP address of a client request.Valid values: on | off. Default value: offIf you do not set this parameter, the default value is used.
'''
result = self._values.get("x_forwarded_for_slbip")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def x_forwarded_for_slbport(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: xForwardedForSlbport: Optional. Indicates whether to use the X-Forwarded-Port header field to retrieve the listening ports of the SLB instance. Valid values: on | off. Default value: offIf you do not set this parameter, the default value is used.
'''
result = self._values.get("x_forwarded_for_slbport")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "PersistenceProperty(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-slb.RosListener.PortRangeProperty",
jsii_struct_bases=[],
name_mapping={"end_port": "endPort", "start_port": "startPort"},
)
class PortRangeProperty:
def __init__(
self,
*,
end_port: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
start_port: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
'''
:param end_port:
:param start_port:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__314d5ec2c18c2e5645f1da52b47f9592473fa77874a463bcd33813d220475044)
check_type(argname="argument end_port", value=end_port, expected_type=type_hints["end_port"])
check_type(argname="argument start_port", value=start_port, expected_type=type_hints["start_port"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"end_port": end_port,
"start_port": start_port,
}
@builtins.property
def end_port(
self,
) -> typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: endPort: End port, from 1 to 65535.
'''
result = self._values.get("end_port")
assert result is not None, "Required property 'end_port' is missing"
return typing.cast(typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def start_port(
self,
) -> typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: startPort: Start port, from 1 to 65535.
'''
result = self._values.get("start_port")
assert result is not None, "Required property 'start_port' is missing"
return typing.cast(typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "PortRangeProperty(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-slb.RosListenerProps",
jsii_struct_bases=[],
name_mapping={
"bandwidth": "bandwidth",
"listener_port": "listenerPort",
"load_balancer_id": "loadBalancerId",
"protocol": "protocol",
"acl_id": "aclId",
"acl_status": "aclStatus",
"acl_type": "aclType",
"backend_server_port": "backendServerPort",
"ca_certificate_id": "caCertificateId",
"description": "description",
"enable_http2": "enableHttp2",
"gzip": "gzip",
"health_check": "healthCheck",
"http_config": "httpConfig",
"idle_timeout": "idleTimeout",
"master_slave_server_group_id": "masterSlaveServerGroupId",
"persistence": "persistence",
"port_range": "portRange",
"request_timeout": "requestTimeout",
"scheduler": "scheduler",
"server_certificate_id": "serverCertificateId",
"start_listener": "startListener",
"tls_cipher_policy": "tlsCipherPolicy",
"v_server_group_id": "vServerGroupId",
},
)
class RosListenerProps:
def __init__(
self,
*,
bandwidth: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
listener_port: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
load_balancer_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
protocol: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
acl_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
acl_status: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
acl_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
backend_server_port: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
ca_certificate_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
description: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
enable_http2: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
gzip: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
health_check: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union[RosListener.HealthCheckProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
http_config: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union[RosListener.HttpConfigProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
idle_timeout: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
master_slave_server_group_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
persistence: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union[RosListener.PersistenceProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
port_range: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union[RosListener.PortRangeProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
request_timeout: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
scheduler: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
server_certificate_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
start_listener: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
tls_cipher_policy: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
v_server_group_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::SLB::Listener``.
:param bandwidth:
:param listener_port:
:param load_balancer_id:
:param protocol:
:param acl_id:
:param acl_status:
:param acl_type:
:param backend_server_port:
:param ca_certificate_id:
:param description:
:param enable_http2:
:param gzip:
:param health_check:
:param http_config:
:param idle_timeout:
:param master_slave_server_group_id:
:param persistence:
:param port_range:
:param request_timeout:
:param scheduler:
:param server_certificate_id:
:param start_listener:
:param tls_cipher_policy:
:param v_server_group_id:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__d3c57955ef9e55f3650e61dba548b01d32bb4d91aec43b7451a9fbacbb77dfce)
check_type(argname="argument bandwidth", value=bandwidth, expected_type=type_hints["bandwidth"])
check_type(argname="argument listener_port", value=listener_port, expected_type=type_hints["listener_port"])
check_type(argname="argument load_balancer_id", value=load_balancer_id, expected_type=type_hints["load_balancer_id"])
check_type(argname="argument protocol", value=protocol, expected_type=type_hints["protocol"])
check_type(argname="argument acl_id", value=acl_id, expected_type=type_hints["acl_id"])
check_type(argname="argument acl_status", value=acl_status, expected_type=type_hints["acl_status"])
check_type(argname="argument acl_type", value=acl_type, expected_type=type_hints["acl_type"])
check_type(argname="argument backend_server_port", value=backend_server_port, expected_type=type_hints["backend_server_port"])
check_type(argname="argument ca_certificate_id", value=ca_certificate_id, expected_type=type_hints["ca_certificate_id"])
check_type(argname="argument description", value=description, expected_type=type_hints["description"])
check_type(argname="argument enable_http2", value=enable_http2, expected_type=type_hints["enable_http2"])
check_type(argname="argument gzip", value=gzip, expected_type=type_hints["gzip"])
check_type(argname="argument health_check", value=health_check, expected_type=type_hints["health_check"])
check_type(argname="argument http_config", value=http_config, expected_type=type_hints["http_config"])
check_type(argname="argument idle_timeout", value=idle_timeout, expected_type=type_hints["idle_timeout"])
check_type(argname="argument master_slave_server_group_id", value=master_slave_server_group_id, expected_type=type_hints["master_slave_server_group_id"])
check_type(argname="argument persistence", value=persistence, expected_type=type_hints["persistence"])
check_type(argname="argument port_range", value=port_range, expected_type=type_hints["port_range"])
check_type(argname="argument request_timeout", value=request_timeout, expected_type=type_hints["request_timeout"])
check_type(argname="argument scheduler", value=scheduler, expected_type=type_hints["scheduler"])
check_type(argname="argument server_certificate_id", value=server_certificate_id, expected_type=type_hints["server_certificate_id"])
check_type(argname="argument start_listener", value=start_listener, expected_type=type_hints["start_listener"])
check_type(argname="argument tls_cipher_policy", value=tls_cipher_policy, expected_type=type_hints["tls_cipher_policy"])
check_type(argname="argument v_server_group_id", value=v_server_group_id, expected_type=type_hints["v_server_group_id"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"bandwidth": bandwidth,
"listener_port": listener_port,
"load_balancer_id": load_balancer_id,
"protocol": protocol,
}
if acl_id is not None:
self._values["acl_id"] = acl_id
if acl_status is not None:
self._values["acl_status"] = acl_status
if acl_type is not None:
self._values["acl_type"] = acl_type
if backend_server_port is not None:
self._values["backend_server_port"] = backend_server_port
if ca_certificate_id is not None:
self._values["ca_certificate_id"] = ca_certificate_id
if description is not None:
self._values["description"] = description
if enable_http2 is not None:
self._values["enable_http2"] = enable_http2
if gzip is not None:
self._values["gzip"] = gzip
if health_check is not None:
self._values["health_check"] = health_check
if http_config is not None:
self._values["http_config"] = http_config
if idle_timeout is not None:
self._values["idle_timeout"] = idle_timeout
if master_slave_server_group_id is not None:
self._values["master_slave_server_group_id"] = master_slave_server_group_id
if persistence is not None:
self._values["persistence"] = persistence
if port_range is not None:
self._values["port_range"] = port_range
if request_timeout is not None:
self._values["request_timeout"] = request_timeout
if scheduler is not None:
self._values["scheduler"] = scheduler
if server_certificate_id is not None:
self._values["server_certificate_id"] = server_certificate_id
if start_listener is not None:
self._values["start_listener"] = start_listener
if tls_cipher_policy is not None:
self._values["tls_cipher_policy"] = tls_cipher_policy
if v_server_group_id is not None:
self._values["v_server_group_id"] = v_server_group_id
@builtins.property
def bandwidth(
self,
) -> typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: bandwidth: The bandwidth of network, unit in Mbps(Million bits per second). If the specified load balancer with "LOAD_BALANCE_ID" is charged by "paybybandwidth" and is created in classic network, each Listener's bandwidth must be greater than 0 and the sum of all of its Listeners' bandwidth can't be greater than the bandwidth of the load balancer.
'''
result = self._values.get("bandwidth")
assert result is not None, "Required property 'bandwidth' is missing"
return typing.cast(typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def listener_port(
self,
) -> typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: listenerPort: Port for front listener. Range from 0 to 65535.
'''
result = self._values.get("listener_port")
assert result is not None, "Required property 'listener_port' is missing"
return typing.cast(typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def load_balancer_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: loadBalancerId: The id of load balancer to create listener.
'''
result = self._values.get("load_balancer_id")
assert result is not None, "Required property 'load_balancer_id' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def protocol(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: protocol: The load balancer transport protocol to use for routing: http, https, tcp, or udp.
'''
result = self._values.get("protocol")
assert result is not None, "Required property 'protocol' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def acl_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
aclId: The ID of the access control list associated with the listener to be created.
If the value of the AclStatus parameter is on, this parameter is required.
'''
result = self._values.get("acl_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def acl_status(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
aclStatus: Indicates whether to enable access control.
Valid values: on | off. Default value: off
'''
result = self._values.get("acl_status")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def acl_type(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
aclType: The access control type:
- white: Indicates a whitelist. Only requests from IP addresses or CIDR blocks in the selected access control lists are forwarded. This applies to scenarios in which an application only allows access from specific IP addresses.
Enabling a whitelist poses some risks to your services.
After a whitelist is enabled, only the IP addresses in the list can access the listener.
If you enable a whitelist without adding any IP addresses in the list, no requests are forwarded.
- black: Indicates a blacklist. Requests from IP addresses or CIDR blocks in the selected access control lists are not forwarded (that is, they are blocked). This applies to scenarios in which an application only denies access from specific IP addresses.
If you enable a blacklist without adding any IP addresses in the list, all requests are forwarded.
If the value of the AclStatus parameter is on, this parameter is required.
'''
result = self._values.get("acl_type")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def backend_server_port(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: backendServerPort: Backend server can listen on ports from 1 to 65535.
'''
result = self._values.get("backend_server_port")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def ca_certificate_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: caCertificateId: CA server certificate id, for https listener only.
'''
result = self._values.get("ca_certificate_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def description(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: description: The description of the listener.It must be 1 to 80 characters in length and can contain letters, digits, hyphens (-), forward slashes (/), periods (.), and underscores (_). Chinese characters are supported.
'''
result = self._values.get("description")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def enable_http2(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
enableHttp2: Specifies whether to use HTTP/2. It takes effect when Protocol=https. Valid values:
on: yes
off: no
'''
result = self._values.get("enable_http2")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def gzip(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
gzip: Specifies whether to enable Gzip compression to compress specific types of files. Valid values:
on (default): yes
off: no
'''
result = self._values.get("gzip")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def health_check(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, RosListener.HealthCheckProperty]]:
'''
:Property: healthCheck: The properties of health checking setting.
'''
result = self._values.get("health_check")
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, RosListener.HealthCheckProperty]], result)
@builtins.property
def http_config(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, RosListener.HttpConfigProperty]]:
'''
:Property: httpConfig: Config for http protocol.
'''
result = self._values.get("http_config")
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, RosListener.HttpConfigProperty]], result)
@builtins.property
def idle_timeout(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: idleTimeout: Specify the idle connection timeout in seconds. Valid value: 1-60 If no request is received during the specified timeout period, Server Load Balancer will temporarily terminate the connection and restart the connection when the next request comes.
'''
result = self._values.get("idle_timeout")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def master_slave_server_group_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: masterSlaveServerGroupId: The id of the MasterSlaveServerGroup which use in listener.
'''
result = self._values.get("master_slave_server_group_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def persistence(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, RosListener.PersistenceProperty]]:
'''
:Property: persistence: The properties of persistence.
'''
result = self._values.get("persistence")
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, RosListener.PersistenceProperty]], result)
@builtins.property
def port_range(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, RosListener.PortRangeProperty]]]]:
'''
:Property: portRange: Port range, only supports TCP or UDP listener. ListenerPort should be 0 when PortRange is specified.
'''
result = self._values.get("port_range")
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, RosListener.PortRangeProperty]]]], result)
@builtins.property
def request_timeout(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: requestTimeout: Specify the request timeout in seconds. Valid value: 1-180 If no response is received from the backend server during the specified timeout period, Server Load Balancer will stop waiting and send an HTTP 504 error to the client.
'''
result = self._values.get("request_timeout")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def scheduler(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
scheduler: The scheduling algorithm. Valid values:
wrr: Backend servers that have higher weights receive more requests than those that have lower weights.
wlc: Requests are distributed based on the combination of the weights and connections to backend servers. If two backend servers have the same weight, the backend server that has fewer connections receives more requests.
rr: Requests are distributed to backend servers in sequence.
sch: specifies consistent hashing that is based on source IP addresses. Requests from the same source IP address are distributed to the same backend server.
tch: specifies consistent hashing that is based on four factors: source IP address, destination IP address, source port number, and destination port number. Requests that contain the same preceding information are distributed to the same backend server.
Default: wrr
'''
result = self._values.get("scheduler")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def server_certificate_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: serverCertificateId: Server certificate id, for https listener only, this properties is required.
'''
result = self._values.get("server_certificate_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def start_listener(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: startListener: Whether start listener after listener created. Default True.
'''
result = self._values.get("start_listener")
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def tls_cipher_policy(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: tlsCipherPolicy: The Transport Layer Security (TLS) security policy. Each security policy contains TLS protocol versions and cipher suites available for HTTPS. It takes effect when Protocol=https.
'''
result = self._values.get("tls_cipher_policy")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def v_server_group_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: vServerGroupId: The id of the VServerGroup which use in listener.
'''
result = self._values.get("v_server_group_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "RosListenerProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class RosLoadBalancer(
_ros_cdk_core_7adfd82f.RosResource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-slb.RosLoadBalancer",
):
'''A ROS template type: ``ALIYUN::SLB::LoadBalancer``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["RosLoadBalancerProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
'''Create a new ``ALIYUN::SLB::LoadBalancer``.
:param scope: - scope in which this resource is defined.
:param id: - scoped id of the resource.
:param props: - resource properties.
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__ac034d72aa26bde3e28687b108c97956145ad9487d6b8efc3dc0c57cd1acda43)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@jsii.member(jsii_name="renderProperties")
def _render_properties(
self,
props: typing.Mapping[builtins.str, typing.Any],
) -> typing.Mapping[builtins.str, typing.Any]:
'''
:param props: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__2a7edf661660d2e34b7cca3206375396dff58f16bb9a776b710d9ca39cfa0b27)
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))
@jsii.python.classproperty
@jsii.member(jsii_name="ROS_RESOURCE_TYPE_NAME")
def ROS_RESOURCE_TYPE_NAME(cls) -> builtins.str:
'''The resource type name for this resource class.'''
return typing.cast(builtins.str, jsii.sget(cls, "ROS_RESOURCE_TYPE_NAME"))
@builtins.property
@jsii.member(jsii_name="attrAddressIpVersion")
def attr_address_ip_version(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: AddressIPVersion: IP version
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrAddressIpVersion"))
@builtins.property
@jsii.member(jsii_name="attrAddressType")
def attr_address_type(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: AddressType: The address type of the load balancer. "intranet" or "internet".
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrAddressType"))
@builtins.property
@jsii.member(jsii_name="attrBandwidth")
def attr_bandwidth(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: Bandwidth: The bandwidth for network
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrBandwidth"))
@builtins.property
@jsii.member(jsii_name="attrIpAddress")
def attr_ip_address(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: IpAddress: The ip address of the load balancer.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrIpAddress"))
@builtins.property
@jsii.member(jsii_name="attrLoadBalancerId")
def attr_load_balancer_id(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: LoadBalancerId: The id of load balance created.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrLoadBalancerId"))
@builtins.property
@jsii.member(jsii_name="attrLoadBalancerName")
def attr_load_balancer_name(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: LoadBalancerName: Name of created load balancer.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrLoadBalancerName"))
@builtins.property
@jsii.member(jsii_name="attrLoadBalancerSpec")
def attr_load_balancer_spec(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: LoadBalancerSpec: The specification of the Server Load Balancer instance
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrLoadBalancerSpec"))
@builtins.property
@jsii.member(jsii_name="attrMasterZoneId")
def attr_master_zone_id(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: MasterZoneId: The master zone id to create load balancer instance.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrMasterZoneId"))
@builtins.property
@jsii.member(jsii_name="attrNetworkType")
def attr_network_type(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: NetworkType: The network type of the load balancer. "vpc" or "classic" network.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrNetworkType"))
@builtins.property
@jsii.member(jsii_name="attrOrderId")
def attr_order_id(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: OrderId: The order ID.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrOrderId"))
@builtins.property
@jsii.member(jsii_name="attrPayType")
def attr_pay_type(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: PayType: The billing method of the instance to be created.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrPayType"))
@builtins.property
@jsii.member(jsii_name="attrResourceGroupId")
def attr_resource_group_id(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: ResourceGroupId: Resource group id.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrResourceGroupId"))
@builtins.property
@jsii.member(jsii_name="attrSlaveZoneId")
def attr_slave_zone_id(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: SlaveZoneId: The slave zone id to create load balancer instance.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrSlaveZoneId"))
@builtins.property
@jsii.member(jsii_name="attrVpcId")
def attr_vpc_id(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: VpcId: Vpc id
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrVpcId"))
@builtins.property
@jsii.member(jsii_name="attrVSwitchId")
def attr_v_switch_id(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: VSwitchId: VSwitch id
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrVSwitchId"))
@builtins.property
@jsii.member(jsii_name="rosProperties")
def _ros_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "rosProperties"))
@builtins.property
@jsii.member(jsii_name="enableResourcePropertyConstraint")
def enable_resource_property_constraint(self) -> builtins.bool:
return typing.cast(builtins.bool, jsii.get(self, "enableResourcePropertyConstraint"))
@enable_resource_property_constraint.setter
def enable_resource_property_constraint(self, value: builtins.bool) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__797f8811e9db7c17b7db8980846f43192379650ace12c2494a149393cd1007dd)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "enableResourcePropertyConstraint", value)
@builtins.property
@jsii.member(jsii_name="addressIpVersion")
def address_ip_version(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: addressIpVersion: IP version, support 'ipv4' or 'ipv6'. If 'ipv6' is selected, please note that the zone and the specification are supported.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "addressIpVersion"))
@address_ip_version.setter
def address_ip_version(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__fdaf5ff7fec7ed58bf64caa92aaba18bc8acee220c99edd54939d46e06c84775)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "addressIpVersion", value)
@builtins.property
@jsii.member(jsii_name="addressType")
def address_type(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
addressType: The network type of the CLB instance. Valid values:
- **internet** (default): After an internet-facing CLB instance is created, the system assigns a public IP address to the CLB instance. Then, the CLB instance can forward requests over the Internet.
- **intranet**: After an internal-facing CLB instance is created, the system assigns a private IP address to the CLB instance. Then, the CLB instance can forward requests only over the internal networks.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "addressType"))
@address_type.setter
def address_type(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__cc2abeaa4eb1d6d7184bfbef30800d9cce06bf117498711045d8ba0708f01b4a)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "addressType", value)
@builtins.property
@jsii.member(jsii_name="autoPay")
def auto_pay(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
autoPay: Specifies whether to automatically pay for the subscription Internet-facing CLB instance. Valid values:
- **true**: automatically pays for the CLB instance. After you call this operation, the system automatically completes the payment and creates the CLB instance.- **false** (default): After you call the operation, the order is created but the payment is not completed. You can view the pending order in the console. The CLB instance will not be created until you complete the payment.**Note** This parameter is supported only by subscription instances created on the Alibaba Cloud China site.
'''
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "autoPay"))
@auto_pay.setter
def auto_pay(
self,
value: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__d14dce33a295ed1e1d5e73999a65bc6f891915ea40684ca50a258a3e8f0536df)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "autoPay", value)
@builtins.property
@jsii.member(jsii_name="autoRenew")
def auto_renew(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: autoRenew: Indicates whether automatic renewal is enabled for the instance. Valid values:- **true**: Automatic renewal is enabled.- **false** (default): Automatic renewal is not enabled. You must renew the instance manually.
'''
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "autoRenew"))
@auto_renew.setter
def auto_renew(
self,
value: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__f8859b93c9ab709a5e4cd9da41f85dc9c3fe048b4a5d7586002bc473b45ae26f)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "autoRenew", value)
@builtins.property
@jsii.member(jsii_name="autoRenewPeriod")
def auto_renew_period(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
autoRenewPeriod: Automatic renewal cycle, which takes effect when AutoRenew is true, and is required:
When PricingCycle = month, the value range is 1 to 9 or 12, 24, 36.
When PeriodUnit = year, the value range is 1-3.
'''
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "autoRenewPeriod"))
@auto_renew_period.setter
def auto_renew_period(
self,
value: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__a8c4545e9e0fbe652aac0c9dc9737379bf08f81a637d6074987a44ae77da487e)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "autoRenewPeriod", value)
@builtins.property
@jsii.member(jsii_name="bandwidth")
def bandwidth(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: bandwidth: The bandwidth for network, unit in Mbps(Mega bit per second). Default is 1. If InternetChargeType is specified as "paybytraffic", this property will be ignore and please specify the "Bandwidth" in ALIYUN::SLB::Listener.
'''
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "bandwidth"))
@bandwidth.setter
def bandwidth(
self,
value: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__fc82c82d03141c0ac5002b517e7e174c598d4252deea9095ac5549b4ed4c6cb8)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "bandwidth", value)
@builtins.property
@jsii.member(jsii_name="deletionProtection")
def deletion_protection(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: deletionProtection: Whether to enable deletion protection.
'''
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "deletionProtection"))
@deletion_protection.setter
def deletion_protection(
self,
value: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__5c665ec4750026b6229fdfa17516c97af4e125d64f781e498c11a832585febaf)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "deletionProtection", value)
@builtins.property
@jsii.member(jsii_name="duration")
def duration(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
duration: Optional. The subscription duration of a Subscription Internet instance.
Valid values:
If PricingCycle is month, the valid range is 1 to 9 or 12, 24, 36, 48, 60.
If PricingCycle is year, the value range is 1 to 5.
'''
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "duration"))
@duration.setter
def duration(
self,
value: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__7309ca279a3aedb6e66b2c068c326c155199df20aa579f4c9282219c953c5279)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "duration", value)
@builtins.property
@jsii.member(jsii_name="instanceChargeType")
def instance_charge_type(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
instanceChargeType: Instance billing method. Valid value:
- **PayBySpec** (default): Pay by spec.
- **PayByCLCU**: billed by usage.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "instanceChargeType"))
@instance_charge_type.setter
def instance_charge_type(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__c53222207b48b2672e2c068b336d9fe090ed84ee6610470e15622eeb1a8c4515)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "instanceChargeType", value)
@builtins.property
@jsii.member(jsii_name="internetChargeType")
def internet_charge_type(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
internetChargeType: The metering method of the Internet-facing CLB instance. Valid values:
- **paybytraffic** (default): If you set the value to paybytraffic, you do not need to specify Bandwidth. Even if you specify Bandwidth, the value does not take effect.
- **paybybandwidth**: pay-by-bandwidth.
**Note** If you set PayType to PayOnDemand and set InstanceChargeType to PayByCLCU, you must set InternetChargeType to paybytraffic.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "internetChargeType"))
@internet_charge_type.setter
def internet_charge_type(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__026a25b59716874c592cbcd49ab24aac71a7766a2c1d7b29db0b763a48ce21e1)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "internetChargeType", value)
@builtins.property
@jsii.member(jsii_name="loadBalancerName")
def load_balancer_name(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: loadBalancerName: Name of created load balancer. Length is limited to 1-80 characters, allowed to contain letters, numbers, '-, /, _,.' When not specified, a default name will be assigned.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "loadBalancerName"))
@load_balancer_name.setter
def load_balancer_name(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__689e47e32d2afb1e4d271e5eb31c5dd95f0f41d4616e69cf6bbd02dae7f82fd9)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "loadBalancerName", value)
@builtins.property
@jsii.member(jsii_name="loadBalancerSpec")
def load_balancer_spec(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
loadBalancerSpec: The specification of the CLB instance. Valid values:
- **slb.s1.small**
- **slb.s2.small**
- **slb.s2.medium**
- **slb.s3.small**
- **slb.s3.medium**
- **slb.s3.large**
**Note** If you do not specify this parameter, a shared-resource CLB instance is created. Shared-resource CLB instances are no longer available for purchase. Therefore, you must specify this parameter.
If InstanceChargeType is set to PayByCLCU, this parameter is invalid and you do not need to specify this parameter.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "loadBalancerSpec"))
@load_balancer_spec.setter
def load_balancer_spec(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__7b572175ef8437888bca6c419ae0589d1ad3d89dc15d6bbd7bad92dde8bec287)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "loadBalancerSpec", value)
@builtins.property
@jsii.member(jsii_name="masterZoneId")
def master_zone_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: masterZoneId: The master zone id to create load balancer instance.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "masterZoneId"))
@master_zone_id.setter
def master_zone_id(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__2a1272586a275470c8dc9b59d3612e869c1e75e21a1924bca37fc9fcc1b5312e)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "masterZoneId", value)
@builtins.property
@jsii.member(jsii_name="modificationProtectionReason")
def modification_protection_reason(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
modificationProtectionReason: Set the reason for modifying the protection status. The length is 1-80 English or Chinese characters, must start with upper and lower letters or Chinese, and can include numbers, periods (.), underscores (_) and dashes (-).
Only valid when ModificationProtectionStatus is ConsoleProtection.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "modificationProtectionReason"))
@modification_protection_reason.setter
def modification_protection_reason(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__1c3f40e7dc3740d21811e251799481467273db66ae0cc8f69ed5dff2219aa6ee)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "modificationProtectionReason", value)
@builtins.property
@jsii.member(jsii_name="modificationProtectionStatus")
def modification_protection_status(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
modificationProtectionStatus: NonProtection or empty: means no restriction on modification protection
ConsoleProtection: Modify instance protection status by console
Default value is empty.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "modificationProtectionStatus"))
@modification_protection_status.setter
def modification_protection_status(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__46492516939a5f5c744e096dfb7ba42ec4e1a1ac22f9b8cb0d56e44c36dca00f)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "modificationProtectionStatus", value)
@builtins.property
@jsii.member(jsii_name="payType")
def pay_type(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
payType: Optional. The billing method of the instance to be created.
Valid value: PayOnDemand (Pay-As-You-Go) | PrePay (Subscription)
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "payType"))
@pay_type.setter
def pay_type(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__98a24be074846809182b991a1184fe184288a911a8ac3da01d7d7e0120b6f147)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "payType", value)
@builtins.property
@jsii.member(jsii_name="pricingCycle")
def pricing_cycle(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
pricingCycle: Optional. The duration of the Subscription-billed Internet instance to be created.
Valid values: month | year.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "pricingCycle"))
@pricing_cycle.setter
def pricing_cycle(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__90002872ae70a67a4f1e619ec83d61985b8982edf3eb2f4b035adea580f4e917)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "pricingCycle", value)
@builtins.property
@jsii.member(jsii_name="resourceGroupId")
def resource_group_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: resourceGroupId: Resource group id.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "resourceGroupId"))
@resource_group_id.setter
def resource_group_id(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__f8c0f3cabade82e069cb8339d8fff4bae2c601b01868aab72150d739ca0a156c)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "resourceGroupId", value)
@builtins.property
@jsii.member(jsii_name="slaveZoneId")
def slave_zone_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: slaveZoneId: The slave zone id to create load balancer instance.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "slaveZoneId"))
@slave_zone_id.setter
def slave_zone_id(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__2c32e11009f833d195cdc8acc81242f5bb226c8588202d56912cff0cdd55a922)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "slaveZoneId", value)
@builtins.property
@jsii.member(jsii_name="tags")
def tags(self) -> typing.Optional[typing.List["RosLoadBalancer.TagsProperty"]]:
'''
:Property: tags: Tags to attach to slb. Max support 5 tags to add during create slb. Each tag with two properties Key and Value, and Key is required.
'''
return typing.cast(typing.Optional[typing.List["RosLoadBalancer.TagsProperty"]], jsii.get(self, "tags"))
@tags.setter
def tags(
self,
value: typing.Optional[typing.List["RosLoadBalancer.TagsProperty"]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__7662e060f3184416fd4b1b14ffc62ea373fed9261fe30285c63faf9e5870b1cf)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "tags", value)
@builtins.property
@jsii.member(jsii_name="vpcId")
def vpc_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: vpcId: The VPC id to create load balancer instance. For VPC network only.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "vpcId"))
@vpc_id.setter
def vpc_id(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__d45d6b63733a6726d2a952dc6a69e39ea31dcea1640e6314993e0be3f12f54c7)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "vpcId", value)
@builtins.property
@jsii.member(jsii_name="vSwitchId")
def v_switch_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: vSwitchId: The VSwitch id to create load balancer instance. For VPC network only.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "vSwitchId"))
@v_switch_id.setter
def v_switch_id(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__ee538bac3fdeaaad87126f158f56053381d6c9f341cb1808e931ce7265b731d8)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "vSwitchId", value)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-slb.RosLoadBalancer.TagsProperty",
jsii_struct_bases=[],
name_mapping={"key": "key", "value": "value"},
)
class TagsProperty:
def __init__(
self,
*,
key: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''
:param key:
:param value:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__ae91907b5c637ed4590f98ef4c8d68d1c4ed228c040a22a2dcfe37582c14a999)
check_type(argname="argument key", value=key, expected_type=type_hints["key"])
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"key": key,
}
if value is not None:
self._values["value"] = value
@builtins.property
def key(self) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: key: undefined
'''
result = self._values.get("key")
assert result is not None, "Required property 'key' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def value(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: value: undefined
'''
result = self._values.get("value")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "TagsProperty(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class RosLoadBalancerClone(
_ros_cdk_core_7adfd82f.RosResource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-slb.RosLoadBalancerClone",
):
'''A ROS template type: ``ALIYUN::SLB::LoadBalancerClone``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["RosLoadBalancerCloneProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
'''Create a new ``ALIYUN::SLB::LoadBalancerClone``.
:param scope: - scope in which this resource is defined.
:param id: - scoped id of the resource.
:param props: - resource properties.
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__2ffade5dc970282cd514b995eebe40dab996c88c5aaf277d21b6a07d25f9ac93)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@jsii.member(jsii_name="renderProperties")
def _render_properties(
self,
props: typing.Mapping[builtins.str, typing.Any],
) -> typing.Mapping[builtins.str, typing.Any]:
'''
:param props: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__a9f6f0be89524067c6057cc968c80fba2619e9222ca524c58bf0bab75d6b2070)
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))
@jsii.python.classproperty
@jsii.member(jsii_name="ROS_RESOURCE_TYPE_NAME")
def ROS_RESOURCE_TYPE_NAME(cls) -> builtins.str:
'''The resource type name for this resource class.'''
return typing.cast(builtins.str, jsii.sget(cls, "ROS_RESOURCE_TYPE_NAME"))
@builtins.property
@jsii.member(jsii_name="attrLoadBalancerId")
def attr_load_balancer_id(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: LoadBalancerId: The id of load balance generated
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrLoadBalancerId"))
@builtins.property
@jsii.member(jsii_name="rosProperties")
def _ros_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "rosProperties"))
@builtins.property
@jsii.member(jsii_name="enableResourcePropertyConstraint")
def enable_resource_property_constraint(self) -> builtins.bool:
return typing.cast(builtins.bool, jsii.get(self, "enableResourcePropertyConstraint"))
@enable_resource_property_constraint.setter
def enable_resource_property_constraint(self, value: builtins.bool) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__61a00b0da57d05e5963e1d1aaac28b18f8b2e6d3dd0520079b36a8f26627dad0)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "enableResourcePropertyConstraint", value)
@builtins.property
@jsii.member(jsii_name="sourceLoadBalancerId")
def source_load_balancer_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: sourceLoadBalancerId: Source load balancer id to clone
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "sourceLoadBalancerId"))
@source_load_balancer_id.setter
def source_load_balancer_id(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__4881a8759fc0ab02baa88833b7c136130e46e087678f51c15172607b519a4258)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "sourceLoadBalancerId", value)
@builtins.property
@jsii.member(jsii_name="backendServers")
def backend_servers(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosLoadBalancerClone.BackendServersProperty"]]]]:
'''
:Property: backendServers: The list of ECS instance, which will attached to load balancer.
'''
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosLoadBalancerClone.BackendServersProperty"]]]], jsii.get(self, "backendServers"))
@backend_servers.setter
def backend_servers(
self,
value: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosLoadBalancerClone.BackendServersProperty"]]]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__c7988d71e27b919133722358429e566e121583c94bd24b03c67daa42532a4282)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "backendServers", value)
@builtins.property
@jsii.member(jsii_name="backendServersPolicy")
def backend_servers_policy(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: backendServersPolicy: Solution for handle the backend server and weights. If select 'clone', it will clone from source load balancer. If select 'empty' it will not attach any backend servers. If select 'append' it will append the new backend server list to source backed servers. If select 'replace' it will only attach new backend server list. Default is 'clone'.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "backendServersPolicy"))
@backend_servers_policy.setter
def backend_servers_policy(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__025387db2dfcfac3341ba466eb5dc3f4de30e018a107f6f007a59c23769e6310)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "backendServersPolicy", value)
@builtins.property
@jsii.member(jsii_name="instanceChargeType")
def instance_charge_type(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
instanceChargeType: Instance billing method. Value:PayBySpec: Pay by spec.
PayByCLCU: billed by usage.
If not specified, it is same with the source load balancer.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "instanceChargeType"))
@instance_charge_type.setter
def instance_charge_type(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__f0213ef0271cd0278b634d936c7735828f3d144ea15b9b0ed98a58d1a1224ce6)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "instanceChargeType", value)
@builtins.property
@jsii.member(jsii_name="loadBalancerName")
def load_balancer_name(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: loadBalancerName: Name of created load balancer. Length is limited to 1-80 characters, allowed to contain letters, numbers, '-, /, _,.' When not specified, a default name will be assigned.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "loadBalancerName"))
@load_balancer_name.setter
def load_balancer_name(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__aef889cf0580f45cd58a670704ad1109d4ef57cf2986531e9da03f770362b0cc)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "loadBalancerName", value)
@builtins.property
@jsii.member(jsii_name="loadBalancerSpec")
def load_balancer_spec(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
loadBalancerSpec: The specification of the load balancer. If not specified, it is same with the source load balancer.
Note If InstanceChargeType is set to PayByCLCU, the LoadBalancerSpec parameter is invalid and you do not need to set this parameter.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "loadBalancerSpec"))
@load_balancer_spec.setter
def load_balancer_spec(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__7fbbe6a4bb532c5692cd4d600a151e1b5d3b08c9a2439ea60c880cba41d6f60a)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "loadBalancerSpec", value)
@builtins.property
@jsii.member(jsii_name="resourceGroupId")
def resource_group_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: resourceGroupId: Resource group id.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "resourceGroupId"))
@resource_group_id.setter
def resource_group_id(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__83ad3f6ec65f700710b10419ae05b8c3779253b6718fbcde064d4d08837bab54)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "resourceGroupId", value)
@builtins.property
@jsii.member(jsii_name="tags")
def tags(self) -> typing.Optional[typing.List["RosLoadBalancerClone.TagsProperty"]]:
'''
:Property: tags: Tags to attach to slb. Max support 5 tags to add during create slb. Each tag with two properties Key and Value, and Key is required.
'''
return typing.cast(typing.Optional[typing.List["RosLoadBalancerClone.TagsProperty"]], jsii.get(self, "tags"))
@tags.setter
def tags(
self,
value: typing.Optional[typing.List["RosLoadBalancerClone.TagsProperty"]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__d7ceb55efa8025d2f9b30b567d2453a05ca64d9adfce00f4590c73d638dfa6df)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "tags", value)
@builtins.property
@jsii.member(jsii_name="tagsPolicy")
def tags_policy(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
tagsPolicy: Solution for handle the tags. If select 'clone', it will clone from source load balancer. If select 'empty' it will not copy tags. If select 'append' it will append the new tags. If select 'replace' it will add new tags.
Default is 'empty'.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "tagsPolicy"))
@tags_policy.setter
def tags_policy(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__3ec67321fe80002f47513b8d2ca14d6f1bc037cf25054d8b2dff43964f249e49)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "tagsPolicy", value)
@builtins.property
@jsii.member(jsii_name="vSwitchId")
def v_switch_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: vSwitchId: The new VSwitch ID to create load balancer instance. For VPC network only and the VSwitch should belong to the VPC which source load balancer is located.When not specified, source load balancer VSwitch ID will be used.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "vSwitchId"))
@v_switch_id.setter
def v_switch_id(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__907c6d68baa35d78328f3bf2319eb05b977c3a5b4971c7f0399096445628d09e)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "vSwitchId", value)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-slb.RosLoadBalancerClone.BackendServersProperty",
jsii_struct_bases=[],
name_mapping={
"server_id": "serverId",
"weight": "weight",
"description": "description",
"server_ip": "serverIp",
"type": "type",
},
)
class BackendServersProperty:
def __init__(
self,
*,
server_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
weight: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
description: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
server_ip: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''
:param server_id:
:param weight:
:param description:
:param server_ip:
:param type:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__806e0f68708f0cfca573b37e8021da59727f95c78daafef8b0594716560d6ae8)
check_type(argname="argument server_id", value=server_id, expected_type=type_hints["server_id"])
check_type(argname="argument weight", value=weight, expected_type=type_hints["weight"])
check_type(argname="argument description", value=description, expected_type=type_hints["description"])
check_type(argname="argument server_ip", value=server_ip, expected_type=type_hints["server_ip"])
check_type(argname="argument type", value=type, expected_type=type_hints["type"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"server_id": server_id,
"weight": weight,
}
if description is not None:
self._values["description"] = description
if server_ip is not None:
self._values["server_ip"] = server_ip
if type is not None:
self._values["type"] = type
@builtins.property
def server_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: serverId: Need one valid instance id. The instance status should running.
'''
result = self._values.get("server_id")
assert result is not None, "Required property 'server_id' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def weight(
self,
) -> typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: weight: The weight of backend server of load balancer. From 0 to 100, 0 means offline. Default is 100.
'''
result = self._values.get("weight")
assert result is not None, "Required property 'weight' is missing"
return typing.cast(typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def description(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: description: A description of the backend server.
'''
result = self._values.get("description")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def server_ip(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: serverIp: The IP of the instance.
'''
result = self._values.get("server_ip")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def type(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: type: The backend server type. Valid values:ecs: ECS instance (default)eni: Elastic Network Interface (ENI)
'''
result = self._values.get("type")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "BackendServersProperty(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-slb.RosLoadBalancerClone.TagsProperty",
jsii_struct_bases=[],
name_mapping={"key": "key", "value": "value"},
)
class TagsProperty:
def __init__(
self,
*,
key: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''
:param key:
:param value:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__9eac177e1081b4a58645490a4cfa0bdac74d80201f3aeed2927310349dc38567)
check_type(argname="argument key", value=key, expected_type=type_hints["key"])
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"key": key,
}
if value is not None:
self._values["value"] = value
@builtins.property
def key(self) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: key: undefined
'''
result = self._values.get("key")
assert result is not None, "Required property 'key' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def value(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: value: undefined
'''
result = self._values.get("value")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "TagsProperty(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-slb.RosLoadBalancerCloneProps",
jsii_struct_bases=[],
name_mapping={
"source_load_balancer_id": "sourceLoadBalancerId",
"backend_servers": "backendServers",
"backend_servers_policy": "backendServersPolicy",
"instance_charge_type": "instanceChargeType",
"load_balancer_name": "loadBalancerName",
"load_balancer_spec": "loadBalancerSpec",
"resource_group_id": "resourceGroupId",
"tags": "tags",
"tags_policy": "tagsPolicy",
"v_switch_id": "vSwitchId",
},
)
class RosLoadBalancerCloneProps:
def __init__(
self,
*,
source_load_balancer_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
backend_servers: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union[RosLoadBalancerClone.BackendServersProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
backend_servers_policy: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
instance_charge_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
load_balancer_name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
load_balancer_spec: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
resource_group_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
tags: typing.Optional[typing.Sequence[typing.Union[RosLoadBalancerClone.TagsProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
tags_policy: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
v_switch_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::SLB::LoadBalancerClone``.
:param source_load_balancer_id:
:param backend_servers:
:param backend_servers_policy:
:param instance_charge_type:
:param load_balancer_name:
:param load_balancer_spec:
:param resource_group_id:
:param tags:
:param tags_policy:
:param v_switch_id:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__bb8dfaad9fcd2ffaf8d59a94a25039beed0dd32209e64d1908c8486b503dea2e)
check_type(argname="argument source_load_balancer_id", value=source_load_balancer_id, expected_type=type_hints["source_load_balancer_id"])
check_type(argname="argument backend_servers", value=backend_servers, expected_type=type_hints["backend_servers"])
check_type(argname="argument backend_servers_policy", value=backend_servers_policy, expected_type=type_hints["backend_servers_policy"])
check_type(argname="argument instance_charge_type", value=instance_charge_type, expected_type=type_hints["instance_charge_type"])
check_type(argname="argument load_balancer_name", value=load_balancer_name, expected_type=type_hints["load_balancer_name"])
check_type(argname="argument load_balancer_spec", value=load_balancer_spec, expected_type=type_hints["load_balancer_spec"])
check_type(argname="argument resource_group_id", value=resource_group_id, expected_type=type_hints["resource_group_id"])
check_type(argname="argument tags", value=tags, expected_type=type_hints["tags"])
check_type(argname="argument tags_policy", value=tags_policy, expected_type=type_hints["tags_policy"])
check_type(argname="argument v_switch_id", value=v_switch_id, expected_type=type_hints["v_switch_id"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"source_load_balancer_id": source_load_balancer_id,
}
if backend_servers is not None:
self._values["backend_servers"] = backend_servers
if backend_servers_policy is not None:
self._values["backend_servers_policy"] = backend_servers_policy
if instance_charge_type is not None:
self._values["instance_charge_type"] = instance_charge_type
if load_balancer_name is not None:
self._values["load_balancer_name"] = load_balancer_name
if load_balancer_spec is not None:
self._values["load_balancer_spec"] = load_balancer_spec
if resource_group_id is not None:
self._values["resource_group_id"] = resource_group_id
if tags is not None:
self._values["tags"] = tags
if tags_policy is not None:
self._values["tags_policy"] = tags_policy
if v_switch_id is not None:
self._values["v_switch_id"] = v_switch_id
@builtins.property
def source_load_balancer_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: sourceLoadBalancerId: Source load balancer id to clone
'''
result = self._values.get("source_load_balancer_id")
assert result is not None, "Required property 'source_load_balancer_id' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def backend_servers(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, RosLoadBalancerClone.BackendServersProperty]]]]:
'''
:Property: backendServers: The list of ECS instance, which will attached to load balancer.
'''
result = self._values.get("backend_servers")
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, RosLoadBalancerClone.BackendServersProperty]]]], result)
@builtins.property
def backend_servers_policy(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: backendServersPolicy: Solution for handle the backend server and weights. If select 'clone', it will clone from source load balancer. If select 'empty' it will not attach any backend servers. If select 'append' it will append the new backend server list to source backed servers. If select 'replace' it will only attach new backend server list. Default is 'clone'.
'''
result = self._values.get("backend_servers_policy")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def instance_charge_type(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
instanceChargeType: Instance billing method. Value:PayBySpec: Pay by spec.
PayByCLCU: billed by usage.
If not specified, it is same with the source load balancer.
'''
result = self._values.get("instance_charge_type")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def load_balancer_name(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: loadBalancerName: Name of created load balancer. Length is limited to 1-80 characters, allowed to contain letters, numbers, '-, /, _,.' When not specified, a default name will be assigned.
'''
result = self._values.get("load_balancer_name")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def load_balancer_spec(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
loadBalancerSpec: The specification of the load balancer. If not specified, it is same with the source load balancer.
Note If InstanceChargeType is set to PayByCLCU, the LoadBalancerSpec parameter is invalid and you do not need to set this parameter.
'''
result = self._values.get("load_balancer_spec")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def resource_group_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: resourceGroupId: Resource group id.
'''
result = self._values.get("resource_group_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def tags(self) -> typing.Optional[typing.List[RosLoadBalancerClone.TagsProperty]]:
'''
:Property: tags: Tags to attach to slb. Max support 5 tags to add during create slb. Each tag with two properties Key and Value, and Key is required.
'''
result = self._values.get("tags")
return typing.cast(typing.Optional[typing.List[RosLoadBalancerClone.TagsProperty]], result)
@builtins.property
def tags_policy(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
tagsPolicy: Solution for handle the tags. If select 'clone', it will clone from source load balancer. If select 'empty' it will not copy tags. If select 'append' it will append the new tags. If select 'replace' it will add new tags.
Default is 'empty'.
'''
result = self._values.get("tags_policy")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def v_switch_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: vSwitchId: The new VSwitch ID to create load balancer instance. For VPC network only and the VSwitch should belong to the VPC which source load balancer is located.When not specified, source load balancer VSwitch ID will be used.
'''
result = self._values.get("v_switch_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "RosLoadBalancerCloneProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-slb.RosLoadBalancerProps",
jsii_struct_bases=[],
name_mapping={
"address_ip_version": "addressIpVersion",
"address_type": "addressType",
"auto_pay": "autoPay",
"auto_renew": "autoRenew",
"auto_renew_period": "autoRenewPeriod",
"bandwidth": "bandwidth",
"deletion_protection": "deletionProtection",
"duration": "duration",
"instance_charge_type": "instanceChargeType",
"internet_charge_type": "internetChargeType",
"load_balancer_name": "loadBalancerName",
"load_balancer_spec": "loadBalancerSpec",
"master_zone_id": "masterZoneId",
"modification_protection_reason": "modificationProtectionReason",
"modification_protection_status": "modificationProtectionStatus",
"pay_type": "payType",
"pricing_cycle": "pricingCycle",
"resource_group_id": "resourceGroupId",
"slave_zone_id": "slaveZoneId",
"tags": "tags",
"vpc_id": "vpcId",
"v_switch_id": "vSwitchId",
},
)
class RosLoadBalancerProps:
def __init__(
self,
*,
address_ip_version: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
address_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
auto_pay: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
auto_renew: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
auto_renew_period: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
bandwidth: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
deletion_protection: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
duration: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
instance_charge_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
internet_charge_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
load_balancer_name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
load_balancer_spec: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
master_zone_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
modification_protection_reason: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
modification_protection_status: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
pay_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
pricing_cycle: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
resource_group_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
slave_zone_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
tags: typing.Optional[typing.Sequence[typing.Union[RosLoadBalancer.TagsProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
vpc_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
v_switch_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::SLB::LoadBalancer``.
:param address_ip_version:
:param address_type:
:param auto_pay:
:param auto_renew:
:param auto_renew_period:
:param bandwidth:
:param deletion_protection:
:param duration:
:param instance_charge_type:
:param internet_charge_type:
:param load_balancer_name:
:param load_balancer_spec:
:param master_zone_id:
:param modification_protection_reason:
:param modification_protection_status:
:param pay_type:
:param pricing_cycle:
:param resource_group_id:
:param slave_zone_id:
:param tags:
:param vpc_id:
:param v_switch_id:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__6c3c7c21484380419d0b84f94989c51d7124ad033f24021f30aedcd89f51feab)
check_type(argname="argument address_ip_version", value=address_ip_version, expected_type=type_hints["address_ip_version"])
check_type(argname="argument address_type", value=address_type, expected_type=type_hints["address_type"])
check_type(argname="argument auto_pay", value=auto_pay, expected_type=type_hints["auto_pay"])
check_type(argname="argument auto_renew", value=auto_renew, expected_type=type_hints["auto_renew"])
check_type(argname="argument auto_renew_period", value=auto_renew_period, expected_type=type_hints["auto_renew_period"])
check_type(argname="argument bandwidth", value=bandwidth, expected_type=type_hints["bandwidth"])
check_type(argname="argument deletion_protection", value=deletion_protection, expected_type=type_hints["deletion_protection"])
check_type(argname="argument duration", value=duration, expected_type=type_hints["duration"])
check_type(argname="argument instance_charge_type", value=instance_charge_type, expected_type=type_hints["instance_charge_type"])
check_type(argname="argument internet_charge_type", value=internet_charge_type, expected_type=type_hints["internet_charge_type"])
check_type(argname="argument load_balancer_name", value=load_balancer_name, expected_type=type_hints["load_balancer_name"])
check_type(argname="argument load_balancer_spec", value=load_balancer_spec, expected_type=type_hints["load_balancer_spec"])
check_type(argname="argument master_zone_id", value=master_zone_id, expected_type=type_hints["master_zone_id"])
check_type(argname="argument modification_protection_reason", value=modification_protection_reason, expected_type=type_hints["modification_protection_reason"])
check_type(argname="argument modification_protection_status", value=modification_protection_status, expected_type=type_hints["modification_protection_status"])
check_type(argname="argument pay_type", value=pay_type, expected_type=type_hints["pay_type"])
check_type(argname="argument pricing_cycle", value=pricing_cycle, expected_type=type_hints["pricing_cycle"])
check_type(argname="argument resource_group_id", value=resource_group_id, expected_type=type_hints["resource_group_id"])
check_type(argname="argument slave_zone_id", value=slave_zone_id, expected_type=type_hints["slave_zone_id"])
check_type(argname="argument tags", value=tags, expected_type=type_hints["tags"])
check_type(argname="argument vpc_id", value=vpc_id, expected_type=type_hints["vpc_id"])
check_type(argname="argument v_switch_id", value=v_switch_id, expected_type=type_hints["v_switch_id"])
self._values: typing.Dict[builtins.str, typing.Any] = {}
if address_ip_version is not None:
self._values["address_ip_version"] = address_ip_version
if address_type is not None:
self._values["address_type"] = address_type
if auto_pay is not None:
self._values["auto_pay"] = auto_pay
if auto_renew is not None:
self._values["auto_renew"] = auto_renew
if auto_renew_period is not None:
self._values["auto_renew_period"] = auto_renew_period
if bandwidth is not None:
self._values["bandwidth"] = bandwidth
if deletion_protection is not None:
self._values["deletion_protection"] = deletion_protection
if duration is not None:
self._values["duration"] = duration
if instance_charge_type is not None:
self._values["instance_charge_type"] = instance_charge_type
if internet_charge_type is not None:
self._values["internet_charge_type"] = internet_charge_type
if load_balancer_name is not None:
self._values["load_balancer_name"] = load_balancer_name
if load_balancer_spec is not None:
self._values["load_balancer_spec"] = load_balancer_spec
if master_zone_id is not None:
self._values["master_zone_id"] = master_zone_id
if modification_protection_reason is not None:
self._values["modification_protection_reason"] = modification_protection_reason
if modification_protection_status is not None:
self._values["modification_protection_status"] = modification_protection_status
if pay_type is not None:
self._values["pay_type"] = pay_type
if pricing_cycle is not None:
self._values["pricing_cycle"] = pricing_cycle
if resource_group_id is not None:
self._values["resource_group_id"] = resource_group_id
if slave_zone_id is not None:
self._values["slave_zone_id"] = slave_zone_id
if tags is not None:
self._values["tags"] = tags
if vpc_id is not None:
self._values["vpc_id"] = vpc_id
if v_switch_id is not None:
self._values["v_switch_id"] = v_switch_id
@builtins.property
def address_ip_version(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: addressIpVersion: IP version, support 'ipv4' or 'ipv6'. If 'ipv6' is selected, please note that the zone and the specification are supported.
'''
result = self._values.get("address_ip_version")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def address_type(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
addressType: The network type of the CLB instance. Valid values:
- **internet** (default): After an internet-facing CLB instance is created, the system assigns a public IP address to the CLB instance. Then, the CLB instance can forward requests over the Internet.
- **intranet**: After an internal-facing CLB instance is created, the system assigns a private IP address to the CLB instance. Then, the CLB instance can forward requests only over the internal networks.
'''
result = self._values.get("address_type")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def auto_pay(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
autoPay: Specifies whether to automatically pay for the subscription Internet-facing CLB instance. Valid values:
- **true**: automatically pays for the CLB instance. After you call this operation, the system automatically completes the payment and creates the CLB instance.- **false** (default): After you call the operation, the order is created but the payment is not completed. You can view the pending order in the console. The CLB instance will not be created until you complete the payment.**Note** This parameter is supported only by subscription instances created on the Alibaba Cloud China site.
'''
result = self._values.get("auto_pay")
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def auto_renew(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: autoRenew: Indicates whether automatic renewal is enabled for the instance. Valid values:- **true**: Automatic renewal is enabled.- **false** (default): Automatic renewal is not enabled. You must renew the instance manually.
'''
result = self._values.get("auto_renew")
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def auto_renew_period(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
autoRenewPeriod: Automatic renewal cycle, which takes effect when AutoRenew is true, and is required:
When PricingCycle = month, the value range is 1 to 9 or 12, 24, 36.
When PeriodUnit = year, the value range is 1-3.
'''
result = self._values.get("auto_renew_period")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def bandwidth(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: bandwidth: The bandwidth for network, unit in Mbps(Mega bit per second). Default is 1. If InternetChargeType is specified as "paybytraffic", this property will be ignore and please specify the "Bandwidth" in ALIYUN::SLB::Listener.
'''
result = self._values.get("bandwidth")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def deletion_protection(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: deletionProtection: Whether to enable deletion protection.
'''
result = self._values.get("deletion_protection")
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def duration(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
duration: Optional. The subscription duration of a Subscription Internet instance.
Valid values:
If PricingCycle is month, the valid range is 1 to 9 or 12, 24, 36, 48, 60.
If PricingCycle is year, the value range is 1 to 5.
'''
result = self._values.get("duration")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def instance_charge_type(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
instanceChargeType: Instance billing method. Valid value:
- **PayBySpec** (default): Pay by spec.
- **PayByCLCU**: billed by usage.
'''
result = self._values.get("instance_charge_type")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def internet_charge_type(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
internetChargeType: The metering method of the Internet-facing CLB instance. Valid values:
- **paybytraffic** (default): If you set the value to paybytraffic, you do not need to specify Bandwidth. Even if you specify Bandwidth, the value does not take effect.
- **paybybandwidth**: pay-by-bandwidth.
**Note** If you set PayType to PayOnDemand and set InstanceChargeType to PayByCLCU, you must set InternetChargeType to paybytraffic.
'''
result = self._values.get("internet_charge_type")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def load_balancer_name(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: loadBalancerName: Name of created load balancer. Length is limited to 1-80 characters, allowed to contain letters, numbers, '-, /, _,.' When not specified, a default name will be assigned.
'''
result = self._values.get("load_balancer_name")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def load_balancer_spec(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
loadBalancerSpec: The specification of the CLB instance. Valid values:
- **slb.s1.small**
- **slb.s2.small**
- **slb.s2.medium**
- **slb.s3.small**
- **slb.s3.medium**
- **slb.s3.large**
**Note** If you do not specify this parameter, a shared-resource CLB instance is created. Shared-resource CLB instances are no longer available for purchase. Therefore, you must specify this parameter.
If InstanceChargeType is set to PayByCLCU, this parameter is invalid and you do not need to specify this parameter.
'''
result = self._values.get("load_balancer_spec")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def master_zone_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: masterZoneId: The master zone id to create load balancer instance.
'''
result = self._values.get("master_zone_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def modification_protection_reason(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
modificationProtectionReason: Set the reason for modifying the protection status. The length is 1-80 English or Chinese characters, must start with upper and lower letters or Chinese, and can include numbers, periods (.), underscores (_) and dashes (-).
Only valid when ModificationProtectionStatus is ConsoleProtection.
'''
result = self._values.get("modification_protection_reason")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def modification_protection_status(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
modificationProtectionStatus: NonProtection or empty: means no restriction on modification protection
ConsoleProtection: Modify instance protection status by console
Default value is empty.
'''
result = self._values.get("modification_protection_status")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def pay_type(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
payType: Optional. The billing method of the instance to be created.
Valid value: PayOnDemand (Pay-As-You-Go) | PrePay (Subscription)
'''
result = self._values.get("pay_type")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def pricing_cycle(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
pricingCycle: Optional. The duration of the Subscription-billed Internet instance to be created.
Valid values: month | year.
'''
result = self._values.get("pricing_cycle")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def resource_group_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: resourceGroupId: Resource group id.
'''
result = self._values.get("resource_group_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def slave_zone_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: slaveZoneId: The slave zone id to create load balancer instance.
'''
result = self._values.get("slave_zone_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def tags(self) -> typing.Optional[typing.List[RosLoadBalancer.TagsProperty]]:
'''
:Property: tags: Tags to attach to slb. Max support 5 tags to add during create slb. Each tag with two properties Key and Value, and Key is required.
'''
result = self._values.get("tags")
return typing.cast(typing.Optional[typing.List[RosLoadBalancer.TagsProperty]], result)
@builtins.property
def vpc_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: vpcId: The VPC id to create load balancer instance. For VPC network only.
'''
result = self._values.get("vpc_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def v_switch_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: vSwitchId: The VSwitch id to create load balancer instance. For VPC network only.
'''
result = self._values.get("v_switch_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "RosLoadBalancerProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class RosMasterSlaveServerGroup(
_ros_cdk_core_7adfd82f.RosResource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-slb.RosMasterSlaveServerGroup",
):
'''A ROS template type: ``ALIYUN::SLB::MasterSlaveServerGroup``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["RosMasterSlaveServerGroupProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
'''Create a new ``ALIYUN::SLB::MasterSlaveServerGroup``.
:param scope: - scope in which this resource is defined.
:param id: - scoped id of the resource.
:param props: - resource properties.
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__9b027e39a65387002d3b41dad2136cb43573e845c5db037a80126ebcea80dc32)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@jsii.member(jsii_name="renderProperties")
def _render_properties(
self,
props: typing.Mapping[builtins.str, typing.Any],
) -> typing.Mapping[builtins.str, typing.Any]:
'''
:param props: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__09e82a2246bd0ac3e4b9e8414f998d2e5e418f9907dd37b4bf3abeeb589aa2f0)
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))
@jsii.python.classproperty
@jsii.member(jsii_name="ROS_RESOURCE_TYPE_NAME")
def ROS_RESOURCE_TYPE_NAME(cls) -> builtins.str:
'''The resource type name for this resource class.'''
return typing.cast(builtins.str, jsii.sget(cls, "ROS_RESOURCE_TYPE_NAME"))
@builtins.property
@jsii.member(jsii_name="attrMasterSlaveServerGroupId")
def attr_master_slave_server_group_id(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: MasterSlaveServerGroupId: Active/standby server group ID.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrMasterSlaveServerGroupId"))
@builtins.property
@jsii.member(jsii_name="rosProperties")
def _ros_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "rosProperties"))
@builtins.property
@jsii.member(jsii_name="enableResourcePropertyConstraint")
def enable_resource_property_constraint(self) -> builtins.bool:
return typing.cast(builtins.bool, jsii.get(self, "enableResourcePropertyConstraint"))
@enable_resource_property_constraint.setter
def enable_resource_property_constraint(self, value: builtins.bool) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__c3ec39fcdb64c9082e573191dfc2592772a8b0e2a32ceb9c799eea8ca3ba8ad8)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "enableResourcePropertyConstraint", value)
@builtins.property
@jsii.member(jsii_name="loadBalancerId")
def load_balancer_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: loadBalancerId: The ID of the Server Load Balancer instance.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "loadBalancerId"))
@load_balancer_id.setter
def load_balancer_id(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__61c090bd1815fac5e202c8904b7382185428de29015efcac6a21bb40ddba3bb0)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "loadBalancerId", value)
@builtins.property
@jsii.member(jsii_name="masterSlaveBackendServers")
def master_slave_backend_servers(
self,
) -> typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosMasterSlaveServerGroup.MasterSlaveBackendServersProperty"]]]:
'''
:Property:
masterSlaveBackendServers: A list of active/standby server group.
An active/standby server group can only contain two backend servers.
'''
return typing.cast(typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosMasterSlaveServerGroup.MasterSlaveBackendServersProperty"]]], jsii.get(self, "masterSlaveBackendServers"))
@master_slave_backend_servers.setter
def master_slave_backend_servers(
self,
value: typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosMasterSlaveServerGroup.MasterSlaveBackendServersProperty"]]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__5592b534a8ec18b667f402ab3f004e509d58c2824d4159df914328154e057527)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "masterSlaveBackendServers", value)
@builtins.property
@jsii.member(jsii_name="masterSlaveServerGroupName")
def master_slave_server_group_name(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: masterSlaveServerGroupName: The name of the active/standby server group.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "masterSlaveServerGroupName"))
@master_slave_server_group_name.setter
def master_slave_server_group_name(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__7a70b1411831fcb5edda90c810638bae0ee8f5eb2b2e65603c1a53dccbe35bb9)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "masterSlaveServerGroupName", value)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-slb.RosMasterSlaveServerGroup.MasterSlaveBackendServersProperty",
jsii_struct_bases=[],
name_mapping={
"port": "port",
"server_id": "serverId",
"weight": "weight",
"server_type": "serverType",
},
)
class MasterSlaveBackendServersProperty:
def __init__(
self,
*,
port: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
server_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
weight: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
server_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''
:param port:
:param server_id:
:param weight:
:param server_type:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__25e0e06986d1255c0ccf0c175f1ef5ab0f7cbc81ec53c1f2323b4f35449b3cb9)
check_type(argname="argument port", value=port, expected_type=type_hints["port"])
check_type(argname="argument server_id", value=server_id, expected_type=type_hints["server_id"])
check_type(argname="argument weight", value=weight, expected_type=type_hints["weight"])
check_type(argname="argument server_type", value=server_type, expected_type=type_hints["server_type"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"port": port,
"server_id": server_id,
"weight": weight,
}
if server_type is not None:
self._values["server_type"] = server_type
@builtins.property
def port(self) -> typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: port: The port used by backend server. From 1 to 65535
'''
result = self._values.get("port")
assert result is not None, "Required property 'port' is missing"
return typing.cast(typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def server_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: serverId: ECS instance ID
'''
result = self._values.get("server_id")
assert result is not None, "Required property 'server_id' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def weight(
self,
) -> typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: weight: The weight of backend server of load balancer. From 0 to 100, 0 means offline. Default is 100.
'''
result = self._values.get("weight")
assert result is not None, "Required property 'weight' is missing"
return typing.cast(typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def server_type(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: serverType: The identity of backend server. Could be "Master" (default) or "Slave"
'''
result = self._values.get("server_type")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "MasterSlaveBackendServersProperty(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-slb.RosMasterSlaveServerGroupProps",
jsii_struct_bases=[],
name_mapping={
"load_balancer_id": "loadBalancerId",
"master_slave_backend_servers": "masterSlaveBackendServers",
"master_slave_server_group_name": "masterSlaveServerGroupName",
},
)
class RosMasterSlaveServerGroupProps:
def __init__(
self,
*,
load_balancer_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
master_slave_backend_servers: typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union[RosMasterSlaveServerGroup.MasterSlaveBackendServersProperty, typing.Dict[builtins.str, typing.Any]]]]],
master_slave_server_group_name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::SLB::MasterSlaveServerGroup``.
:param load_balancer_id:
:param master_slave_backend_servers:
:param master_slave_server_group_name:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__cd97e9773855b4776a284c30d03fdb9067f6d27bbe78804460239dcac1c732f5)
check_type(argname="argument load_balancer_id", value=load_balancer_id, expected_type=type_hints["load_balancer_id"])
check_type(argname="argument master_slave_backend_servers", value=master_slave_backend_servers, expected_type=type_hints["master_slave_backend_servers"])
check_type(argname="argument master_slave_server_group_name", value=master_slave_server_group_name, expected_type=type_hints["master_slave_server_group_name"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"load_balancer_id": load_balancer_id,
"master_slave_backend_servers": master_slave_backend_servers,
}
if master_slave_server_group_name is not None:
self._values["master_slave_server_group_name"] = master_slave_server_group_name
@builtins.property
def load_balancer_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: loadBalancerId: The ID of the Server Load Balancer instance.
'''
result = self._values.get("load_balancer_id")
assert result is not None, "Required property 'load_balancer_id' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def master_slave_backend_servers(
self,
) -> typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, RosMasterSlaveServerGroup.MasterSlaveBackendServersProperty]]]:
'''
:Property:
masterSlaveBackendServers: A list of active/standby server group.
An active/standby server group can only contain two backend servers.
'''
result = self._values.get("master_slave_backend_servers")
assert result is not None, "Required property 'master_slave_backend_servers' is missing"
return typing.cast(typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, RosMasterSlaveServerGroup.MasterSlaveBackendServersProperty]]], result)
@builtins.property
def master_slave_server_group_name(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: masterSlaveServerGroupName: The name of the active/standby server group.
'''
result = self._values.get("master_slave_server_group_name")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "RosMasterSlaveServerGroupProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class RosRule(
_ros_cdk_core_7adfd82f.RosResource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-slb.RosRule",
):
'''A ROS template type: ``ALIYUN::SLB::Rule``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["RosRuleProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
'''Create a new ``ALIYUN::SLB::Rule``.
:param scope: - scope in which this resource is defined.
:param id: - scoped id of the resource.
:param props: - resource properties.
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__bfa316001bdbed0ac85141c35c10150aa45356e0250b8f0cdec86e328961ee0e)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@jsii.member(jsii_name="renderProperties")
def _render_properties(
self,
props: typing.Mapping[builtins.str, typing.Any],
) -> typing.Mapping[builtins.str, typing.Any]:
'''
:param props: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__ea608b45e67109620c8226e05c3f00431cf6fe4d106bc6a821d586353c8f53e8)
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))
@jsii.python.classproperty
@jsii.member(jsii_name="ROS_RESOURCE_TYPE_NAME")
def ROS_RESOURCE_TYPE_NAME(cls) -> builtins.str:
'''The resource type name for this resource class.'''
return typing.cast(builtins.str, jsii.sget(cls, "ROS_RESOURCE_TYPE_NAME"))
@builtins.property
@jsii.member(jsii_name="attrRules")
def attr_rules(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: Rules: A list of forwarding rules. Each element of rules contains "RuleId".
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrRules"))
@builtins.property
@jsii.member(jsii_name="rosProperties")
def _ros_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "rosProperties"))
@builtins.property
@jsii.member(jsii_name="enableResourcePropertyConstraint")
def enable_resource_property_constraint(self) -> builtins.bool:
return typing.cast(builtins.bool, jsii.get(self, "enableResourcePropertyConstraint"))
@enable_resource_property_constraint.setter
def enable_resource_property_constraint(self, value: builtins.bool) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__90ba6edbaad0b0c58f9ffe60cf34c10c1e49632a64516f0f92911f481b7339a9)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "enableResourcePropertyConstraint", value)
@builtins.property
@jsii.member(jsii_name="listenerPort")
def listener_port(
self,
) -> typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
listenerPort: The front-end HTTPS listener port of the Server Load Balancer instance. Valid value:
1-65535
'''
return typing.cast(typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "listenerPort"))
@listener_port.setter
def listener_port(
self,
value: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__c810b3c0e69113845e4309585fe13e5f46863ca80ae40d64d97b963fe34ff7df)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "listenerPort", value)
@builtins.property
@jsii.member(jsii_name="loadBalancerId")
def load_balancer_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: loadBalancerId: The ID of Server Load Balancer instance.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "loadBalancerId"))
@load_balancer_id.setter
def load_balancer_id(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__4a5e262b0586e5621d14e723a0acb7530ac9c5a47f8386ce9549edeea60bdb86)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "loadBalancerId", value)
@builtins.property
@jsii.member(jsii_name="ruleList")
def rule_list(
self,
) -> typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosRule.RuleListProperty"]]]:
'''
:Property: ruleList: The forwarding rules to add.
'''
return typing.cast(typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosRule.RuleListProperty"]]], jsii.get(self, "ruleList"))
@rule_list.setter
def rule_list(
self,
value: typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosRule.RuleListProperty"]]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__192e030dac8bf63634821eaff61966328a544f58e0b1664f776ce03768baaa3f)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "ruleList", value)
@builtins.property
@jsii.member(jsii_name="listenerProtocol")
def listener_protocol(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: listenerProtocol: The frontend protocol that is used by the SLB instance.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "listenerProtocol"))
@listener_protocol.setter
def listener_protocol(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__a17b2a2adb12b8361c26dc68ba94cf2fa5de3c3d6fa96da1eb09275a3b2a6be4)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "listenerProtocol", value)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-slb.RosRule.AdvancedSettingsProperty",
jsii_struct_bases=[],
name_mapping={
"cookie": "cookie",
"cookie_timeout": "cookieTimeout",
"health_check": "healthCheck",
"health_check_connect_port": "healthCheckConnectPort",
"health_check_domain": "healthCheckDomain",
"health_check_http_code": "healthCheckHttpCode",
"health_check_interval": "healthCheckInterval",
"health_check_timeout": "healthCheckTimeout",
"health_check_uri": "healthCheckUri",
"healthy_threshold": "healthyThreshold",
"listener_sync": "listenerSync",
"scheduler": "scheduler",
"sticky_session": "stickySession",
"sticky_session_type": "stickySessionType",
"unhealthy_threshold": "unhealthyThreshold",
},
)
class AdvancedSettingsProperty:
def __init__(
self,
*,
cookie: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
cookie_timeout: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
health_check: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
health_check_connect_port: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
health_check_domain: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
health_check_http_code: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
health_check_interval: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
health_check_timeout: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
health_check_uri: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
healthy_threshold: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
listener_sync: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
scheduler: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
sticky_session: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
sticky_session_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
unhealthy_threshold: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''
:param cookie:
:param cookie_timeout:
:param health_check:
:param health_check_connect_port:
:param health_check_domain:
:param health_check_http_code:
:param health_check_interval:
:param health_check_timeout:
:param health_check_uri:
:param healthy_threshold:
:param listener_sync:
:param scheduler:
:param sticky_session:
:param sticky_session_type:
:param unhealthy_threshold:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__0e3f32f522b93e5be096b6298c2e6fd02b536e3e5e7fa12ab16272d2313d04f2)
check_type(argname="argument cookie", value=cookie, expected_type=type_hints["cookie"])
check_type(argname="argument cookie_timeout", value=cookie_timeout, expected_type=type_hints["cookie_timeout"])
check_type(argname="argument health_check", value=health_check, expected_type=type_hints["health_check"])
check_type(argname="argument health_check_connect_port", value=health_check_connect_port, expected_type=type_hints["health_check_connect_port"])
check_type(argname="argument health_check_domain", value=health_check_domain, expected_type=type_hints["health_check_domain"])
check_type(argname="argument health_check_http_code", value=health_check_http_code, expected_type=type_hints["health_check_http_code"])
check_type(argname="argument health_check_interval", value=health_check_interval, expected_type=type_hints["health_check_interval"])
check_type(argname="argument health_check_timeout", value=health_check_timeout, expected_type=type_hints["health_check_timeout"])
check_type(argname="argument health_check_uri", value=health_check_uri, expected_type=type_hints["health_check_uri"])
check_type(argname="argument healthy_threshold", value=healthy_threshold, expected_type=type_hints["healthy_threshold"])
check_type(argname="argument listener_sync", value=listener_sync, expected_type=type_hints["listener_sync"])
check_type(argname="argument scheduler", value=scheduler, expected_type=type_hints["scheduler"])
check_type(argname="argument sticky_session", value=sticky_session, expected_type=type_hints["sticky_session"])
check_type(argname="argument sticky_session_type", value=sticky_session_type, expected_type=type_hints["sticky_session_type"])
check_type(argname="argument unhealthy_threshold", value=unhealthy_threshold, expected_type=type_hints["unhealthy_threshold"])
self._values: typing.Dict[builtins.str, typing.Any] = {}
if cookie is not None:
self._values["cookie"] = cookie
if cookie_timeout is not None:
self._values["cookie_timeout"] = cookie_timeout
if health_check is not None:
self._values["health_check"] = health_check
if health_check_connect_port is not None:
self._values["health_check_connect_port"] = health_check_connect_port
if health_check_domain is not None:
self._values["health_check_domain"] = health_check_domain
if health_check_http_code is not None:
self._values["health_check_http_code"] = health_check_http_code
if health_check_interval is not None:
self._values["health_check_interval"] = health_check_interval
if health_check_timeout is not None:
self._values["health_check_timeout"] = health_check_timeout
if health_check_uri is not None:
self._values["health_check_uri"] = health_check_uri
if healthy_threshold is not None:
self._values["healthy_threshold"] = healthy_threshold
if listener_sync is not None:
self._values["listener_sync"] = listener_sync
if scheduler is not None:
self._values["scheduler"] = scheduler
if sticky_session is not None:
self._values["sticky_session"] = sticky_session
if sticky_session_type is not None:
self._values["sticky_session_type"] = sticky_session_type
if unhealthy_threshold is not None:
self._values["unhealthy_threshold"] = unhealthy_threshold
@builtins.property
def cookie(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
cookie: The cookie that is configured on the server.
The cookie must be 1 to 200 characters in length and can contain only ASCII characters and digits. It cannot contain commas (,), semicolons (;), or space characters. It cannot start with a dollar sign ($).
'''
result = self._values.get("cookie")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def cookie_timeout(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: cookieTimeout: The timeout period of a cookie. Unit: seconds.
'''
result = self._values.get("cookie_timeout")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def health_check(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
healthCheck: Specifies whether to enable the health check feature. Valid values:
on: yes
off: no
'''
result = self._values.get("health_check")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def health_check_connect_port(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: healthCheckConnectPort: The port that is used for health checks. Valid values: 1 to 65535.
'''
result = self._values.get("health_check_connect_port")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def health_check_domain(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
healthCheckDomain: The domain name that is used for health checks. Valid values:
$_ip: the private IP address of a backend server. If you do not set this parameter or set the parameter to $_ip, the SLB instance uses the private IP address of each backend server for health checks.
domain: The domain name must be 1 to 80 characters in length, and can contain letters, digits, periods (.), and hyphens (-).
'''
result = self._values.get("health_check_domain")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def health_check_http_code(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
healthCheckHttpCode: The HTTP status code for a successful health check. Multiple HTTP status codes are separated by commas (,).
Valid values: http_2xx, http_3xx, http_4xx, and http_5xx.
'''
result = self._values.get("health_check_http_code")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def health_check_interval(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: healthCheckInterval: The interval between two consecutive health checks. Unit: seconds. Valid values: 1 to 50.
'''
result = self._values.get("health_check_interval")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def health_check_timeout(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: healthCheckTimeout: The timeout period of a health check response. If a backend server, such as an Elastic Compute Service (ECS) instance, does not return a health check response within the specified timeout period, the server fails the health check. Unit: seconds. Valid values: 1 to 300.
'''
result = self._values.get("health_check_timeout")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def health_check_uri(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: healthCheckUri: The URI that is used for health checks.
'''
result = self._values.get("health_check_uri")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def healthy_threshold(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: healthyThreshold: The number of times that an unhealthy backend server must consecutively pass health checks before it is declared healthy. In this case, the health status is changed from fail to success.
'''
result = self._values.get("healthy_threshold")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def listener_sync(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
listenerSync: Specifies whether to use the scheduling algorithm, session persistence, and health check configurations of the listener. Valid values:
on: uses the configurations of the listener.
off: does not use the configurations of the listener. You can customize the health check and session persistence configurations for the forwarding rule.
'''
result = self._values.get("listener_sync")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def scheduler(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
scheduler: The scheduling algorithm. Valid values:
wrr: Backend servers with higher weights receive more requests than those with lower weights.
rr: Requests are distributed to backend servers in sequence.
'''
result = self._values.get("scheduler")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def sticky_session(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
stickySession: Specifies whether to enable session persistence. Valid values:
on: yes
off: no
'''
result = self._values.get("sticky_session")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def sticky_session_type(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
stickySessionType: The method that is used to handle a cookie. Valid values:
insert: inserts a cookie.
server: rewrites a cookie.
'''
result = self._values.get("sticky_session_type")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def unhealthy_threshold(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: unhealthyThreshold: The number of times that a healthy backend server must consecutively fail health checks before it is declared unhealthy. In this case, the health status is changed from success to fail.
'''
result = self._values.get("unhealthy_threshold")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "AdvancedSettingsProperty(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-slb.RosRule.RuleListProperty",
jsii_struct_bases=[],
name_mapping={
"rule_name": "ruleName",
"v_server_group_id": "vServerGroupId",
"advanced_settings": "advancedSettings",
"domain": "domain",
"url": "url",
},
)
class RuleListProperty:
def __init__(
self,
*,
rule_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
v_server_group_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
advanced_settings: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union["RosRule.AdvancedSettingsProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
domain: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
url: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''
:param rule_name:
:param v_server_group_id:
:param advanced_settings:
:param domain:
:param url:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__678956d97f1cf53c67fa2e352dc14294c41fe2477d9e33c6ad5a40c30d7c4dbe)
check_type(argname="argument rule_name", value=rule_name, expected_type=type_hints["rule_name"])
check_type(argname="argument v_server_group_id", value=v_server_group_id, expected_type=type_hints["v_server_group_id"])
check_type(argname="argument advanced_settings", value=advanced_settings, expected_type=type_hints["advanced_settings"])
check_type(argname="argument domain", value=domain, expected_type=type_hints["domain"])
check_type(argname="argument url", value=url, expected_type=type_hints["url"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"rule_name": rule_name,
"v_server_group_id": v_server_group_id,
}
if advanced_settings is not None:
self._values["advanced_settings"] = advanced_settings
if domain is not None:
self._values["domain"] = domain
if url is not None:
self._values["url"] = url
@builtins.property
def rule_name(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: ruleName: The name of the forwarding rule.
'''
result = self._values.get("rule_name")
assert result is not None, "Required property 'rule_name' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def v_server_group_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: vServerGroupId: The ID of the VServer group associated with the forwarding rule.
'''
result = self._values.get("v_server_group_id")
assert result is not None, "Required property 'v_server_group_id' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def advanced_settings(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosRule.AdvancedSettingsProperty"]]:
'''
:Property: advancedSettings: The advanced settings of the rule.
'''
result = self._values.get("advanced_settings")
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosRule.AdvancedSettingsProperty"]], result)
@builtins.property
def domain(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: domain: The domain name.
'''
result = self._values.get("domain")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def url(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: url: The URL.
'''
result = self._values.get("url")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "RuleListProperty(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-slb.RosRuleProps",
jsii_struct_bases=[],
name_mapping={
"listener_port": "listenerPort",
"load_balancer_id": "loadBalancerId",
"rule_list": "ruleList",
"listener_protocol": "listenerProtocol",
},
)
class RosRuleProps:
def __init__(
self,
*,
listener_port: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
load_balancer_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
rule_list: typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union[RosRule.RuleListProperty, typing.Dict[builtins.str, typing.Any]]]]],
listener_protocol: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::SLB::Rule``.
:param listener_port:
:param load_balancer_id:
:param rule_list:
:param listener_protocol:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__6adbefceaba654aea7652f24b4f2145c82614eb14f44783867c486f0efca7a9e)
check_type(argname="argument listener_port", value=listener_port, expected_type=type_hints["listener_port"])
check_type(argname="argument load_balancer_id", value=load_balancer_id, expected_type=type_hints["load_balancer_id"])
check_type(argname="argument rule_list", value=rule_list, expected_type=type_hints["rule_list"])
check_type(argname="argument listener_protocol", value=listener_protocol, expected_type=type_hints["listener_protocol"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"listener_port": listener_port,
"load_balancer_id": load_balancer_id,
"rule_list": rule_list,
}
if listener_protocol is not None:
self._values["listener_protocol"] = listener_protocol
@builtins.property
def listener_port(
self,
) -> typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
listenerPort: The front-end HTTPS listener port of the Server Load Balancer instance. Valid value:
1-65535
'''
result = self._values.get("listener_port")
assert result is not None, "Required property 'listener_port' is missing"
return typing.cast(typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def load_balancer_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: loadBalancerId: The ID of Server Load Balancer instance.
'''
result = self._values.get("load_balancer_id")
assert result is not None, "Required property 'load_balancer_id' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def rule_list(
self,
) -> typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, RosRule.RuleListProperty]]]:
'''
:Property: ruleList: The forwarding rules to add.
'''
result = self._values.get("rule_list")
assert result is not None, "Required property 'rule_list' is missing"
return typing.cast(typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, RosRule.RuleListProperty]]], result)
@builtins.property
def listener_protocol(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: listenerProtocol: The frontend protocol that is used by the SLB instance.
'''
result = self._values.get("listener_protocol")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "RosRuleProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class RosVServerGroup(
_ros_cdk_core_7adfd82f.RosResource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-slb.RosVServerGroup",
):
'''A ROS template type: ``ALIYUN::SLB::VServerGroup``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["RosVServerGroupProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
'''Create a new ``ALIYUN::SLB::VServerGroup``.
:param scope: - scope in which this resource is defined.
:param id: - scoped id of the resource.
:param props: - resource properties.
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__ba0ae8b794bafc8987cda1cae4ab1c592036f2b54c4e27b3bff7281c40b54e65)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@jsii.member(jsii_name="renderProperties")
def _render_properties(
self,
props: typing.Mapping[builtins.str, typing.Any],
) -> typing.Mapping[builtins.str, typing.Any]:
'''
:param props: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__f4e6b1b355ca5a7ee3ac0be75a0721d7868fd9636af5a2bd3a250d5e00a1cac2)
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))
@jsii.python.classproperty
@jsii.member(jsii_name="ROS_RESOURCE_TYPE_NAME")
def ROS_RESOURCE_TYPE_NAME(cls) -> builtins.str:
'''The resource type name for this resource class.'''
return typing.cast(builtins.str, jsii.sget(cls, "ROS_RESOURCE_TYPE_NAME"))
@builtins.property
@jsii.member(jsii_name="attrBackendServers")
def attr_backend_servers(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: BackendServers: Backend server list in this VServerGroup.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrBackendServers"))
@builtins.property
@jsii.member(jsii_name="attrVServerGroupId")
def attr_v_server_group_id(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: VServerGroupId: The id of VServerGroup created.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrVServerGroupId"))
@builtins.property
@jsii.member(jsii_name="rosProperties")
def _ros_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "rosProperties"))
@builtins.property
@jsii.member(jsii_name="enableResourcePropertyConstraint")
def enable_resource_property_constraint(self) -> builtins.bool:
return typing.cast(builtins.bool, jsii.get(self, "enableResourcePropertyConstraint"))
@enable_resource_property_constraint.setter
def enable_resource_property_constraint(self, value: builtins.bool) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__a4def502340c7d5a5aba934ba24dd5efa80b9fe159b46e94889347ae3aac3271)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "enableResourcePropertyConstraint", value)
@builtins.property
@jsii.member(jsii_name="loadBalancerId")
def load_balancer_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: loadBalancerId: The id of load balancer.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "loadBalancerId"))
@load_balancer_id.setter
def load_balancer_id(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__eb14d63fc0a051c9d593d68b08daeae085bc2e5fb72dcc123c7df6bfacf81102)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "loadBalancerId", value)
@builtins.property
@jsii.member(jsii_name="vServerGroupName")
def v_server_group_name(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: vServerGroupName: Display name of the VServerGroup.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "vServerGroupName"))
@v_server_group_name.setter
def v_server_group_name(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__2c21a95804741692bb8ea191692365d03db626e96cb6b7994c5694398359a36e)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "vServerGroupName", value)
@builtins.property
@jsii.member(jsii_name="backendServers")
def backend_servers(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosVServerGroup.BackendServersProperty"]]]]:
'''
:Property: backendServers: The list of a combination of ECS Instance-Port-Weight.Same ecs instance with different port is allowed, but same ecs instance with same port isn't.
'''
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosVServerGroup.BackendServersProperty"]]]], jsii.get(self, "backendServers"))
@backend_servers.setter
def backend_servers(
self,
value: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosVServerGroup.BackendServersProperty"]]]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__d7c39ef65c8ac1f69ba359970b93b98122c4f99ef4997b68408a283e23e99193)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "backendServers", value)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-slb.RosVServerGroup.BackendServersProperty",
jsii_struct_bases=[],
name_mapping={
"port": "port",
"server_id": "serverId",
"description": "description",
"server_ip": "serverIp",
"type": "type",
"weight": "weight",
},
)
class BackendServersProperty:
def __init__(
self,
*,
port: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
server_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
description: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
server_ip: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
weight: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''
:param port:
:param server_id:
:param description:
:param server_ip:
:param type:
:param weight:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__1d39db1f12ee865f2bbbc9999430b91a62007e2108fe0f652f0fd62e2e97c1e4)
check_type(argname="argument port", value=port, expected_type=type_hints["port"])
check_type(argname="argument server_id", value=server_id, expected_type=type_hints["server_id"])
check_type(argname="argument description", value=description, expected_type=type_hints["description"])
check_type(argname="argument server_ip", value=server_ip, expected_type=type_hints["server_ip"])
check_type(argname="argument type", value=type, expected_type=type_hints["type"])
check_type(argname="argument weight", value=weight, expected_type=type_hints["weight"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"port": port,
"server_id": server_id,
}
if description is not None:
self._values["description"] = description
if server_ip is not None:
self._values["server_ip"] = server_ip
if type is not None:
self._values["type"] = type
if weight is not None:
self._values["weight"] = weight
@builtins.property
def port(self) -> typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: port: The port of backend server. From 1 to 65535.
'''
result = self._values.get("port")
assert result is not None, "Required property 'port' is missing"
return typing.cast(typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def server_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: serverId: The ID of the backend server. You can specify the ID of an Elastic Compute Service (ECS) instance,an elastic network interface (ENI) or elastic container instance (ECI).
'''
result = self._values.get("server_id")
assert result is not None, "Required property 'server_id' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def description(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: description: The description of the backend server. The description must be 1 to 80 characters in length, and can contain letters, digits, hyphens (-), forward slashes (/), periods (.), and underscores (_).
'''
result = self._values.get("description")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def server_ip(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: serverIp: The IP address of an ECS instance, ENI or ECI
'''
result = self._values.get("server_ip")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def type(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
type: The instance type of the backend server. This parameter must be set to a string. Valid values:
ecs: ECS instance. This is the default value.
eni: ENI.
eci: ECI.
'''
result = self._values.get("type")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def weight(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: weight: The weight of backend server of load balancer. From 0 to 100, 0 means offline. Default is 100.
'''
result = self._values.get("weight")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "BackendServersProperty(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-slb.RosVServerGroupProps",
jsii_struct_bases=[],
name_mapping={
"load_balancer_id": "loadBalancerId",
"v_server_group_name": "vServerGroupName",
"backend_servers": "backendServers",
},
)
class RosVServerGroupProps:
def __init__(
self,
*,
load_balancer_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
v_server_group_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
backend_servers: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union[RosVServerGroup.BackendServersProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::SLB::VServerGroup``.
:param load_balancer_id:
:param v_server_group_name:
:param backend_servers:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__0fc61be057feca1c69057e6b558d355895d67d724d7f20ebdaaab1f9af33c745)
check_type(argname="argument load_balancer_id", value=load_balancer_id, expected_type=type_hints["load_balancer_id"])
check_type(argname="argument v_server_group_name", value=v_server_group_name, expected_type=type_hints["v_server_group_name"])
check_type(argname="argument backend_servers", value=backend_servers, expected_type=type_hints["backend_servers"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"load_balancer_id": load_balancer_id,
"v_server_group_name": v_server_group_name,
}
if backend_servers is not None:
self._values["backend_servers"] = backend_servers
@builtins.property
def load_balancer_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: loadBalancerId: The id of load balancer.
'''
result = self._values.get("load_balancer_id")
assert result is not None, "Required property 'load_balancer_id' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def v_server_group_name(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: vServerGroupName: Display name of the VServerGroup.
'''
result = self._values.get("v_server_group_name")
assert result is not None, "Required property 'v_server_group_name' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def backend_servers(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, RosVServerGroup.BackendServersProperty]]]]:
'''
:Property: backendServers: The list of a combination of ECS Instance-Port-Weight.Same ecs instance with different port is allowed, but same ecs instance with same port isn't.
'''
result = self._values.get("backend_servers")
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, RosVServerGroup.BackendServersProperty]]]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "RosVServerGroupProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class Rule(
_ros_cdk_core_7adfd82f.Resource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-slb.Rule",
):
'''A ROS resource type: ``ALIYUN::SLB::Rule``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["RuleProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
'''Create a new ``ALIYUN::SLB::Rule``.
Param scope - scope in which this resource is defined
Param id - scoped id of the resource
Param props - resource properties
:param scope: -
:param id: -
:param props: -
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__6714fcd56060bb195948743a7e083d93a2fb68f8a5f12708254121117d1e48d2)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@builtins.property
@jsii.member(jsii_name="attrRules")
def attr_rules(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute Rules: A list of forwarding rules.
Each element of rules contains "RuleId".
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrRules"))
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-slb.RuleProps",
jsii_struct_bases=[],
name_mapping={
"listener_port": "listenerPort",
"load_balancer_id": "loadBalancerId",
"rule_list": "ruleList",
"listener_protocol": "listenerProtocol",
},
)
class RuleProps:
def __init__(
self,
*,
listener_port: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
load_balancer_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
rule_list: typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union[RosRule.RuleListProperty, typing.Dict[builtins.str, typing.Any]]]]],
listener_protocol: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::SLB::Rule``.
:param listener_port: Property listenerPort: The front-end HTTPS listener port of the Server Load Balancer instance. Valid value: 1-65535
:param load_balancer_id: Property loadBalancerId: The ID of Server Load Balancer instance.
:param rule_list: Property ruleList: The forwarding rules to add.
:param listener_protocol: Property listenerProtocol: The frontend protocol that is used by the SLB instance.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__e129446274a24ad6aa9eb095e8f4eca774eca83907618b25734ebef089185ec1)
check_type(argname="argument listener_port", value=listener_port, expected_type=type_hints["listener_port"])
check_type(argname="argument load_balancer_id", value=load_balancer_id, expected_type=type_hints["load_balancer_id"])
check_type(argname="argument rule_list", value=rule_list, expected_type=type_hints["rule_list"])
check_type(argname="argument listener_protocol", value=listener_protocol, expected_type=type_hints["listener_protocol"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"listener_port": listener_port,
"load_balancer_id": load_balancer_id,
"rule_list": rule_list,
}
if listener_protocol is not None:
self._values["listener_protocol"] = listener_protocol
@builtins.property
def listener_port(
self,
) -> typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property listenerPort: The front-end HTTPS listener port of the Server Load Balancer instance.
Valid value:
1-65535
'''
result = self._values.get("listener_port")
assert result is not None, "Required property 'listener_port' is missing"
return typing.cast(typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def load_balancer_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property loadBalancerId: The ID of Server Load Balancer instance.'''
result = self._values.get("load_balancer_id")
assert result is not None, "Required property 'load_balancer_id' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def rule_list(
self,
) -> typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, RosRule.RuleListProperty]]]:
'''Property ruleList: The forwarding rules to add.'''
result = self._values.get("rule_list")
assert result is not None, "Required property 'rule_list' is missing"
return typing.cast(typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, RosRule.RuleListProperty]]], result)
@builtins.property
def listener_protocol(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property listenerProtocol: The frontend protocol that is used by the SLB instance.'''
result = self._values.get("listener_protocol")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "RuleProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class VServerGroup(
_ros_cdk_core_7adfd82f.Resource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-slb.VServerGroup",
):
'''A ROS resource type: ``ALIYUN::SLB::VServerGroup``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["VServerGroupProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
'''Create a new ``ALIYUN::SLB::VServerGroup``.
Param scope - scope in which this resource is defined
Param id - scoped id of the resource
Param props - resource properties
:param scope: -
:param id: -
:param props: -
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__7f60a3997d4ec3fbeb54cdc1f0e72ed2daf8d910c56630797915bdc1bbecb3eb)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@builtins.property
@jsii.member(jsii_name="attrBackendServers")
def attr_backend_servers(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute BackendServers: Backend server list in this VServerGroup.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrBackendServers"))
@builtins.property
@jsii.member(jsii_name="attrVServerGroupId")
def attr_v_server_group_id(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute VServerGroupId: The id of VServerGroup created.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrVServerGroupId"))
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-slb.VServerGroupProps",
jsii_struct_bases=[],
name_mapping={
"load_balancer_id": "loadBalancerId",
"v_server_group_name": "vServerGroupName",
"backend_servers": "backendServers",
},
)
class VServerGroupProps:
def __init__(
self,
*,
load_balancer_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
v_server_group_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
backend_servers: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union[RosVServerGroup.BackendServersProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::SLB::VServerGroup``.
:param load_balancer_id: Property loadBalancerId: The id of load balancer.
:param v_server_group_name: Property vServerGroupName: Display name of the VServerGroup.
:param backend_servers: Property backendServers: The list of a combination of ECS Instance-Port-Weight.Same ecs instance with different port is allowed, but same ecs instance with same port isn't.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__887ec67fa550450dc63e4652dad04aadfdd351aff995b9a2dd93ffe5981333dd)
check_type(argname="argument load_balancer_id", value=load_balancer_id, expected_type=type_hints["load_balancer_id"])
check_type(argname="argument v_server_group_name", value=v_server_group_name, expected_type=type_hints["v_server_group_name"])
check_type(argname="argument backend_servers", value=backend_servers, expected_type=type_hints["backend_servers"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"load_balancer_id": load_balancer_id,
"v_server_group_name": v_server_group_name,
}
if backend_servers is not None:
self._values["backend_servers"] = backend_servers
@builtins.property
def load_balancer_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property loadBalancerId: The id of load balancer.'''
result = self._values.get("load_balancer_id")
assert result is not None, "Required property 'load_balancer_id' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def v_server_group_name(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property vServerGroupName: Display name of the VServerGroup.'''
result = self._values.get("v_server_group_name")
assert result is not None, "Required property 'v_server_group_name' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def backend_servers(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, RosVServerGroup.BackendServersProperty]]]]:
'''Property backendServers: The list of a combination of ECS Instance-Port-Weight.Same ecs instance with different port is allowed, but same ecs instance with same port isn't.'''
result = self._values.get("backend_servers")
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, RosVServerGroup.BackendServersProperty]]]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "VServerGroupProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
__all__ = [
"AccessControl",
"AccessControlProps",
"BackendServerAttachment",
"BackendServerAttachmentProps",
"BackendServerToVServerGroupAddition",
"BackendServerToVServerGroupAdditionProps",
"Certificate",
"CertificateProps",
"DomainExtension",
"DomainExtensionProps",
"Listener",
"ListenerProps",
"LoadBalancer",
"LoadBalancerClone",
"LoadBalancerCloneProps",
"LoadBalancerProps",
"MasterSlaveServerGroup",
"MasterSlaveServerGroupProps",
"RosAccessControl",
"RosAccessControlProps",
"RosBackendServerAttachment",
"RosBackendServerAttachmentProps",
"RosBackendServerToVServerGroupAddition",
"RosBackendServerToVServerGroupAdditionProps",
"RosCertificate",
"RosCertificateProps",
"RosDomainExtension",
"RosDomainExtensionProps",
"RosListener",
"RosListenerProps",
"RosLoadBalancer",
"RosLoadBalancerClone",
"RosLoadBalancerCloneProps",
"RosLoadBalancerProps",
"RosMasterSlaveServerGroup",
"RosMasterSlaveServerGroupProps",
"RosRule",
"RosRuleProps",
"RosVServerGroup",
"RosVServerGroupProps",
"Rule",
"RuleProps",
"VServerGroup",
"VServerGroupProps",
"datasource",
]
publication.publish()
# Loading modules to ensure their types are registered with the jsii runtime library
from . import datasource
def _typecheckingstub__32a956c3ef43a14333968f8229f0d7116d55dad7cb2d8c920d99a092cc4d2653(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[AccessControlProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__c1c7183293eca0c3b4b02f340d7a4e2c6d4d85e9411b7e7727eeef0adb33ea5b(
*,
acl_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
acl_entries: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union[RosAccessControl.AclEntriesProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
address_ip_version: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
resource_group_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
tags: typing.Optional[typing.Sequence[typing.Union[RosAccessControl.TagsProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__740242b36f0a9a36e145fd30d2c7f83cb26719ec58aafb1352aad92bfa16b731(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[BackendServerAttachmentProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__02fd1d549c244f46a5382d4091d6a07bac33ae63e08f5b2e88e33380720e9a1e(
*,
load_balancer_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
backend_server_list: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]] = None,
backend_servers: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union[RosBackendServerAttachment.BackendServersProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
backend_server_weight_list: typing.Optional[typing.Union[typing.Sequence[typing.Any], _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__608f8e871d117a9f8ef313d7610c628a9fe7c18d185917a3d7f638927a6abc97(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[BackendServerToVServerGroupAdditionProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__a98a4993f3ea63e5fd57b85edbc771753ff77cdcc8b899e785db738504496030(
*,
backend_servers: typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union[RosBackendServerToVServerGroupAddition.BackendServersProperty, typing.Dict[builtins.str, typing.Any]]]]],
v_server_group_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__7c8fc66ab11f0764614174a5f8788439426cbf2274890fc962a480cf9cae117a(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Optional[typing.Union[CertificateProps, typing.Dict[builtins.str, typing.Any]]] = None,
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__e08ce0ccadd779ef96f0da73a4e29df0de57d7c43d5d820c4dab9d177ce4d59f(
*,
ali_cloud_certificate_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
ali_cloud_certificate_name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
certificate: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
certificate_name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
certificate_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
private_key: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
resource_group_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
tags: typing.Optional[typing.Sequence[typing.Union[RosCertificate.TagsProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__f075a4b99b0d235401fd54cfd59da8a26b061310758c0ce3baea2e025a66018e(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[DomainExtensionProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__e93ec881b1960b1b062cf14ba12453d6067add0b39f2c325ffcd98b36abf65c6(
*,
domain: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
listener_port: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
load_balancer_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
server_certificate_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__1b5f96846837d0c3ac0e5d668025bfb7c14f2e093ad738ef2d4e8ac499a76f2c(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[ListenerProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__833f6e5162e2986432e31fab06356e33cbaecfa04c65ef36b467797465fd3efa(
*,
bandwidth: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
listener_port: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
load_balancer_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
protocol: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
acl_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
acl_status: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
acl_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
backend_server_port: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
ca_certificate_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
description: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
enable_http2: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
gzip: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
health_check: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union[RosListener.HealthCheckProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
http_config: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union[RosListener.HttpConfigProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
idle_timeout: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
master_slave_server_group_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
persistence: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union[RosListener.PersistenceProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
port_range: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union[RosListener.PortRangeProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
request_timeout: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
scheduler: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
server_certificate_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
start_listener: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
tls_cipher_policy: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
v_server_group_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__8cd0aabfc6504c1c8f1619c3401270e978664dbcc2d0bc8fe002d95604294ae0(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Optional[typing.Union[LoadBalancerProps, typing.Dict[builtins.str, typing.Any]]] = None,
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__5d459d5c385260d41c64adc07d3acbacb63cde27ac1ca8722859c1d4827bbc3e(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[LoadBalancerCloneProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__f8469484bc4459b59972d21dd27adcec279c397f08f30ae7fb368f548d2a8a94(
*,
source_load_balancer_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
backend_servers: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union[RosLoadBalancerClone.BackendServersProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
backend_servers_policy: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
instance_charge_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
load_balancer_name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
load_balancer_spec: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
resource_group_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
tags: typing.Optional[typing.Sequence[typing.Union[RosLoadBalancerClone.TagsProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
tags_policy: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
v_switch_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__a4a7083494ae715443133830be3bb8ff556bfa79afc1e887e4d712b9bb1e2b06(
*,
address_ip_version: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
address_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
auto_pay: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
auto_renew: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
auto_renew_period: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
bandwidth: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
deletion_protection: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
duration: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
instance_charge_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
internet_charge_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
load_balancer_name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
load_balancer_spec: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
master_zone_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
modification_protection_reason: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
modification_protection_status: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
pay_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
pricing_cycle: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
resource_group_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
slave_zone_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
tags: typing.Optional[typing.Sequence[typing.Union[RosLoadBalancer.TagsProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
vpc_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
v_switch_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__6d5ba0c12773b56874ebafc1ca87ff70891c314834e4f3670157daa8896fbbf6(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[MasterSlaveServerGroupProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__9ba17813f95ad5905513888e77f640c74d85fae7cba6878cee95f3dd8aa8bef1(
*,
load_balancer_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
master_slave_backend_servers: typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union[RosMasterSlaveServerGroup.MasterSlaveBackendServersProperty, typing.Dict[builtins.str, typing.Any]]]]],
master_slave_server_group_name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__847fc2f16e9a47f66c7243731f63c9f1d52310abd4e857246964461aaeee30dd(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[RosAccessControlProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__9a8f42ca1e8a3aef91e81077f3b911b07e57d15342bcd7306df9ad0ee85f5c7f(
props: typing.Mapping[builtins.str, typing.Any],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__31809101fe1427cb1d90e7dae97aa0ddf0f81f290d1d1661dae5d089feeb124a(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__9f5e93da08ab7c5f50ebe45e85a75f0dc5e103fd1b96f5f66103ed57e3f3f280(
value: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__ed9c17cff27dd7b53e8049ea8480da359f2743634197701dc588421d9da957e9(
value: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, RosAccessControl.AclEntriesProperty]]]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__099830a6a860a21255da2bbd16856d0e345a2e2802d479794f929caee4247f2b(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__c403fe390927d5a9d737985410764d6eb0e62b874c79364aeb9cfff49d5a01f2(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__24d3ff97d12583710993d1cf63e4ecfc5a2bdad76612458b7d382df8886c357c(
value: typing.Optional[typing.List[RosAccessControl.TagsProperty]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__aed7ffb080eb23aa1da440e8612f4a40305b3f8d32414e3cc3aebaab292d98d3(
*,
entry: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
comment: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__76dd5903d6dbcea456f6cf5e6c00a7ffba4ffa260101a98b451b041f5adfe028(
*,
key: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__fa6e5f0360b09d4efc644e3d658b7fd5e8a3c254825920954f2e53e1680c13ce(
*,
acl_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
acl_entries: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union[RosAccessControl.AclEntriesProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
address_ip_version: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
resource_group_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
tags: typing.Optional[typing.Sequence[typing.Union[RosAccessControl.TagsProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__1297df82ec7f888d361a67b9b70e86d801bb81be27637104e1445d8aa56413fa(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[RosBackendServerAttachmentProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__6ded85dafeb5f3ba0ee9b2a00a1b4bac91ba4ee2bec58b7c654e37e57d81f022(
props: typing.Mapping[builtins.str, typing.Any],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__5f617203d5362870f678f3e89a9c1993a6fa0bc363e7da6560b435f86ddcc5dc(
value: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__1b3603fe811c59ee8b09724cfa746218c8cbed55c58775d5e15e4c9d84c2e50d(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__6b75fbb1826bf52c6902373a9c3b153e4237ac49658b54ab88364addbf6fec7a(
value: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__9c2106b21fc641a5315dc6560db831d4b1f99453da01fcc499f8ad04cddfb27a(
value: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, RosBackendServerAttachment.BackendServersProperty]]]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__efb133348a6cca28b5641464ae207e3cf43a0d0d51d3c8cf7ca53012da111f7f(
value: typing.Optional[typing.Union[typing.List[typing.Any], _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__6de1a2d97858568e4fa17a871129e58381ad9535ee19bca9d35ce805c8f23ad3(
*,
server_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
weight: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
description: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
server_ip: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__7e764e3cf866d942d6842a6fe7178f9cc8fc442ccc648cbb6fe59583f92e5134(
*,
load_balancer_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
backend_server_list: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]] = None,
backend_servers: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union[RosBackendServerAttachment.BackendServersProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
backend_server_weight_list: typing.Optional[typing.Union[typing.Sequence[typing.Any], _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__593b28df9c0f0b456f530fc332714b320e70941a906ca8d117acb85ce6dd1c9d(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[RosBackendServerToVServerGroupAdditionProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__acf9d29063e3563a0077b19af37dda331f136d189ab60948da535af70c1fcab7(
props: typing.Mapping[builtins.str, typing.Any],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__b3f7f1e0b5c61bef9fe316f8d8e0b911dabda91047999d58e251bde716992246(
value: typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, RosBackendServerToVServerGroupAddition.BackendServersProperty]]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__8f9cd633291cc4535208b3b886f2e3d4a2dae70bd666d0d8454df8702bb274ab(
value: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__33efd890e1f47cd176201389153fe678326b23ad2c238220a12f775ac9a74ded(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__52b88569c0f1e1467cb1ea14550e40a91c94d852b52dbfa4885def5151e3c4ee(
*,
port: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
server_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
description: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
server_ip: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
weight: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__d4e0325e11e8bc298a9d48fc3f85253f3a4a2c3ea862a6ea71d7e7f360d9f3bb(
*,
backend_servers: typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union[RosBackendServerToVServerGroupAddition.BackendServersProperty, typing.Dict[builtins.str, typing.Any]]]]],
v_server_group_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__f7c79b67c543726d7ae20d7245f9264f6136fcf58b5b726d9eea181b77511c99(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[RosCertificateProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__525d8ef886383b275baed218f264f4c90bad610ac8126945bb07af65b068354a(
props: typing.Mapping[builtins.str, typing.Any],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__6474487ec4158c05182b85939e66b48a4b1602b7f78a92e13034ce3b1af0e078(
value: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__a9cb3731fee8e80d3256db508b818c4477e04bb713d12cd3efd13dd57557a564(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__737731f6acdc011aa78640ef2eac75013ecf4eee218b8c3984589c6e9119b8a6(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__e12658e10510fa209c5d684182982e34f99a061f37e821468cfd0656b38b1a0a(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__5292361599bc615e2c552e3ef23d8c44b0909bb6d569db3bc123da6a048e6a10(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__b0b0954c32af9b710f7edbf5af0357141bb728d91d12e9b91aae6ead156c62a3(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__b96b2b66b6694d2bb06b8ae1217200216b7b91587de424e5344409bf362c3bbb(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__b9a0d718e443a2ac70fe46e47dd895acea53962559343f1098918b09a3085da6(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__4cfeca3ea70eacfadde311116975e863ba1c933f4b6da7c06607c9cd9c77dc69(
value: typing.Optional[typing.List[RosCertificate.TagsProperty]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__4a0778ef6490b87318c4c8193b11347468e8262447f6da1bfdd21268a6283385(
*,
key: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__7e01ca041985f2287c83ba2b5708b2fa9878f085ed7bc08d083e986dd7c2b462(
*,
ali_cloud_certificate_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
ali_cloud_certificate_name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
certificate: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
certificate_name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
certificate_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
private_key: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
resource_group_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
tags: typing.Optional[typing.Sequence[typing.Union[RosCertificate.TagsProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__7ae95996ee1773356b83e45d8a8d75ac575ab3678422c9d12f9378859a935edf(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[RosDomainExtensionProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__983c9ce0930c5c51ca60c5f28b59be18a36b463de725860cd7ab65530338832b(
props: typing.Mapping[builtins.str, typing.Any],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__69708cdf696a442f4a9182443e89b1dc19f7b2e9453658bb531b4d6cde2e490a(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__8b46d288e43e152eccb96f29313a9ed9ec4a3da61aedfbe028a8bfee8636a18a(
value: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__50f17f12c9d459b5e2323f34ed9270145a016e6c710549107f2f5e2f6247f741(
value: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__46a1b8ce5e00d299225dd665e9eab7bc2f9ca6e0f8cc7f00378e923ba09a5a92(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__b2d6d37707d7c5593cefaed35d4bf3497351b57892605803aaff478416b6f09b(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__5910ec9bc329b736bc2ff762a3fcd91f184bf32fc1a8f5a3871e31d8d0f4d478(
*,
domain: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
listener_port: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
load_balancer_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
server_certificate_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__751bc5618e98ab72ea98d725a26bfbe9060ade092357018dbbb0600a3865c503(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[RosListenerProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__d6e9c154bda923d441b1e6a47fea30053a4d787a072f2f7847d877ab72beee1a(
props: typing.Mapping[builtins.str, typing.Any],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__080364c22d736e7e6c8aca87febbd9115c4b16a7d0117a550112f4a12287b62a(
value: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__a171a54669f1918b4ce2397ceece399eca0d3c7b32913b1c5e7c5724c510a757(
value: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__5959eb784c01f16f68c991941bd11a2c7fb7dd2ee22dfcdf65e54f8524db3016(
value: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__3fa1e2b77d36d34cf2afa826bf1089142152cb6937dc950d299f834b43e41316(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__d838f8ed8ceb88352442206a401a683577754f7c757665484ff1387c652a162d(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__c72336f8d5cf733ba925086b1a91f938181f6d036ed5fe3cbd7ca2e1c29ecbd9(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__8b186ff0000b32e6e03dd28ebefa20e632c39189233127355c97ca6711f38742(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__fdd15311d5c389793d5d0effdf35aaae33d0bb0bd32055097b041581bddfcf4c(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__dcdff56130779b973ce4664c24af785a0c58c11126410eb4deeca93cfc769f5f(
value: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__1d65999633df7706029659714ddfa3b5c9ff0f2faec6ca27476c75949de1c662(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__deacde491ff1e99a8e6e95efadf83c246edc449f2a8fd8ad1be4d958dbcb1954(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__57ecd60cf3ce01487939bba9d178f20c5cd80bbe9e5d5d5b4652abb9f3382374(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__b95d2e00bd7c68a783df86ab409ae9dee2d48f12290cdb969b4d0080f74cb554(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__235939a8a3a75a15579937a6a76b158b410c9551955c832aa18014fadbf3aa25(
value: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, RosListener.HealthCheckProperty]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__d8e87688141d6935d6a699efa054cbd09127c9e3f05eefbf81bd16a3b5810a0f(
value: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, RosListener.HttpConfigProperty]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__d42590f52bb7a7352ba27e22ed8aee699d78e72a399fb261e45e1ce4242d0e25(
value: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__84cb2bd88e393c16ba8875a98530c0a5022f35e314b9c2a4a0e0a8e6e157eec4(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__8118c2c75a8f04d376feb26c8ba931f384ae8ee4f0006bde4b2ffeeee22c26f3(
value: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, RosListener.PersistenceProperty]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__c9ce8f2fe70c315990ecd31b3fa74bc1f50dc23e42905a521bf291b8b58944b1(
value: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, RosListener.PortRangeProperty]]]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__0edbf23cd8f1c622ffeb49b11ff06347a3431fb76f63c81a5993ba83590e1b34(
value: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__0726316d42070a5bf5be5a8d44981d13a658c112548bdfd7fe00e8fbdd8419e9(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__f9afdacf8f1db95ba480b05b3b643774056198c1c29d2ab2ca2b5da5d66a1ba2(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__f33b607b770417212837e09fce7f0834cc6092a9f761754fe089504c9654b7bf(
value: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__d38354b4e8158a49d7d4418844c722e178634b61a40683177cd1230b47ce4fa3(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__9dedd683a1c4602a3398684772ed8d510c2efc312b6dee42eb4e62de0d7f6456(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__f7bb472dd5f75b293476d1d83cb77c4a18fa448f24ef3141472603f9d5f6425f(
*,
domain: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
health_check_method: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
health_check_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
healthy_threshold: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
http_code: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
interval: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
port: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
switch: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
timeout: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
unhealthy_threshold: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
uri: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__2fed72d5bbd2e4710dde65ab405172307d15127aeaa39f672b65c93b3632c0cf(
*,
forward_port: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
listener_forward: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__4241bd702b9bc2b4bb8e465291abf9233ef9c5d1af927aa073011b4233b9dae6(
*,
cookie: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
cookie_timeout: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
persistence_timeout: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
sticky_session: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
sticky_session_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
x_forwarded_for: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
x_forwarded_for_client_src_port: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
x_forwarded_for_proto: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
x_forwarded_for_slbid: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
x_forwarded_for_slbip: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
x_forwarded_for_slbport: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__314d5ec2c18c2e5645f1da52b47f9592473fa77874a463bcd33813d220475044(
*,
end_port: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
start_port: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__d3c57955ef9e55f3650e61dba548b01d32bb4d91aec43b7451a9fbacbb77dfce(
*,
bandwidth: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
listener_port: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
load_balancer_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
protocol: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
acl_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
acl_status: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
acl_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
backend_server_port: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
ca_certificate_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
description: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
enable_http2: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
gzip: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
health_check: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union[RosListener.HealthCheckProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
http_config: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union[RosListener.HttpConfigProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
idle_timeout: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
master_slave_server_group_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
persistence: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union[RosListener.PersistenceProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
port_range: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union[RosListener.PortRangeProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
request_timeout: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
scheduler: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
server_certificate_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
start_listener: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
tls_cipher_policy: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
v_server_group_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__ac034d72aa26bde3e28687b108c97956145ad9487d6b8efc3dc0c57cd1acda43(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[RosLoadBalancerProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__2a7edf661660d2e34b7cca3206375396dff58f16bb9a776b710d9ca39cfa0b27(
props: typing.Mapping[builtins.str, typing.Any],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__797f8811e9db7c17b7db8980846f43192379650ace12c2494a149393cd1007dd(
value: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__fdaf5ff7fec7ed58bf64caa92aaba18bc8acee220c99edd54939d46e06c84775(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__cc2abeaa4eb1d6d7184bfbef30800d9cce06bf117498711045d8ba0708f01b4a(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__d14dce33a295ed1e1d5e73999a65bc6f891915ea40684ca50a258a3e8f0536df(
value: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__f8859b93c9ab709a5e4cd9da41f85dc9c3fe048b4a5d7586002bc473b45ae26f(
value: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__a8c4545e9e0fbe652aac0c9dc9737379bf08f81a637d6074987a44ae77da487e(
value: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__fc82c82d03141c0ac5002b517e7e174c598d4252deea9095ac5549b4ed4c6cb8(
value: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__5c665ec4750026b6229fdfa17516c97af4e125d64f781e498c11a832585febaf(
value: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__7309ca279a3aedb6e66b2c068c326c155199df20aa579f4c9282219c953c5279(
value: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__c53222207b48b2672e2c068b336d9fe090ed84ee6610470e15622eeb1a8c4515(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__026a25b59716874c592cbcd49ab24aac71a7766a2c1d7b29db0b763a48ce21e1(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__689e47e32d2afb1e4d271e5eb31c5dd95f0f41d4616e69cf6bbd02dae7f82fd9(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__7b572175ef8437888bca6c419ae0589d1ad3d89dc15d6bbd7bad92dde8bec287(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__2a1272586a275470c8dc9b59d3612e869c1e75e21a1924bca37fc9fcc1b5312e(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__1c3f40e7dc3740d21811e251799481467273db66ae0cc8f69ed5dff2219aa6ee(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__46492516939a5f5c744e096dfb7ba42ec4e1a1ac22f9b8cb0d56e44c36dca00f(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__98a24be074846809182b991a1184fe184288a911a8ac3da01d7d7e0120b6f147(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__90002872ae70a67a4f1e619ec83d61985b8982edf3eb2f4b035adea580f4e917(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__f8c0f3cabade82e069cb8339d8fff4bae2c601b01868aab72150d739ca0a156c(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__2c32e11009f833d195cdc8acc81242f5bb226c8588202d56912cff0cdd55a922(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__7662e060f3184416fd4b1b14ffc62ea373fed9261fe30285c63faf9e5870b1cf(
value: typing.Optional[typing.List[RosLoadBalancer.TagsProperty]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__d45d6b63733a6726d2a952dc6a69e39ea31dcea1640e6314993e0be3f12f54c7(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__ee538bac3fdeaaad87126f158f56053381d6c9f341cb1808e931ce7265b731d8(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__ae91907b5c637ed4590f98ef4c8d68d1c4ed228c040a22a2dcfe37582c14a999(
*,
key: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__2ffade5dc970282cd514b995eebe40dab996c88c5aaf277d21b6a07d25f9ac93(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[RosLoadBalancerCloneProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__a9f6f0be89524067c6057cc968c80fba2619e9222ca524c58bf0bab75d6b2070(
props: typing.Mapping[builtins.str, typing.Any],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__61a00b0da57d05e5963e1d1aaac28b18f8b2e6d3dd0520079b36a8f26627dad0(
value: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__4881a8759fc0ab02baa88833b7c136130e46e087678f51c15172607b519a4258(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__c7988d71e27b919133722358429e566e121583c94bd24b03c67daa42532a4282(
value: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, RosLoadBalancerClone.BackendServersProperty]]]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__025387db2dfcfac3341ba466eb5dc3f4de30e018a107f6f007a59c23769e6310(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__f0213ef0271cd0278b634d936c7735828f3d144ea15b9b0ed98a58d1a1224ce6(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__aef889cf0580f45cd58a670704ad1109d4ef57cf2986531e9da03f770362b0cc(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__7fbbe6a4bb532c5692cd4d600a151e1b5d3b08c9a2439ea60c880cba41d6f60a(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__83ad3f6ec65f700710b10419ae05b8c3779253b6718fbcde064d4d08837bab54(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__d7ceb55efa8025d2f9b30b567d2453a05ca64d9adfce00f4590c73d638dfa6df(
value: typing.Optional[typing.List[RosLoadBalancerClone.TagsProperty]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__3ec67321fe80002f47513b8d2ca14d6f1bc037cf25054d8b2dff43964f249e49(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__907c6d68baa35d78328f3bf2319eb05b977c3a5b4971c7f0399096445628d09e(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__806e0f68708f0cfca573b37e8021da59727f95c78daafef8b0594716560d6ae8(
*,
server_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
weight: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
description: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
server_ip: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__9eac177e1081b4a58645490a4cfa0bdac74d80201f3aeed2927310349dc38567(
*,
key: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__bb8dfaad9fcd2ffaf8d59a94a25039beed0dd32209e64d1908c8486b503dea2e(
*,
source_load_balancer_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
backend_servers: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union[RosLoadBalancerClone.BackendServersProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
backend_servers_policy: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
instance_charge_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
load_balancer_name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
load_balancer_spec: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
resource_group_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
tags: typing.Optional[typing.Sequence[typing.Union[RosLoadBalancerClone.TagsProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
tags_policy: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
v_switch_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__6c3c7c21484380419d0b84f94989c51d7124ad033f24021f30aedcd89f51feab(
*,
address_ip_version: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
address_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
auto_pay: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
auto_renew: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
auto_renew_period: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
bandwidth: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
deletion_protection: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
duration: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
instance_charge_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
internet_charge_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
load_balancer_name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
load_balancer_spec: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
master_zone_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
modification_protection_reason: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
modification_protection_status: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
pay_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
pricing_cycle: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
resource_group_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
slave_zone_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
tags: typing.Optional[typing.Sequence[typing.Union[RosLoadBalancer.TagsProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
vpc_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
v_switch_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__9b027e39a65387002d3b41dad2136cb43573e845c5db037a80126ebcea80dc32(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[RosMasterSlaveServerGroupProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__09e82a2246bd0ac3e4b9e8414f998d2e5e418f9907dd37b4bf3abeeb589aa2f0(
props: typing.Mapping[builtins.str, typing.Any],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__c3ec39fcdb64c9082e573191dfc2592772a8b0e2a32ceb9c799eea8ca3ba8ad8(
value: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__61c090bd1815fac5e202c8904b7382185428de29015efcac6a21bb40ddba3bb0(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__5592b534a8ec18b667f402ab3f004e509d58c2824d4159df914328154e057527(
value: typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, RosMasterSlaveServerGroup.MasterSlaveBackendServersProperty]]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__7a70b1411831fcb5edda90c810638bae0ee8f5eb2b2e65603c1a53dccbe35bb9(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__25e0e06986d1255c0ccf0c175f1ef5ab0f7cbc81ec53c1f2323b4f35449b3cb9(
*,
port: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
server_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
weight: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
server_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__cd97e9773855b4776a284c30d03fdb9067f6d27bbe78804460239dcac1c732f5(
*,
load_balancer_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
master_slave_backend_servers: typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union[RosMasterSlaveServerGroup.MasterSlaveBackendServersProperty, typing.Dict[builtins.str, typing.Any]]]]],
master_slave_server_group_name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__bfa316001bdbed0ac85141c35c10150aa45356e0250b8f0cdec86e328961ee0e(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[RosRuleProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__ea608b45e67109620c8226e05c3f00431cf6fe4d106bc6a821d586353c8f53e8(
props: typing.Mapping[builtins.str, typing.Any],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__90ba6edbaad0b0c58f9ffe60cf34c10c1e49632a64516f0f92911f481b7339a9(
value: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__c810b3c0e69113845e4309585fe13e5f46863ca80ae40d64d97b963fe34ff7df(
value: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__4a5e262b0586e5621d14e723a0acb7530ac9c5a47f8386ce9549edeea60bdb86(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__192e030dac8bf63634821eaff61966328a544f58e0b1664f776ce03768baaa3f(
value: typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, RosRule.RuleListProperty]]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__a17b2a2adb12b8361c26dc68ba94cf2fa5de3c3d6fa96da1eb09275a3b2a6be4(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__0e3f32f522b93e5be096b6298c2e6fd02b536e3e5e7fa12ab16272d2313d04f2(
*,
cookie: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
cookie_timeout: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
health_check: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
health_check_connect_port: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
health_check_domain: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
health_check_http_code: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
health_check_interval: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
health_check_timeout: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
health_check_uri: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
healthy_threshold: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
listener_sync: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
scheduler: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
sticky_session: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
sticky_session_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
unhealthy_threshold: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__678956d97f1cf53c67fa2e352dc14294c41fe2477d9e33c6ad5a40c30d7c4dbe(
*,
rule_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
v_server_group_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
advanced_settings: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union[RosRule.AdvancedSettingsProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
domain: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
url: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__6adbefceaba654aea7652f24b4f2145c82614eb14f44783867c486f0efca7a9e(
*,
listener_port: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
load_balancer_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
rule_list: typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union[RosRule.RuleListProperty, typing.Dict[builtins.str, typing.Any]]]]],
listener_protocol: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__ba0ae8b794bafc8987cda1cae4ab1c592036f2b54c4e27b3bff7281c40b54e65(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[RosVServerGroupProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__f4e6b1b355ca5a7ee3ac0be75a0721d7868fd9636af5a2bd3a250d5e00a1cac2(
props: typing.Mapping[builtins.str, typing.Any],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__a4def502340c7d5a5aba934ba24dd5efa80b9fe159b46e94889347ae3aac3271(
value: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__eb14d63fc0a051c9d593d68b08daeae085bc2e5fb72dcc123c7df6bfacf81102(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__2c21a95804741692bb8ea191692365d03db626e96cb6b7994c5694398359a36e(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__d7c39ef65c8ac1f69ba359970b93b98122c4f99ef4997b68408a283e23e99193(
value: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, RosVServerGroup.BackendServersProperty]]]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__1d39db1f12ee865f2bbbc9999430b91a62007e2108fe0f652f0fd62e2e97c1e4(
*,
port: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
server_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
description: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
server_ip: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
weight: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__0fc61be057feca1c69057e6b558d355895d67d724d7f20ebdaaab1f9af33c745(
*,
load_balancer_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
v_server_group_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
backend_servers: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union[RosVServerGroup.BackendServersProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__6714fcd56060bb195948743a7e083d93a2fb68f8a5f12708254121117d1e48d2(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[RuleProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__e129446274a24ad6aa9eb095e8f4eca774eca83907618b25734ebef089185ec1(
*,
listener_port: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
load_balancer_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
rule_list: typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union[RosRule.RuleListProperty, typing.Dict[builtins.str, typing.Any]]]]],
listener_protocol: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__7f60a3997d4ec3fbeb54cdc1f0e72ed2daf8d910c56630797915bdc1bbecb3eb(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[VServerGroupProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__887ec67fa550450dc63e4652dad04aadfdd351aff995b9a2dd93ffe5981333dd(
*,
load_balancer_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
v_server_group_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
backend_servers: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union[RosVServerGroup.BackendServersProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
) -> None:
"""Type checking stubs"""
pass | /ros-cdk-slb-1.0.17.tar.gz/ros-cdk-slb-1.0.17/src/ros_cdk_slb/__init__.py | 0.674372 | 0.150372 | __init__.py | pypi |
import abc
import builtins
import datetime
import enum
import typing
import jsii
import publication
import typing_extensions
from typeguard import check_type
from ._jsii import *
import ros_cdk_core as _ros_cdk_core_7adfd82f
class Alert(
_ros_cdk_core_7adfd82f.Resource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-sls.Alert",
):
'''A ROS resource type: ``ALIYUN::SLS::Alert``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["AlertProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
'''Create a new ``ALIYUN::SLS::Alert``.
Param scope - scope in which this resource is defined
Param id - scoped id of the resource
Param props - resource properties
:param scope: -
:param id: -
:param props: -
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__4dc90d5eb990de440a55f36fefa7ba92d25bf22b7c503f361ce5506d11d4cad0)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@builtins.property
@jsii.member(jsii_name="attrName")
def attr_name(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute Name: Alert name.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrName"))
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-sls.AlertProps",
jsii_struct_bases=[],
name_mapping={"detail": "detail", "project": "project"},
)
class AlertProps:
def __init__(
self,
*,
detail: typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union["RosAlert.DetailProperty", typing.Dict[builtins.str, typing.Any]]],
project: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
'''Properties for defining a ``ALIYUN::SLS::Alert``.
:param detail: Property detail:.
:param project: Property project: Project name: 1. Only supports lowercase letters, numbers, hyphens (-) and underscores (_). 2. Must start and end with lowercase letters and numbers. 3. The name length is 3-63 characters.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__3915aaafcbce9b37683554165f5ef18d4047883b83d2acc3696d4f04edbd3d00)
check_type(argname="argument detail", value=detail, expected_type=type_hints["detail"])
check_type(argname="argument project", value=project, expected_type=type_hints["project"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"detail": detail,
"project": project,
}
@builtins.property
def detail(
self,
) -> typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosAlert.DetailProperty"]:
'''Property detail:.'''
result = self._values.get("detail")
assert result is not None, "Required property 'detail' is missing"
return typing.cast(typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosAlert.DetailProperty"], result)
@builtins.property
def project(self) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property project: Project name: 1.
Only supports lowercase letters, numbers, hyphens (-) and underscores (_).
2. Must start and end with lowercase letters and numbers.
3. The name length is 3-63 characters.
'''
result = self._values.get("project")
assert result is not None, "Required property 'project' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "AlertProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class ApplyConfigToMachineGroup(
_ros_cdk_core_7adfd82f.Resource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-sls.ApplyConfigToMachineGroup",
):
'''A ROS resource type: ``ALIYUN::SLS::ApplyConfigToMachineGroup``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Optional[typing.Union["ApplyConfigToMachineGroupProps", typing.Dict[builtins.str, typing.Any]]] = None,
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
'''Create a new ``ALIYUN::SLS::ApplyConfigToMachineGroup``.
Param scope - scope in which this resource is defined
Param id - scoped id of the resource
Param props - resource properties
:param scope: -
:param id: -
:param props: -
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__939f798867cdbdd3ccac4a71da46d977541b7535df2acc8acf96d4b2fb1532d8)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-sls.ApplyConfigToMachineGroupProps",
jsii_struct_bases=[],
name_mapping={
"config_name": "configName",
"group_name": "groupName",
"project_name": "projectName",
},
)
class ApplyConfigToMachineGroupProps:
def __init__(
self,
*,
config_name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
group_name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
project_name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::SLS::ApplyConfigToMachineGroup``.
:param config_name: Property configName: Apply config to the config name.
:param group_name: Property groupName: Apply config to the group name.
:param project_name: Property projectName: Apply config to the project name.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__2e841975a95f0caaef38704a787ff0fa3aa4f36c0404a05c0478c221b7b60a3f)
check_type(argname="argument config_name", value=config_name, expected_type=type_hints["config_name"])
check_type(argname="argument group_name", value=group_name, expected_type=type_hints["group_name"])
check_type(argname="argument project_name", value=project_name, expected_type=type_hints["project_name"])
self._values: typing.Dict[builtins.str, typing.Any] = {}
if config_name is not None:
self._values["config_name"] = config_name
if group_name is not None:
self._values["group_name"] = group_name
if project_name is not None:
self._values["project_name"] = project_name
@builtins.property
def config_name(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property configName: Apply config to the config name.'''
result = self._values.get("config_name")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def group_name(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property groupName: Apply config to the group name.'''
result = self._values.get("group_name")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def project_name(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property projectName: Apply config to the project name.'''
result = self._values.get("project_name")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "ApplyConfigToMachineGroupProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class Audit(
_ros_cdk_core_7adfd82f.Resource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-sls.Audit",
):
'''A ROS resource type: ``ALIYUN::SLS::Audit``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["AuditProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
'''Create a new ``ALIYUN::SLS::Audit``.
Param scope - scope in which this resource is defined
Param id - scoped id of the resource
Param props - resource properties
:param scope: -
:param id: -
:param props: -
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__f71af29470adc4f3830048e02c84c908818932ae9d7e9fe3cb445d358ec121ce)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@builtins.property
@jsii.member(jsii_name="attrDisplayName")
def attr_display_name(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute DisplayName: Name of SLS log audit.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrDisplayName"))
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-sls.AuditProps",
jsii_struct_bases=[],
name_mapping={
"display_name": "displayName",
"variable_map": "variableMap",
"multi_account": "multiAccount",
},
)
class AuditProps:
def __init__(
self,
*,
display_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
variable_map: typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union["RosAudit.VariableMapProperty", typing.Dict[builtins.str, typing.Any]]],
multi_account: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::SLS::Audit``.
:param display_name: Property displayName: Name of SLS log audit.
:param variable_map: Property variableMap: Log audit detailed configuration.
:param multi_account: Property multiAccount: Multi-account configuration, please fill in multiple aliuid.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__ca39effacb160cba87db70b32051e2903b282cd4c0b9680d83ffa990931dad6d)
check_type(argname="argument display_name", value=display_name, expected_type=type_hints["display_name"])
check_type(argname="argument variable_map", value=variable_map, expected_type=type_hints["variable_map"])
check_type(argname="argument multi_account", value=multi_account, expected_type=type_hints["multi_account"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"display_name": display_name,
"variable_map": variable_map,
}
if multi_account is not None:
self._values["multi_account"] = multi_account
@builtins.property
def display_name(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property displayName: Name of SLS log audit.'''
result = self._values.get("display_name")
assert result is not None, "Required property 'display_name' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def variable_map(
self,
) -> typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosAudit.VariableMapProperty"]:
'''Property variableMap: Log audit detailed configuration.'''
result = self._values.get("variable_map")
assert result is not None, "Required property 'variable_map' is missing"
return typing.cast(typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosAudit.VariableMapProperty"], result)
@builtins.property
def multi_account(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]]:
'''Property multiAccount: Multi-account configuration, please fill in multiple aliuid.'''
result = self._values.get("multi_account")
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "AuditProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class Dashboard(
_ros_cdk_core_7adfd82f.Resource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-sls.Dashboard",
):
'''A ROS resource type: ``ALIYUN::SLS::Dashboard``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["DashboardProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
'''Create a new ``ALIYUN::SLS::Dashboard``.
Param scope - scope in which this resource is defined
Param id - scoped id of the resource
Param props - resource properties
:param scope: -
:param id: -
:param props: -
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__0a612850618f1228ee78250a54ce5b64a134718cdc0866e17c6c5241dcd92cd8)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@builtins.property
@jsii.member(jsii_name="attrDashboardName")
def attr_dashboard_name(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute DashboardName: Dashboard name.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrDashboardName"))
@builtins.property
@jsii.member(jsii_name="attrDisplayName")
def attr_display_name(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute DisplayName: Display name.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrDisplayName"))
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-sls.DashboardProps",
jsii_struct_bases=[],
name_mapping={
"charts": "charts",
"dashboard_name": "dashboardName",
"project_name": "projectName",
"description": "description",
"display_name": "displayName",
},
)
class DashboardProps:
def __init__(
self,
*,
charts: typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Mapping[builtins.str, typing.Any]]],
dashboard_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
project_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
description: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
display_name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::SLS::Dashboard``.
:param charts: Property charts: Chart list.
:param dashboard_name: Property dashboardName: Dashboard name.
:param project_name: Property projectName: Project name: 1. Only supports lowercase letters, numbers, hyphens (-) and underscores (_). 2. Must start and end with lowercase letters and numbers. 3. The name length is 3-63 characters.
:param description: Property description: Dashboard description.
:param display_name: Property displayName: Dashboard display name.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__02bccad83b27835df2ad9a17842b3b5a447fa55e96c1dcbe1743ca027925c5ae)
check_type(argname="argument charts", value=charts, expected_type=type_hints["charts"])
check_type(argname="argument dashboard_name", value=dashboard_name, expected_type=type_hints["dashboard_name"])
check_type(argname="argument project_name", value=project_name, expected_type=type_hints["project_name"])
check_type(argname="argument description", value=description, expected_type=type_hints["description"])
check_type(argname="argument display_name", value=display_name, expected_type=type_hints["display_name"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"charts": charts,
"dashboard_name": dashboard_name,
"project_name": project_name,
}
if description is not None:
self._values["description"] = description
if display_name is not None:
self._values["display_name"] = display_name
@builtins.property
def charts(
self,
) -> typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Mapping[builtins.str, typing.Any]]]:
'''Property charts: Chart list.'''
result = self._values.get("charts")
assert result is not None, "Required property 'charts' is missing"
return typing.cast(typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Mapping[builtins.str, typing.Any]]], result)
@builtins.property
def dashboard_name(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property dashboardName: Dashboard name.'''
result = self._values.get("dashboard_name")
assert result is not None, "Required property 'dashboard_name' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def project_name(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property projectName: Project name: 1.
Only supports lowercase letters, numbers, hyphens (-) and underscores (_).
2. Must start and end with lowercase letters and numbers.
3. The name length is 3-63 characters.
'''
result = self._values.get("project_name")
assert result is not None, "Required property 'project_name' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def description(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property description: Dashboard description.'''
result = self._values.get("description")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def display_name(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property displayName: Dashboard display name.'''
result = self._values.get("display_name")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "DashboardProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class Etl(
_ros_cdk_core_7adfd82f.Resource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-sls.Etl",
):
'''A ROS resource type: ``ALIYUN::SLS::Etl``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["EtlProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
'''Create a new ``ALIYUN::SLS::Etl``.
Param scope - scope in which this resource is defined
Param id - scoped id of the resource
Param props - resource properties
:param scope: -
:param id: -
:param props: -
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__29fc8efa98adb9273024b08d52cba929ca77378561006bf0c9c31f8298610651)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@builtins.property
@jsii.member(jsii_name="attrName")
def attr_name(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute Name: ETL name.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrName"))
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-sls.EtlProps",
jsii_struct_bases=[],
name_mapping={
"configuration": "configuration",
"display_name": "displayName",
"name": "name",
"project_name": "projectName",
"schedule": "schedule",
"description": "description",
},
)
class EtlProps:
def __init__(
self,
*,
configuration: typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union["RosEtl.ConfigurationProperty", typing.Dict[builtins.str, typing.Any]]],
display_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
project_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
schedule: typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union["RosEtl.ScheduleProperty", typing.Dict[builtins.str, typing.Any]]],
description: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::SLS::Etl``.
:param configuration: Property configuration: The configuration of ETL task.
:param display_name: Property displayName: ETL display name.
:param name: Property name: ETL name.
:param project_name: Property projectName: Project name.
:param schedule: Property schedule: Task scheduling strategy.
:param description: Property description: ETL description message.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__7844781c2020366512942ad290c99edac6cd8eaf9c14acd4e2137e86d318ddf6)
check_type(argname="argument configuration", value=configuration, expected_type=type_hints["configuration"])
check_type(argname="argument display_name", value=display_name, expected_type=type_hints["display_name"])
check_type(argname="argument name", value=name, expected_type=type_hints["name"])
check_type(argname="argument project_name", value=project_name, expected_type=type_hints["project_name"])
check_type(argname="argument schedule", value=schedule, expected_type=type_hints["schedule"])
check_type(argname="argument description", value=description, expected_type=type_hints["description"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"configuration": configuration,
"display_name": display_name,
"name": name,
"project_name": project_name,
"schedule": schedule,
}
if description is not None:
self._values["description"] = description
@builtins.property
def configuration(
self,
) -> typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosEtl.ConfigurationProperty"]:
'''Property configuration: The configuration of ETL task.'''
result = self._values.get("configuration")
assert result is not None, "Required property 'configuration' is missing"
return typing.cast(typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosEtl.ConfigurationProperty"], result)
@builtins.property
def display_name(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property displayName: ETL display name.'''
result = self._values.get("display_name")
assert result is not None, "Required property 'display_name' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def name(self) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property name: ETL name.'''
result = self._values.get("name")
assert result is not None, "Required property 'name' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def project_name(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property projectName: Project name.'''
result = self._values.get("project_name")
assert result is not None, "Required property 'project_name' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def schedule(
self,
) -> typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosEtl.ScheduleProperty"]:
'''Property schedule: Task scheduling strategy.'''
result = self._values.get("schedule")
assert result is not None, "Required property 'schedule' is missing"
return typing.cast(typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosEtl.ScheduleProperty"], result)
@builtins.property
def description(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property description: ETL description message.'''
result = self._values.get("description")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "EtlProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class Index(
_ros_cdk_core_7adfd82f.Resource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-sls.Index",
):
'''A ROS resource type: ``ALIYUN::SLS::Index``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["IndexProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
'''Create a new ``ALIYUN::SLS::Index``.
Param scope - scope in which this resource is defined
Param id - scoped id of the resource
Param props - resource properties
:param scope: -
:param id: -
:param props: -
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__37ce56cf99a18afc6ffc83bdf68f8d54a6c421ecc5be7b831935e0ce3191b534)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-sls.IndexProps",
jsii_struct_bases=[],
name_mapping={
"full_text_index": "fullTextIndex",
"logstore_name": "logstoreName",
"project_name": "projectName",
"key_indices": "keyIndices",
"log_reduce": "logReduce",
},
)
class IndexProps:
def __init__(
self,
*,
full_text_index: typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union["RosIndex.FullTextIndexProperty", typing.Dict[builtins.str, typing.Any]]],
logstore_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
project_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
key_indices: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union["RosIndex.KeyIndicesProperty", typing.Dict[builtins.str, typing.Any]]]]]] = None,
log_reduce: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::SLS::Index``.
:param full_text_index: Property fullTextIndex: Full-text indexing configuration. Full-text indexing and key indexing must have at least one enabled.
:param logstore_name: Property logstoreName: Logstore name: 1. Only supports lowercase letters, numbers, hyphens (-) and underscores (_). 2. Must start and end with lowercase letters and numbers. 3. The name length is 3-63 characters.
:param project_name: Property projectName: Project name: 1. Only supports lowercase letters, numbers, hyphens (-) and underscores (_). 2. Must start and end with lowercase letters and numbers. 3. The name length is 3-63 characters.
:param key_indices: Property keyIndices: Key index configurations. Full-text indexing and key indexing must have at least one enabled.
:param log_reduce: Property logReduce: Whether to enable log reduce. Default to false.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__87a3553e99bb30490cd4d8a4606bb24823b1f2d5fb7a923d6a3196ad70dacb9c)
check_type(argname="argument full_text_index", value=full_text_index, expected_type=type_hints["full_text_index"])
check_type(argname="argument logstore_name", value=logstore_name, expected_type=type_hints["logstore_name"])
check_type(argname="argument project_name", value=project_name, expected_type=type_hints["project_name"])
check_type(argname="argument key_indices", value=key_indices, expected_type=type_hints["key_indices"])
check_type(argname="argument log_reduce", value=log_reduce, expected_type=type_hints["log_reduce"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"full_text_index": full_text_index,
"logstore_name": logstore_name,
"project_name": project_name,
}
if key_indices is not None:
self._values["key_indices"] = key_indices
if log_reduce is not None:
self._values["log_reduce"] = log_reduce
@builtins.property
def full_text_index(
self,
) -> typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosIndex.FullTextIndexProperty"]:
'''Property fullTextIndex: Full-text indexing configuration.
Full-text indexing and key indexing must have at least one enabled.
'''
result = self._values.get("full_text_index")
assert result is not None, "Required property 'full_text_index' is missing"
return typing.cast(typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosIndex.FullTextIndexProperty"], result)
@builtins.property
def logstore_name(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property logstoreName: Logstore name: 1.
Only supports lowercase letters, numbers, hyphens (-) and underscores (_).
2. Must start and end with lowercase letters and numbers.
3. The name length is 3-63 characters.
'''
result = self._values.get("logstore_name")
assert result is not None, "Required property 'logstore_name' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def project_name(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property projectName: Project name: 1.
Only supports lowercase letters, numbers, hyphens (-) and underscores (_).
2. Must start and end with lowercase letters and numbers.
3. The name length is 3-63 characters.
'''
result = self._values.get("project_name")
assert result is not None, "Required property 'project_name' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def key_indices(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosIndex.KeyIndicesProperty"]]]]:
'''Property keyIndices: Key index configurations.
Full-text indexing and key indexing must have at least one enabled.
'''
result = self._values.get("key_indices")
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosIndex.KeyIndicesProperty"]]]], result)
@builtins.property
def log_reduce(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property logReduce: Whether to enable log reduce.
Default to false.
'''
result = self._values.get("log_reduce")
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "IndexProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class Logstore(
_ros_cdk_core_7adfd82f.Resource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-sls.Logstore",
):
'''A ROS resource type: ``ALIYUN::SLS::Logstore``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["LogstoreProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
'''Create a new ``ALIYUN::SLS::Logstore``.
Param scope - scope in which this resource is defined
Param id - scoped id of the resource
Param props - resource properties
:param scope: -
:param id: -
:param props: -
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__c79bb65dcabce61b887a71b17ddce83bdae93928e2a65252e7a2b7ff3a264b9e)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@builtins.property
@jsii.member(jsii_name="attrLogstoreName")
def attr_logstore_name(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute LogstoreName: Logstore name.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrLogstoreName"))
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-sls.LogstoreProps",
jsii_struct_bases=[],
name_mapping={
"logstore_name": "logstoreName",
"project_name": "projectName",
"append_meta": "appendMeta",
"auto_split": "autoSplit",
"enable_tracking": "enableTracking",
"encrypt_conf": "encryptConf",
"max_split_shard": "maxSplitShard",
"preserve_storage": "preserveStorage",
"shard_count": "shardCount",
"ttl": "ttl",
},
)
class LogstoreProps:
def __init__(
self,
*,
logstore_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
project_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
append_meta: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
auto_split: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
enable_tracking: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
encrypt_conf: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union["RosLogstore.EncryptConfProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
max_split_shard: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
preserve_storage: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
shard_count: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
ttl: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::SLS::Logstore``.
:param logstore_name: Property logstoreName: Logstore name: 1. Only supports lowercase letters, numbers, hyphens (-) and underscores (_). 2. Must start and end with lowercase letters and numbers. 3. The name length is 3-63 characters.
:param project_name: Property projectName: Project name: 1. Only supports lowercase letters, numbers, hyphens (-) and underscores (_). 2. Must start and end with lowercase letters and numbers. 3. The name length is 3-63 characters.
:param append_meta: Property appendMeta: Whether to add client external network IP and log arrival time after receiving the log. Default to false.
:param auto_split: Property autoSplit: Whether to automatically split the shard. Default to false.
:param enable_tracking: Property enableTracking: Whether to enable WebTracking, which supports fast capture of various browsers and iOS/Android/APP access information. Default to false.
:param encrypt_conf: Property encryptConf: Data encryption config.
:param max_split_shard: Property maxSplitShard: The maximum number of shards when splitting automatically. Must be specified if AutoSplit is set to true. Allowed Values: 1-64.
:param preserve_storage: Property preserveStorage: Whether to keep the log permanently. If set to true, TTL will be ignored. Default to false.
:param shard_count: Property shardCount: The number of Shards. Allowed Values: 1-100, default to 2.
:param ttl: Property ttl: The lifecycle of log in the logstore in days. Allowed Values: 1-3600, default to 30.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__e93c4fefc36d5232872c87439488763bf3f8c4c3075cdb5894f83c2d2de01d77)
check_type(argname="argument logstore_name", value=logstore_name, expected_type=type_hints["logstore_name"])
check_type(argname="argument project_name", value=project_name, expected_type=type_hints["project_name"])
check_type(argname="argument append_meta", value=append_meta, expected_type=type_hints["append_meta"])
check_type(argname="argument auto_split", value=auto_split, expected_type=type_hints["auto_split"])
check_type(argname="argument enable_tracking", value=enable_tracking, expected_type=type_hints["enable_tracking"])
check_type(argname="argument encrypt_conf", value=encrypt_conf, expected_type=type_hints["encrypt_conf"])
check_type(argname="argument max_split_shard", value=max_split_shard, expected_type=type_hints["max_split_shard"])
check_type(argname="argument preserve_storage", value=preserve_storage, expected_type=type_hints["preserve_storage"])
check_type(argname="argument shard_count", value=shard_count, expected_type=type_hints["shard_count"])
check_type(argname="argument ttl", value=ttl, expected_type=type_hints["ttl"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"logstore_name": logstore_name,
"project_name": project_name,
}
if append_meta is not None:
self._values["append_meta"] = append_meta
if auto_split is not None:
self._values["auto_split"] = auto_split
if enable_tracking is not None:
self._values["enable_tracking"] = enable_tracking
if encrypt_conf is not None:
self._values["encrypt_conf"] = encrypt_conf
if max_split_shard is not None:
self._values["max_split_shard"] = max_split_shard
if preserve_storage is not None:
self._values["preserve_storage"] = preserve_storage
if shard_count is not None:
self._values["shard_count"] = shard_count
if ttl is not None:
self._values["ttl"] = ttl
@builtins.property
def logstore_name(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property logstoreName: Logstore name: 1.
Only supports lowercase letters, numbers, hyphens (-) and underscores (_).
2. Must start and end with lowercase letters and numbers.
3. The name length is 3-63 characters.
'''
result = self._values.get("logstore_name")
assert result is not None, "Required property 'logstore_name' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def project_name(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property projectName: Project name: 1.
Only supports lowercase letters, numbers, hyphens (-) and underscores (_).
2. Must start and end with lowercase letters and numbers.
3. The name length is 3-63 characters.
'''
result = self._values.get("project_name")
assert result is not None, "Required property 'project_name' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def append_meta(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property appendMeta: Whether to add client external network IP and log arrival time after receiving the log.
Default to false.
'''
result = self._values.get("append_meta")
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def auto_split(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property autoSplit: Whether to automatically split the shard.
Default to false.
'''
result = self._values.get("auto_split")
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def enable_tracking(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property enableTracking: Whether to enable WebTracking, which supports fast capture of various browsers and iOS/Android/APP access information.
Default to false.
'''
result = self._values.get("enable_tracking")
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def encrypt_conf(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosLogstore.EncryptConfProperty"]]:
'''Property encryptConf: Data encryption config.'''
result = self._values.get("encrypt_conf")
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosLogstore.EncryptConfProperty"]], result)
@builtins.property
def max_split_shard(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property maxSplitShard: The maximum number of shards when splitting automatically.
Must be specified if AutoSplit is set to true.
Allowed Values: 1-64.
'''
result = self._values.get("max_split_shard")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def preserve_storage(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property preserveStorage: Whether to keep the log permanently.
If set to true, TTL will be ignored.
Default to false.
'''
result = self._values.get("preserve_storage")
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def shard_count(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property shardCount: The number of Shards.
Allowed Values: 1-100, default to 2.
'''
result = self._values.get("shard_count")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def ttl(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property ttl: The lifecycle of log in the logstore in days.
Allowed Values: 1-3600, default to 30.
'''
result = self._values.get("ttl")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "LogstoreProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class LogtailConfig(
_ros_cdk_core_7adfd82f.Resource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-sls.LogtailConfig",
):
'''A ROS resource type: ``ALIYUN::SLS::LogtailConfig``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["LogtailConfigProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
'''Create a new ``ALIYUN::SLS::LogtailConfig``.
Param scope - scope in which this resource is defined
Param id - scoped id of the resource
Param props - resource properties
:param scope: -
:param id: -
:param props: -
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__70ffb82ed17c7a61e3451a40493e2f4eeb542c6ff00318fd972681920c0f24b9)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@builtins.property
@jsii.member(jsii_name="attrAppliedMachineGroups")
def attr_applied_machine_groups(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute AppliedMachineGroups: Applied machine groups.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrAppliedMachineGroups"))
@builtins.property
@jsii.member(jsii_name="attrEndpoint")
def attr_endpoint(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute Endpoint: Endpoint address.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrEndpoint"))
@builtins.property
@jsii.member(jsii_name="attrLogtailConfigName")
def attr_logtail_config_name(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute LogtailConfigName: Logtail config name.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrLogtailConfigName"))
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-sls.LogtailConfigProps",
jsii_struct_bases=[],
name_mapping={
"logstore_name": "logstoreName",
"logtail_config_name": "logtailConfigName",
"project_name": "projectName",
"clone_from": "cloneFrom",
"raw_config_data": "rawConfigData",
},
)
class LogtailConfigProps:
def __init__(
self,
*,
logstore_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
logtail_config_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
project_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
clone_from: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union["RosLogtailConfig.CloneFromProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
raw_config_data: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::SLS::LogtailConfig``.
:param logstore_name: Property logstoreName: Logstore name: 1. Only supports lowercase letters, numbers, hyphens (-) and underscores (_). 2. Must start and end with lowercase letters and numbers. 3. The name length is 3-63 characters.
:param logtail_config_name: Property logtailConfigName: Logtail config name: 1. Only supports lowercase letters, numbers, hyphens (-) and underscores (_). 2. Must start and end with lowercase letters and numbers. 3. The name length is 3-63 characters.
:param project_name: Property projectName: Project name: 1. Only supports lowercase letters, numbers, hyphens (-) and underscores (_). 2. Must start and end with lowercase letters and numbers. 3. The name length is 3-63 characters.
:param clone_from: Property cloneFrom: Clone logtail config data from existing logtail config. Either CloneFrom or RawConfigData must be specified. If CloneFrom and RawConfigData are both specified, logtail config data will be merged from both with RawConfigData first.
:param raw_config_data: Property rawConfigData: The format is the same as the response of SLS API GetConfig. Either CloneFrom or RawConfigData must be specified. If CloneFrom and RawConfigData are both specified, logtail config data will be merged from both with RawConfigData first. configName, outputType, outputDetail in data will be ignored.For example: { "configName": "test-logtail-config", "createTime": 1574843554, "inputDetail": { "acceptNoEnoughKeys": false, "adjustTimezone": false, "advanced": { "force_multiconfig": false }, "autoExtend": true, "delayAlarmBytes": 0, "delaySkipBytes": 0, "discardNonUtf8": false, "discardUnmatch": false, "dockerExcludeEnv": {}, "dockerExcludeLabel": {}, "dockerFile": false, "dockerIncludeEnv": {}, "dockerIncludeLabel": {}, "enableRawLog": false, "enableTag": false, "fileEncoding": "utf8", "filePattern": "test.log*", "filterKey": [], "filterRegex": [], "key": [ "time", "logger", "level", "request_id", "user_id", "region_id", "content" ], "localStorage": true, "logPath": "/var/log/test", "logTimezone": "", "logType": "delimiter_log", "maxDepth": 100, "maxSendRate": -1, "mergeType": "topic", "preserve": true, "preserveDepth": 1, "priority": 0, "quote": "\\u0001", "sendRateExpire": 0, "sensitive_keys": [], "separator": ",,,", "shardHashKey": [], "tailExisted": false, "timeFormat": "", "timeKey": "", "topicFormat": "none" }, "inputType": "file", "lastModifyTime": 1574843554, "logSample": "2019-11-27 10:48:23,160,,,MAIN,,,INFO,,,98DCC51D-BE5D-49C7-B3FD-37B2BAEFB296,,,123456789,,,cn-hangzhou,,,this is a simple test.", "outputDetail": { "endpoint": "cn-hangzhou-intranet.log.aliyuncs.com", "logstoreName": "test-logstore", "region": "cn-hangzhou" }, "outputType": "LogService" }
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__997427b30c5163225c21712ca6967753c2240e9b45aec519ef99002bd95d1ebd)
check_type(argname="argument logstore_name", value=logstore_name, expected_type=type_hints["logstore_name"])
check_type(argname="argument logtail_config_name", value=logtail_config_name, expected_type=type_hints["logtail_config_name"])
check_type(argname="argument project_name", value=project_name, expected_type=type_hints["project_name"])
check_type(argname="argument clone_from", value=clone_from, expected_type=type_hints["clone_from"])
check_type(argname="argument raw_config_data", value=raw_config_data, expected_type=type_hints["raw_config_data"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"logstore_name": logstore_name,
"logtail_config_name": logtail_config_name,
"project_name": project_name,
}
if clone_from is not None:
self._values["clone_from"] = clone_from
if raw_config_data is not None:
self._values["raw_config_data"] = raw_config_data
@builtins.property
def logstore_name(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property logstoreName: Logstore name: 1.
Only supports lowercase letters, numbers, hyphens (-) and underscores (_).
2. Must start and end with lowercase letters and numbers.
3. The name length is 3-63 characters.
'''
result = self._values.get("logstore_name")
assert result is not None, "Required property 'logstore_name' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def logtail_config_name(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property logtailConfigName: Logtail config name: 1.
Only supports lowercase letters, numbers, hyphens (-) and underscores (_).
2. Must start and end with lowercase letters and numbers.
3. The name length is 3-63 characters.
'''
result = self._values.get("logtail_config_name")
assert result is not None, "Required property 'logtail_config_name' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def project_name(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property projectName: Project name: 1.
Only supports lowercase letters, numbers, hyphens (-) and underscores (_).
2. Must start and end with lowercase letters and numbers.
3. The name length is 3-63 characters.
'''
result = self._values.get("project_name")
assert result is not None, "Required property 'project_name' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def clone_from(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosLogtailConfig.CloneFromProperty"]]:
'''Property cloneFrom: Clone logtail config data from existing logtail config.
Either CloneFrom or RawConfigData must be specified. If CloneFrom and RawConfigData are both specified, logtail config data will be merged from both with RawConfigData first.
'''
result = self._values.get("clone_from")
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosLogtailConfig.CloneFromProperty"]], result)
@builtins.property
def raw_config_data(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]]:
'''Property rawConfigData: The format is the same as the response of SLS API GetConfig.
Either CloneFrom or RawConfigData must be specified. If CloneFrom and RawConfigData are both specified, logtail config data will be merged from both with RawConfigData first.
configName, outputType, outputDetail in data will be ignored.For example:
{
"configName": "test-logtail-config",
"createTime": 1574843554,
"inputDetail": {
"acceptNoEnoughKeys": false,
"adjustTimezone": false,
"advanced": {
"force_multiconfig": false
},
"autoExtend": true,
"delayAlarmBytes": 0,
"delaySkipBytes": 0,
"discardNonUtf8": false,
"discardUnmatch": false,
"dockerExcludeEnv": {},
"dockerExcludeLabel": {},
"dockerFile": false,
"dockerIncludeEnv": {},
"dockerIncludeLabel": {},
"enableRawLog": false,
"enableTag": false,
"fileEncoding": "utf8",
"filePattern": "test.log*",
"filterKey": [],
"filterRegex": [],
"key": [
"time",
"logger",
"level",
"request_id",
"user_id",
"region_id",
"content"
],
"localStorage": true,
"logPath": "/var/log/test",
"logTimezone": "",
"logType": "delimiter_log",
"maxDepth": 100,
"maxSendRate": -1,
"mergeType": "topic",
"preserve": true,
"preserveDepth": 1,
"priority": 0,
"quote": "\\u0001",
"sendRateExpire": 0,
"sensitive_keys": [],
"separator": ",,,",
"shardHashKey": [],
"tailExisted": false,
"timeFormat": "",
"timeKey": "",
"topicFormat": "none"
},
"inputType": "file",
"lastModifyTime": 1574843554,
"logSample": "2019-11-27 10:48:23,160,,,MAIN,,,INFO,,,98DCC51D-BE5D-49C7-B3FD-37B2BAEFB296,,,123456789,,,cn-hangzhou,,,this is a simple test.",
"outputDetail": {
"endpoint": "cn-hangzhou-intranet.log.aliyuncs.com",
"logstoreName": "test-logstore",
"region": "cn-hangzhou"
},
"outputType": "LogService"
}
'''
result = self._values.get("raw_config_data")
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "LogtailConfigProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class MachineGroup(
_ros_cdk_core_7adfd82f.Resource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-sls.MachineGroup",
):
'''A ROS resource type: ``ALIYUN::SLS::MachineGroup``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Optional[typing.Union["MachineGroupProps", typing.Dict[builtins.str, typing.Any]]] = None,
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
'''Create a new ``ALIYUN::SLS::MachineGroup``.
Param scope - scope in which this resource is defined
Param id - scoped id of the resource
Param props - resource properties
:param scope: -
:param id: -
:param props: -
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__b22aba27590c9ba9fcef78ece9af9628932bed672c0ab16db139b31d1392669e)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@builtins.property
@jsii.member(jsii_name="attrGroupName")
def attr_group_name(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute GroupName: GroupName of SLS.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrGroupName"))
@builtins.property
@jsii.member(jsii_name="attrProjectName")
def attr_project_name(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute ProjectName: ProjectName of SLS.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrProjectName"))
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-sls.MachineGroupProps",
jsii_struct_bases=[],
name_mapping={
"group_attribute": "groupAttribute",
"group_name": "groupName",
"group_type": "groupType",
"machine_identify_type": "machineIdentifyType",
"machine_list": "machineList",
"project_name": "projectName",
},
)
class MachineGroupProps:
def __init__(
self,
*,
group_attribute: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
group_name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
group_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
machine_identify_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
machine_list: typing.Optional[typing.Union[typing.Sequence[typing.Any], _ros_cdk_core_7adfd82f.IResolvable]] = None,
project_name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::SLS::MachineGroup``.
:param group_attribute: Property groupAttribute: Group attribute, default is null. The object value is groupToic and externalName
:param group_name: Property groupName: Display name of the group name, the Project only. [2, 128] English or Chinese characters, must start with a letter or Chinese in size, can contain numbers, '_' or '.', '-'
:param group_type: Property groupType: MachineGroup type, the value is empty or Armory.
:param machine_identify_type: Property machineIdentifyType: Machine indentify type, the value is 'ip' or 'userdefined'.
:param machine_list: Property machineList: The machine tag, the value is ip or userdefined-id.
:param project_name: Property projectName: MachineGroup created in project.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__45ed99b8d188d732f608210e6fa1bc867af7e5ee0e1bab8d04237b6137de3303)
check_type(argname="argument group_attribute", value=group_attribute, expected_type=type_hints["group_attribute"])
check_type(argname="argument group_name", value=group_name, expected_type=type_hints["group_name"])
check_type(argname="argument group_type", value=group_type, expected_type=type_hints["group_type"])
check_type(argname="argument machine_identify_type", value=machine_identify_type, expected_type=type_hints["machine_identify_type"])
check_type(argname="argument machine_list", value=machine_list, expected_type=type_hints["machine_list"])
check_type(argname="argument project_name", value=project_name, expected_type=type_hints["project_name"])
self._values: typing.Dict[builtins.str, typing.Any] = {}
if group_attribute is not None:
self._values["group_attribute"] = group_attribute
if group_name is not None:
self._values["group_name"] = group_name
if group_type is not None:
self._values["group_type"] = group_type
if machine_identify_type is not None:
self._values["machine_identify_type"] = machine_identify_type
if machine_list is not None:
self._values["machine_list"] = machine_list
if project_name is not None:
self._values["project_name"] = project_name
@builtins.property
def group_attribute(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property groupAttribute: Group attribute, default is null.
The object value is groupToic and externalName
'''
result = self._values.get("group_attribute")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def group_name(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property groupName: Display name of the group name, the Project only.
[2, 128] English or Chinese characters, must start with a letter or Chinese in size, can contain numbers, '_' or '.', '-'
'''
result = self._values.get("group_name")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def group_type(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property groupType: MachineGroup type, the value is empty or Armory.'''
result = self._values.get("group_type")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def machine_identify_type(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property machineIdentifyType: Machine indentify type, the value is 'ip' or 'userdefined'.'''
result = self._values.get("machine_identify_type")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def machine_list(
self,
) -> typing.Optional[typing.Union[typing.List[typing.Any], _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property machineList: The machine tag, the value is ip or userdefined-id.'''
result = self._values.get("machine_list")
return typing.cast(typing.Optional[typing.Union[typing.List[typing.Any], _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def project_name(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property projectName: MachineGroup created in project.'''
result = self._values.get("project_name")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "MachineGroupProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class MetricStore(
_ros_cdk_core_7adfd82f.Resource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-sls.MetricStore",
):
'''A ROS resource type: ``ALIYUN::SLS::MetricStore``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["MetricStoreProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
'''Create a new ``ALIYUN::SLS::MetricStore``.
Param scope - scope in which this resource is defined
Param id - scoped id of the resource
Param props - resource properties
:param scope: -
:param id: -
:param props: -
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__4663a674839438b2c47edf7b54c23c2beedb0d1ce18df1282b31edadf5d78587)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@builtins.property
@jsii.member(jsii_name="attrLogstoreName")
def attr_logstore_name(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute LogstoreName: Metric store name.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrLogstoreName"))
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-sls.MetricStoreProps",
jsii_struct_bases=[],
name_mapping={
"logstore_name": "logstoreName",
"project_name": "projectName",
"preserve_storage": "preserveStorage",
"shard_count": "shardCount",
"ttl": "ttl",
},
)
class MetricStoreProps:
def __init__(
self,
*,
logstore_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
project_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
preserve_storage: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
shard_count: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
ttl: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::SLS::MetricStore``.
:param logstore_name: Property logstoreName: Metric store name: 1. Only supports lowercase letters, numbers, hyphens (-) and underscores (_). 2. Must start and end with lowercase letters and numbers. 3. The name length is 3-63 characters.
:param project_name: Property projectName: Project name: 1. Only supports lowercase letters, numbers, hyphens (-) and underscores (_). 2. Must start and end with lowercase letters and numbers. 3. The name length is 3-63 characters.
:param preserve_storage: Property preserveStorage: Whether to keep the log permanently. If set to true, TTL will be ignored. Default to false.
:param shard_count: Property shardCount: The number of Shards. Allowed Values: 1-10, default to 2.
:param ttl: Property ttl: The lifecycle of log in the metrice store in days. Allowed Values: 1-3000, default to 30.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__b34e84ca87f2fe6236aeb3933401db5149795129f06227666f5ad165a9ae952e)
check_type(argname="argument logstore_name", value=logstore_name, expected_type=type_hints["logstore_name"])
check_type(argname="argument project_name", value=project_name, expected_type=type_hints["project_name"])
check_type(argname="argument preserve_storage", value=preserve_storage, expected_type=type_hints["preserve_storage"])
check_type(argname="argument shard_count", value=shard_count, expected_type=type_hints["shard_count"])
check_type(argname="argument ttl", value=ttl, expected_type=type_hints["ttl"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"logstore_name": logstore_name,
"project_name": project_name,
}
if preserve_storage is not None:
self._values["preserve_storage"] = preserve_storage
if shard_count is not None:
self._values["shard_count"] = shard_count
if ttl is not None:
self._values["ttl"] = ttl
@builtins.property
def logstore_name(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property logstoreName: Metric store name: 1.
Only supports lowercase letters, numbers, hyphens (-) and underscores (_).
2. Must start and end with lowercase letters and numbers.
3. The name length is 3-63 characters.
'''
result = self._values.get("logstore_name")
assert result is not None, "Required property 'logstore_name' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def project_name(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property projectName: Project name: 1.
Only supports lowercase letters, numbers, hyphens (-) and underscores (_).
2. Must start and end with lowercase letters and numbers.
3. The name length is 3-63 characters.
'''
result = self._values.get("project_name")
assert result is not None, "Required property 'project_name' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def preserve_storage(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property preserveStorage: Whether to keep the log permanently.
If set to true, TTL will be ignored.
Default to false.
'''
result = self._values.get("preserve_storage")
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def shard_count(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property shardCount: The number of Shards.
Allowed Values: 1-10, default to 2.
'''
result = self._values.get("shard_count")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def ttl(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property ttl: The lifecycle of log in the metrice store in days.
Allowed Values: 1-3000, default to 30.
'''
result = self._values.get("ttl")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "MetricStoreProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class Project(
_ros_cdk_core_7adfd82f.Resource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-sls.Project",
):
'''A ROS resource type: ``ALIYUN::SLS::Project``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["ProjectProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
'''Create a new ``ALIYUN::SLS::Project``.
Param scope - scope in which this resource is defined
Param id - scoped id of the resource
Param props - resource properties
:param scope: -
:param id: -
:param props: -
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__43e5ccce68dcd7589fe7a912c535fededac7de18ffe6efb56ce3a0e02ca34050)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@builtins.property
@jsii.member(jsii_name="attrName")
def attr_name(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute Name: Project name.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrName"))
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-sls.ProjectProps",
jsii_struct_bases=[],
name_mapping={"name": "name", "description": "description", "tags": "tags"},
)
class ProjectProps:
def __init__(
self,
*,
name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
description: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
tags: typing.Optional[typing.Sequence[typing.Union["RosProject.TagsProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::SLS::Project``.
:param name: Property name: Project name: 1. Only supports lowercase letters, numbers, hyphens (-) and underscores (_). 2. Must start and end with lowercase letters and numbers. 3. The name length is 3-63 characters.
:param description: Property description: Project description: <>'"\\ is not supported, up to 64 characters.
:param tags: Property tags: Tags to attach to project. Max support 20 tags to add during create project. Each tag with two properties Key and Value, and Key is required.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__e8200cc4deccd66b4f1d77b8d6692341d01973dca3ef46fe9678865407d439cb)
check_type(argname="argument name", value=name, expected_type=type_hints["name"])
check_type(argname="argument description", value=description, expected_type=type_hints["description"])
check_type(argname="argument tags", value=tags, expected_type=type_hints["tags"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"name": name,
}
if description is not None:
self._values["description"] = description
if tags is not None:
self._values["tags"] = tags
@builtins.property
def name(self) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property name: Project name: 1.
Only supports lowercase letters, numbers, hyphens (-) and underscores (_).
2. Must start and end with lowercase letters and numbers.
3. The name length is 3-63 characters.
'''
result = self._values.get("name")
assert result is not None, "Required property 'name' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def description(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property description: Project description: <>'"\\ is not supported, up to 64 characters.'''
result = self._values.get("description")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def tags(self) -> typing.Optional[typing.List["RosProject.TagsProperty"]]:
'''Property tags: Tags to attach to project.
Max support 20 tags to add during create project. Each tag with two properties Key and Value, and Key is required.
'''
result = self._values.get("tags")
return typing.cast(typing.Optional[typing.List["RosProject.TagsProperty"]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "ProjectProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class RosAlert(
_ros_cdk_core_7adfd82f.RosResource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-sls.RosAlert",
):
'''A ROS template type: ``ALIYUN::SLS::Alert``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["RosAlertProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
'''Create a new ``ALIYUN::SLS::Alert``.
:param scope: - scope in which this resource is defined.
:param id: - scoped id of the resource.
:param props: - resource properties.
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__d81c9e3194e6b74ce23c4c5e1d279882e3252bf091e874c82783f7ac748f7177)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@jsii.member(jsii_name="renderProperties")
def _render_properties(
self,
props: typing.Mapping[builtins.str, typing.Any],
) -> typing.Mapping[builtins.str, typing.Any]:
'''
:param props: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__d4d410b4f4685a4baf0479d010a853ff24bfbd0f3059de40d98068a808e88a7b)
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))
@jsii.python.classproperty
@jsii.member(jsii_name="ROS_RESOURCE_TYPE_NAME")
def ROS_RESOURCE_TYPE_NAME(cls) -> builtins.str:
'''The resource type name for this resource class.'''
return typing.cast(builtins.str, jsii.sget(cls, "ROS_RESOURCE_TYPE_NAME"))
@builtins.property
@jsii.member(jsii_name="attrName")
def attr_name(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: Name: Alert name.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrName"))
@builtins.property
@jsii.member(jsii_name="rosProperties")
def _ros_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "rosProperties"))
@builtins.property
@jsii.member(jsii_name="detail")
def detail(
self,
) -> typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosAlert.DetailProperty"]:
'''
:Property: detail:
'''
return typing.cast(typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosAlert.DetailProperty"], jsii.get(self, "detail"))
@detail.setter
def detail(
self,
value: typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosAlert.DetailProperty"],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__916f1f24d97236db3a911f4c9e173175fefd41025b668e4820e1d7d21c45adc6)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "detail", value)
@builtins.property
@jsii.member(jsii_name="enableResourcePropertyConstraint")
def enable_resource_property_constraint(self) -> builtins.bool:
return typing.cast(builtins.bool, jsii.get(self, "enableResourcePropertyConstraint"))
@enable_resource_property_constraint.setter
def enable_resource_property_constraint(self, value: builtins.bool) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__41eac6e8840febf9281354bd51a1d0951f6fbff1e70327787d45e0481fd96b11)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "enableResourcePropertyConstraint", value)
@builtins.property
@jsii.member(jsii_name="project")
def project(self) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
project: Project name:
1. Only supports lowercase letters, numbers, hyphens (-) and underscores (_).
2. Must start and end with lowercase letters and numbers.
3. The name length is 3-63 characters.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "project"))
@project.setter
def project(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__2ceefc40fd026b604c27ac8617a5f924b8bed63bdd4be5315c6519368d5fb177)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "project", value)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-sls.RosAlert.AnnotationsProperty",
jsii_struct_bases=[],
name_mapping={"key": "key", "value": "value"},
)
class AnnotationsProperty:
def __init__(
self,
*,
key: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
'''
:param key:
:param value:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__d177d30c91b26129266385e50775754752a8632d3f8c4221bd5d6c21c5b479cd)
check_type(argname="argument key", value=key, expected_type=type_hints["key"])
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"key": key,
"value": value,
}
@builtins.property
def key(self) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: key:
'''
result = self._values.get("key")
assert result is not None, "Required property 'key' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def value(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: value:
'''
result = self._values.get("value")
assert result is not None, "Required property 'value' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "AnnotationsProperty(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-sls.RosAlert.ConfigurationProperty",
jsii_struct_bases=[],
name_mapping={
"dashboard": "dashboard",
"query_list": "queryList",
"annotations": "annotations",
"auto_annotation": "autoAnnotation",
"condition": "condition",
"group_configuration": "groupConfiguration",
"join_configurations": "joinConfigurations",
"labels": "labels",
"mute_until": "muteUntil",
"no_data_fire": "noDataFire",
"no_data_severity": "noDataSeverity",
"notification_list": "notificationList",
"notify_threshold": "notifyThreshold",
"policy_configuration": "policyConfiguration",
"send_resolved": "sendResolved",
"severity_configurations": "severityConfigurations",
"threshold": "threshold",
"throttling": "throttling",
"type": "type",
"version": "version",
},
)
class ConfigurationProperty:
def __init__(
self,
*,
dashboard: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
query_list: typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union["RosAlert.QueryListProperty", typing.Dict[builtins.str, typing.Any]]]]],
annotations: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union["RosAlert.AnnotationsProperty", typing.Dict[builtins.str, typing.Any]]]]]] = None,
auto_annotation: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
condition: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
group_configuration: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union["RosAlert.GroupConfigurationProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
join_configurations: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union["RosAlert.JoinConfigurationsProperty", typing.Dict[builtins.str, typing.Any]]]]]] = None,
labels: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union["RosAlert.LabelsProperty", typing.Dict[builtins.str, typing.Any]]]]]] = None,
mute_until: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
no_data_fire: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
no_data_severity: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
notification_list: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union["RosAlert.NotificationListProperty", typing.Dict[builtins.str, typing.Any]]]]]] = None,
notify_threshold: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
policy_configuration: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union["RosAlert.PolicyConfigurationProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
send_resolved: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
severity_configurations: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union["RosAlert.SeverityConfigurationsProperty", typing.Dict[builtins.str, typing.Any]]]]]] = None,
threshold: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
throttling: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
version: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''
:param dashboard:
:param query_list:
:param annotations:
:param auto_annotation:
:param condition:
:param group_configuration:
:param join_configurations:
:param labels:
:param mute_until:
:param no_data_fire:
:param no_data_severity:
:param notification_list:
:param notify_threshold:
:param policy_configuration:
:param send_resolved:
:param severity_configurations:
:param threshold:
:param throttling:
:param type:
:param version:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__c40c5940d9d97be9c83588103df6b0efbb235317d46fe5b6ac39a04a0f362866)
check_type(argname="argument dashboard", value=dashboard, expected_type=type_hints["dashboard"])
check_type(argname="argument query_list", value=query_list, expected_type=type_hints["query_list"])
check_type(argname="argument annotations", value=annotations, expected_type=type_hints["annotations"])
check_type(argname="argument auto_annotation", value=auto_annotation, expected_type=type_hints["auto_annotation"])
check_type(argname="argument condition", value=condition, expected_type=type_hints["condition"])
check_type(argname="argument group_configuration", value=group_configuration, expected_type=type_hints["group_configuration"])
check_type(argname="argument join_configurations", value=join_configurations, expected_type=type_hints["join_configurations"])
check_type(argname="argument labels", value=labels, expected_type=type_hints["labels"])
check_type(argname="argument mute_until", value=mute_until, expected_type=type_hints["mute_until"])
check_type(argname="argument no_data_fire", value=no_data_fire, expected_type=type_hints["no_data_fire"])
check_type(argname="argument no_data_severity", value=no_data_severity, expected_type=type_hints["no_data_severity"])
check_type(argname="argument notification_list", value=notification_list, expected_type=type_hints["notification_list"])
check_type(argname="argument notify_threshold", value=notify_threshold, expected_type=type_hints["notify_threshold"])
check_type(argname="argument policy_configuration", value=policy_configuration, expected_type=type_hints["policy_configuration"])
check_type(argname="argument send_resolved", value=send_resolved, expected_type=type_hints["send_resolved"])
check_type(argname="argument severity_configurations", value=severity_configurations, expected_type=type_hints["severity_configurations"])
check_type(argname="argument threshold", value=threshold, expected_type=type_hints["threshold"])
check_type(argname="argument throttling", value=throttling, expected_type=type_hints["throttling"])
check_type(argname="argument type", value=type, expected_type=type_hints["type"])
check_type(argname="argument version", value=version, expected_type=type_hints["version"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"dashboard": dashboard,
"query_list": query_list,
}
if annotations is not None:
self._values["annotations"] = annotations
if auto_annotation is not None:
self._values["auto_annotation"] = auto_annotation
if condition is not None:
self._values["condition"] = condition
if group_configuration is not None:
self._values["group_configuration"] = group_configuration
if join_configurations is not None:
self._values["join_configurations"] = join_configurations
if labels is not None:
self._values["labels"] = labels
if mute_until is not None:
self._values["mute_until"] = mute_until
if no_data_fire is not None:
self._values["no_data_fire"] = no_data_fire
if no_data_severity is not None:
self._values["no_data_severity"] = no_data_severity
if notification_list is not None:
self._values["notification_list"] = notification_list
if notify_threshold is not None:
self._values["notify_threshold"] = notify_threshold
if policy_configuration is not None:
self._values["policy_configuration"] = policy_configuration
if send_resolved is not None:
self._values["send_resolved"] = send_resolved
if severity_configurations is not None:
self._values["severity_configurations"] = severity_configurations
if threshold is not None:
self._values["threshold"] = threshold
if throttling is not None:
self._values["throttling"] = throttling
if type is not None:
self._values["type"] = type
if version is not None:
self._values["version"] = version
@builtins.property
def dashboard(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: dashboard: Alarm associated dashboard.
'''
result = self._values.get("dashboard")
assert result is not None, "Required property 'dashboard' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def query_list(
self,
) -> typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosAlert.QueryListProperty"]]]:
'''
:Property: queryList:
'''
result = self._values.get("query_list")
assert result is not None, "Required property 'query_list' is missing"
return typing.cast(typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosAlert.QueryListProperty"]]], result)
@builtins.property
def annotations(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosAlert.AnnotationsProperty"]]]]:
'''
:Property: annotations: The list of annotations.
'''
result = self._values.get("annotations")
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosAlert.AnnotationsProperty"]]]], result)
@builtins.property
def auto_annotation(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: autoAnnotation:
'''
result = self._values.get("auto_annotation")
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def condition(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
condition: The condition that is required to trigger an alert.
Log Service triggers an alert if the trigger condition is met.
For example, you can set the trigger condition to pv%100 > 0 && uv > 0.
'''
result = self._values.get("condition")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def group_configuration(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosAlert.GroupConfigurationProperty"]]:
'''
:Property: groupConfiguration:
'''
result = self._values.get("group_configuration")
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosAlert.GroupConfigurationProperty"]], result)
@builtins.property
def join_configurations(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosAlert.JoinConfigurationsProperty"]]]]:
'''
:Property: joinConfigurations: The list of Join conditions when multiple tables are joined. For example, 3 tables join, and 2 joinConfigurations are passed in.
'''
result = self._values.get("join_configurations")
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosAlert.JoinConfigurationsProperty"]]]], result)
@builtins.property
def labels(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosAlert.LabelsProperty"]]]]:
'''
:Property: labels: The list of tags.
'''
result = self._values.get("labels")
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosAlert.LabelsProperty"]]]], result)
@builtins.property
def mute_until(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: muteUntil:
'''
result = self._values.get("mute_until")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def no_data_fire(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: noDataFire: Whether to trigger an alarm if there is no data, the default is false.
'''
result = self._values.get("no_data_fire")
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def no_data_severity(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
noDataSeverity: The alarm level when there is no data to trigger the alarm. Valid values:
2: Report
4: Low
6: Medium
8: High
10: Critical.
'''
result = self._values.get("no_data_severity")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def notification_list(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosAlert.NotificationListProperty"]]]]:
'''
:Property: notificationList:
'''
result = self._values.get("notification_list")
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosAlert.NotificationListProperty"]]]], result)
@builtins.property
def notify_threshold(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
notifyThreshold: The notification threshold,
which will not be notified until the number of triggers is reached.
'''
result = self._values.get("notify_threshold")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def policy_configuration(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosAlert.PolicyConfigurationProperty"]]:
'''
:Property: policyConfiguration:
'''
result = self._values.get("policy_configuration")
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosAlert.PolicyConfigurationProperty"]], result)
@builtins.property
def send_resolved(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: sendResolved: Whether to notify when the alarm is restored, the default is false.
'''
result = self._values.get("send_resolved")
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def severity_configurations(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosAlert.SeverityConfigurationsProperty"]]]]:
'''
:Property: severityConfigurations: The list of severity configurations.
'''
result = self._values.get("severity_configurations")
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosAlert.SeverityConfigurationsProperty"]]]], result)
@builtins.property
def threshold(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: threshold: Trigger threshold.
'''
result = self._values.get("threshold")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def throttling(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: throttling: Notification interval, default is no interval.
'''
result = self._values.get("throttling")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def type(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: type: Configuration type.
'''
result = self._values.get("type")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def version(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: version: Configuration version.
'''
result = self._values.get("version")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "ConfigurationProperty(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-sls.RosAlert.DetailProperty",
jsii_struct_bases=[],
name_mapping={
"configuration": "configuration",
"display_name": "displayName",
"name": "name",
"schedule": "schedule",
"description": "description",
"state": "state",
"type": "type",
},
)
class DetailProperty:
def __init__(
self,
*,
configuration: typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union["RosAlert.ConfigurationProperty", typing.Dict[builtins.str, typing.Any]]],
display_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
schedule: typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union["RosAlert.ScheduleProperty", typing.Dict[builtins.str, typing.Any]]],
description: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
state: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''
:param configuration:
:param display_name:
:param name:
:param schedule:
:param description:
:param state:
:param type:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__a1b980fb01df01e7cca013f9fc86e5c17aad18f9d87e2e9ca54b93c028f419d2)
check_type(argname="argument configuration", value=configuration, expected_type=type_hints["configuration"])
check_type(argname="argument display_name", value=display_name, expected_type=type_hints["display_name"])
check_type(argname="argument name", value=name, expected_type=type_hints["name"])
check_type(argname="argument schedule", value=schedule, expected_type=type_hints["schedule"])
check_type(argname="argument description", value=description, expected_type=type_hints["description"])
check_type(argname="argument state", value=state, expected_type=type_hints["state"])
check_type(argname="argument type", value=type, expected_type=type_hints["type"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"configuration": configuration,
"display_name": display_name,
"name": name,
"schedule": schedule,
}
if description is not None:
self._values["description"] = description
if state is not None:
self._values["state"] = state
if type is not None:
self._values["type"] = type
@builtins.property
def configuration(
self,
) -> typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosAlert.ConfigurationProperty"]:
'''
:Property: configuration:
'''
result = self._values.get("configuration")
assert result is not None, "Required property 'configuration' is missing"
return typing.cast(typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosAlert.ConfigurationProperty"], result)
@builtins.property
def display_name(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: displayName: Alert name display in console. The name length is 1-64 characters.
'''
result = self._values.get("display_name")
assert result is not None, "Required property 'display_name' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def name(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: name: Alert name.
'''
result = self._values.get("name")
assert result is not None, "Required property 'name' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def schedule(
self,
) -> typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosAlert.ScheduleProperty"]:
'''
:Property:
schedule: The interval at which Log Service evaluates the alert rule.
Note During an alert rule evaluation, if a query returns more than 100 log entries,
Log Service checks only the first 100 log entries.
'''
result = self._values.get("schedule")
assert result is not None, "Required property 'schedule' is missing"
return typing.cast(typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosAlert.ScheduleProperty"], result)
@builtins.property
def description(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: description: Description of the alert.
'''
result = self._values.get("description")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def state(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: state:
'''
result = self._values.get("state")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def type(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: type:
'''
result = self._values.get("type")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "DetailProperty(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-sls.RosAlert.EvalConditionProperty",
jsii_struct_bases=[],
name_mapping={"condition": "condition", "count_condition": "countCondition"},
)
class EvalConditionProperty:
def __init__(
self,
*,
condition: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
count_condition: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''
:param condition:
:param count_condition:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__9baca7159b8bd19387ed97626c68cdfd774f1dcc1af7da6401a45e579625eb5a)
check_type(argname="argument condition", value=condition, expected_type=type_hints["condition"])
check_type(argname="argument count_condition", value=count_condition, expected_type=type_hints["count_condition"])
self._values: typing.Dict[builtins.str, typing.Any] = {}
if condition is not None:
self._values["condition"] = condition
if count_condition is not None:
self._values["count_condition"] = count_condition
@builtins.property
def condition(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: condition: It is triggered when any piece of data in the result of judging the Cartesian product satisfies the Condition. After grouping, it indicates the data trigger condition for each group, and an empty string indicates that any data row is satisfied.
'''
result = self._values.get("condition")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def count_condition(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: countCondition: Alarm expression, indicating how much data meets the alarm condition.
'''
result = self._values.get("count_condition")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "EvalConditionProperty(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-sls.RosAlert.GroupConfigurationProperty",
jsii_struct_bases=[],
name_mapping={"type": "type", "fields": "fields"},
)
class GroupConfigurationProperty:
def __init__(
self,
*,
type: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
fields: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]] = None,
) -> None:
'''
:param type:
:param fields:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__8335fbd7beb94c51b7a74abf2a0515bdf8c2144e3face1e0111afd38cc5a617d)
check_type(argname="argument type", value=type, expected_type=type_hints["type"])
check_type(argname="argument fields", value=fields, expected_type=type_hints["fields"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"type": type,
}
if fields is not None:
self._values["fields"] = fields
@builtins.property
def type(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
type: Grouping type.
no_group: no grouping
labels_auto: autocustom: custom.
'''
result = self._values.get("type")
assert result is not None, "Required property 'type' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def fields(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]]:
'''
:Property: fields: The fields of group. Fill in the empty list when not group. No fill when group automatically. Fill required when group in custom.
'''
result = self._values.get("fields")
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "GroupConfigurationProperty(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-sls.RosAlert.JoinConfigurationsProperty",
jsii_struct_bases=[],
name_mapping={"type": "type", "condition": "condition"},
)
class JoinConfigurationsProperty:
def __init__(
self,
*,
type: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
condition: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''
:param type:
:param condition:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__bb37763eb7980adc3f4162a2b98986b2371ec6bc9b4ec74553a9d5d56b84b542)
check_type(argname="argument type", value=type, expected_type=type_hints["type"])
check_type(argname="argument condition", value=condition, expected_type=type_hints["condition"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"type": type,
}
if condition is not None:
self._values["condition"] = condition
@builtins.property
def type(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: type: The type of set operation join.
'''
result = self._values.get("type")
assert result is not None, "Required property 'type' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def condition(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: condition: Condition for a set operation. Not required when using Cartesian product.
'''
result = self._values.get("condition")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "JoinConfigurationsProperty(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-sls.RosAlert.LabelsProperty",
jsii_struct_bases=[],
name_mapping={"key": "key", "value": "value"},
)
class LabelsProperty:
def __init__(
self,
*,
key: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
'''
:param key:
:param value:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__330c80b091e838652d1dcd3174153eabe55351c1bf74e4246a6dd874081b732b)
check_type(argname="argument key", value=key, expected_type=type_hints["key"])
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"key": key,
"value": value,
}
@builtins.property
def key(self) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: key:
'''
result = self._values.get("key")
assert result is not None, "Required property 'key' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def value(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: value:
'''
result = self._values.get("value")
assert result is not None, "Required property 'value' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "LabelsProperty(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-sls.RosAlert.NotificationListProperty",
jsii_struct_bases=[],
name_mapping={
"type": "type",
"content": "content",
"email_list": "emailList",
"headers": "headers",
"method": "method",
"mobile_list": "mobileList",
"service_uri": "serviceUri",
},
)
class NotificationListProperty:
def __init__(
self,
*,
type: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
content: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
email_list: typing.Optional[typing.Union[typing.Sequence[typing.Any], _ros_cdk_core_7adfd82f.IResolvable]] = None,
headers: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]] = None,
method: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
mobile_list: typing.Optional[typing.Union[typing.Sequence[typing.Any], _ros_cdk_core_7adfd82f.IResolvable]] = None,
service_uri: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''
:param type:
:param content:
:param email_list:
:param headers:
:param method:
:param mobile_list:
:param service_uri:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__0dadac77daffa12d08cfcd4cc632a75631f1d14dbf49037a5890a74c08721c3a)
check_type(argname="argument type", value=type, expected_type=type_hints["type"])
check_type(argname="argument content", value=content, expected_type=type_hints["content"])
check_type(argname="argument email_list", value=email_list, expected_type=type_hints["email_list"])
check_type(argname="argument headers", value=headers, expected_type=type_hints["headers"])
check_type(argname="argument method", value=method, expected_type=type_hints["method"])
check_type(argname="argument mobile_list", value=mobile_list, expected_type=type_hints["mobile_list"])
check_type(argname="argument service_uri", value=service_uri, expected_type=type_hints["service_uri"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"type": type,
}
if content is not None:
self._values["content"] = content
if email_list is not None:
self._values["email_list"] = email_list
if headers is not None:
self._values["headers"] = headers
if method is not None:
self._values["method"] = method
if mobile_list is not None:
self._values["mobile_list"] = mobile_list
if service_uri is not None:
self._values["service_uri"] = service_uri
@builtins.property
def type(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
type: This topic describes how to configure a notification method.
Log Service can send alert notifications by using one or more methods.
Available notification methods include emails, DingTalk chatbot webhooks,
custom webhooks, and Alibaba Cloud Message Center.
'''
result = self._values.get("type")
assert result is not None, "Required property 'type' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def content(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: content: The content of an alert notification
'''
result = self._values.get("content")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def email_list(
self,
) -> typing.Optional[typing.Union[typing.List[typing.Any], _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: emailList:
'''
result = self._values.get("email_list")
return typing.cast(typing.Optional[typing.Union[typing.List[typing.Any], _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def headers(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]]:
'''
:Property: headers:
'''
result = self._values.get("headers")
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]], result)
@builtins.property
def method(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: method:
'''
result = self._values.get("method")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def mobile_list(
self,
) -> typing.Optional[typing.Union[typing.List[typing.Any], _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: mobileList:
'''
result = self._values.get("mobile_list")
return typing.cast(typing.Optional[typing.Union[typing.List[typing.Any], _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def service_uri(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: serviceUri: The webhook URL of the DingTalk chatbot.
'''
result = self._values.get("service_uri")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "NotificationListProperty(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-sls.RosAlert.PolicyConfigurationProperty",
jsii_struct_bases=[],
name_mapping={
"action_policy_id": "actionPolicyId",
"alert_policy_id": "alertPolicyId",
"repeat_interval": "repeatInterval",
"use_default": "useDefault",
},
)
class PolicyConfigurationProperty:
def __init__(
self,
*,
action_policy_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
alert_policy_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
repeat_interval: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
use_default: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''
:param action_policy_id:
:param alert_policy_id:
:param repeat_interval:
:param use_default:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__cea1347ca092dea0f8a2d7a1806f9c9f6eb5df8ef4f23212cc08f852fedee5df)
check_type(argname="argument action_policy_id", value=action_policy_id, expected_type=type_hints["action_policy_id"])
check_type(argname="argument alert_policy_id", value=alert_policy_id, expected_type=type_hints["alert_policy_id"])
check_type(argname="argument repeat_interval", value=repeat_interval, expected_type=type_hints["repeat_interval"])
check_type(argname="argument use_default", value=use_default, expected_type=type_hints["use_default"])
self._values: typing.Dict[builtins.str, typing.Any] = {}
if action_policy_id is not None:
self._values["action_policy_id"] = action_policy_id
if alert_policy_id is not None:
self._values["alert_policy_id"] = alert_policy_id
if repeat_interval is not None:
self._values["repeat_interval"] = repeat_interval
if use_default is not None:
self._values["use_default"] = use_default
@builtins.property
def action_policy_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: actionPolicyId: The ID of action policy. It is useful when an alert policy references a dynamic action policy.
'''
result = self._values.get("action_policy_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def alert_policy_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: alertPolicyId: The ID of alert policy.
'''
result = self._values.get("alert_policy_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def repeat_interval(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: repeatInterval: Repeat interval. The format is number with suffix s/m/h.
'''
result = self._values.get("repeat_interval")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def use_default(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: useDefault:
'''
result = self._values.get("use_default")
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "PolicyConfigurationProperty(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-sls.RosAlert.QueryListProperty",
jsii_struct_bases=[],
name_mapping={
"end": "end",
"query": "query",
"start": "start",
"time_span_type": "timeSpanType",
"chart_title": "chartTitle",
"dashboard_id": "dashboardId",
"log_store": "logStore",
"power_sql_mode": "powerSqlMode",
"project": "project",
"region": "region",
"role_arn": "roleArn",
"store": "store",
"store_type": "storeType",
},
)
class QueryListProperty:
def __init__(
self,
*,
end: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
query: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
start: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
time_span_type: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
chart_title: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
dashboard_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
log_store: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
power_sql_mode: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
project: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
region: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
role_arn: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
store: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
store_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''
:param end:
:param query:
:param start:
:param time_span_type:
:param chart_title:
:param dashboard_id:
:param log_store:
:param power_sql_mode:
:param project:
:param region:
:param role_arn:
:param store:
:param store_type:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__86fafbbbc10fca3015f28a29fa7dc2f5489989dc36e8bf3ed1fd392f86183ea6)
check_type(argname="argument end", value=end, expected_type=type_hints["end"])
check_type(argname="argument query", value=query, expected_type=type_hints["query"])
check_type(argname="argument start", value=start, expected_type=type_hints["start"])
check_type(argname="argument time_span_type", value=time_span_type, expected_type=type_hints["time_span_type"])
check_type(argname="argument chart_title", value=chart_title, expected_type=type_hints["chart_title"])
check_type(argname="argument dashboard_id", value=dashboard_id, expected_type=type_hints["dashboard_id"])
check_type(argname="argument log_store", value=log_store, expected_type=type_hints["log_store"])
check_type(argname="argument power_sql_mode", value=power_sql_mode, expected_type=type_hints["power_sql_mode"])
check_type(argname="argument project", value=project, expected_type=type_hints["project"])
check_type(argname="argument region", value=region, expected_type=type_hints["region"])
check_type(argname="argument role_arn", value=role_arn, expected_type=type_hints["role_arn"])
check_type(argname="argument store", value=store, expected_type=type_hints["store"])
check_type(argname="argument store_type", value=store_type, expected_type=type_hints["store_type"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"end": end,
"query": query,
"start": start,
"time_span_type": time_span_type,
}
if chart_title is not None:
self._values["chart_title"] = chart_title
if dashboard_id is not None:
self._values["dashboard_id"] = dashboard_id
if log_store is not None:
self._values["log_store"] = log_store
if power_sql_mode is not None:
self._values["power_sql_mode"] = power_sql_mode
if project is not None:
self._values["project"] = project
if region is not None:
self._values["region"] = region
if role_arn is not None:
self._values["role_arn"] = role_arn
if store is not None:
self._values["store"] = store
if store_type is not None:
self._values["store_type"] = store_type
@builtins.property
def end(self) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: end:
'''
result = self._values.get("end")
assert result is not None, "Required property 'end' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def query(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: query:
'''
result = self._values.get("query")
assert result is not None, "Required property 'query' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def start(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: start:
'''
result = self._values.get("start")
assert result is not None, "Required property 'start' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def time_span_type(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: timeSpanType:
'''
result = self._values.get("time_span_type")
assert result is not None, "Required property 'time_span_type' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def chart_title(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: chartTitle:
'''
result = self._values.get("chart_title")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def dashboard_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: dashboardId: The ID of associated dashboard.
'''
result = self._values.get("dashboard_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def log_store(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: logStore:
'''
result = self._values.get("log_store")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def power_sql_mode(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: powerSqlMode:
'''
result = self._values.get("power_sql_mode")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def project(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: project:
'''
result = self._values.get("project")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def region(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: region:
'''
result = self._values.get("region")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def role_arn(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: roleArn: ARN used by role access.
'''
result = self._values.get("role_arn")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def store(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
store: When StoreType is log or metric, it indicates the LogStore to be queried.
When StoreType is meta, it indicates the ResourceName to be queried.
'''
result = self._values.get("store")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def store_type(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
storeType: Log store type. Valid values:
log: sls query analysis statement
metric: sls time series data
meta: query metastore.
'''
result = self._values.get("store_type")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "QueryListProperty(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-sls.RosAlert.ScheduleProperty",
jsii_struct_bases=[],
name_mapping={
"type": "type",
"cron_expression": "cronExpression",
"day_of_week": "dayOfWeek",
"delay": "delay",
"hour": "hour",
"interval": "interval",
"run_immediately": "runImmediately",
},
)
class ScheduleProperty:
def __init__(
self,
*,
type: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
cron_expression: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
day_of_week: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
delay: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
hour: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
interval: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
run_immediately: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''
:param type:
:param cron_expression:
:param day_of_week:
:param delay:
:param hour:
:param interval:
:param run_immediately:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__c34ed5f1de3c4967fda894df32f3f1b97edb2df72eb5c71d737b6cd739f64af7)
check_type(argname="argument type", value=type, expected_type=type_hints["type"])
check_type(argname="argument cron_expression", value=cron_expression, expected_type=type_hints["cron_expression"])
check_type(argname="argument day_of_week", value=day_of_week, expected_type=type_hints["day_of_week"])
check_type(argname="argument delay", value=delay, expected_type=type_hints["delay"])
check_type(argname="argument hour", value=hour, expected_type=type_hints["hour"])
check_type(argname="argument interval", value=interval, expected_type=type_hints["interval"])
check_type(argname="argument run_immediately", value=run_immediately, expected_type=type_hints["run_immediately"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"type": type,
}
if cron_expression is not None:
self._values["cron_expression"] = cron_expression
if day_of_week is not None:
self._values["day_of_week"] = day_of_week
if delay is not None:
self._values["delay"] = delay
if hour is not None:
self._values["hour"] = hour
if interval is not None:
self._values["interval"] = interval
if run_immediately is not None:
self._values["run_immediately"] = run_immediately
@builtins.property
def type(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: type:
'''
result = self._values.get("type")
assert result is not None, "Required property 'type' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def cron_expression(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: cronExpression:
'''
result = self._values.get("cron_expression")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def day_of_week(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: dayOfWeek:
'''
result = self._values.get("day_of_week")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def delay(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: delay:
'''
result = self._values.get("delay")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def hour(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: hour:
'''
result = self._values.get("hour")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def interval(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: interval: Execution interval
'''
result = self._values.get("interval")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def run_immediately(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: runImmediately:
'''
result = self._values.get("run_immediately")
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "ScheduleProperty(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-sls.RosAlert.SeverityConfigurationsProperty",
jsii_struct_bases=[],
name_mapping={"severity": "severity", "eval_condition": "evalCondition"},
)
class SeverityConfigurationsProperty:
def __init__(
self,
*,
severity: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
eval_condition: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union["RosAlert.EvalConditionProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
'''
:param severity:
:param eval_condition:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__7e55c1d8adc9c7e907a04150d234949970efec6488cf020183afce9f2050ff11)
check_type(argname="argument severity", value=severity, expected_type=type_hints["severity"])
check_type(argname="argument eval_condition", value=eval_condition, expected_type=type_hints["eval_condition"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"severity": severity,
}
if eval_condition is not None:
self._values["eval_condition"] = eval_condition
@builtins.property
def severity(
self,
) -> typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
severity: The alarm level when there is no data to trigger the alarm. Valid values:
2: Report
4: Low
6: Medium
8: High
10: Critical.
'''
result = self._values.get("severity")
assert result is not None, "Required property 'severity' is missing"
return typing.cast(typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def eval_condition(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosAlert.EvalConditionProperty"]]:
'''
:Property: evalCondition:
'''
result = self._values.get("eval_condition")
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosAlert.EvalConditionProperty"]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "SeverityConfigurationsProperty(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-sls.RosAlertProps",
jsii_struct_bases=[],
name_mapping={"detail": "detail", "project": "project"},
)
class RosAlertProps:
def __init__(
self,
*,
detail: typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union[RosAlert.DetailProperty, typing.Dict[builtins.str, typing.Any]]],
project: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
'''Properties for defining a ``ALIYUN::SLS::Alert``.
:param detail:
:param project:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__e604851b523ce98d9c9ba9fcf69e0fe38558dfd63c154b23e62b9e4fd4d6fc93)
check_type(argname="argument detail", value=detail, expected_type=type_hints["detail"])
check_type(argname="argument project", value=project, expected_type=type_hints["project"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"detail": detail,
"project": project,
}
@builtins.property
def detail(
self,
) -> typing.Union[_ros_cdk_core_7adfd82f.IResolvable, RosAlert.DetailProperty]:
'''
:Property: detail:
'''
result = self._values.get("detail")
assert result is not None, "Required property 'detail' is missing"
return typing.cast(typing.Union[_ros_cdk_core_7adfd82f.IResolvable, RosAlert.DetailProperty], result)
@builtins.property
def project(self) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
project: Project name:
1. Only supports lowercase letters, numbers, hyphens (-) and underscores (_).
2. Must start and end with lowercase letters and numbers.
3. The name length is 3-63 characters.
'''
result = self._values.get("project")
assert result is not None, "Required property 'project' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "RosAlertProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class RosApplyConfigToMachineGroup(
_ros_cdk_core_7adfd82f.RosResource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-sls.RosApplyConfigToMachineGroup",
):
'''A ROS template type: ``ALIYUN::SLS::ApplyConfigToMachineGroup``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["RosApplyConfigToMachineGroupProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
'''Create a new ``ALIYUN::SLS::ApplyConfigToMachineGroup``.
:param scope: - scope in which this resource is defined.
:param id: - scoped id of the resource.
:param props: - resource properties.
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__be2133a7cf1f199681a7fe74dd560b109406022dad7bea3042489e0034a35dc8)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@jsii.member(jsii_name="renderProperties")
def _render_properties(
self,
props: typing.Mapping[builtins.str, typing.Any],
) -> typing.Mapping[builtins.str, typing.Any]:
'''
:param props: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__fe251e09b0fc2e85f6e790399a06cf82d60cc1f9a3e09a263a2a11e5110738a4)
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))
@jsii.python.classproperty
@jsii.member(jsii_name="ROS_RESOURCE_TYPE_NAME")
def ROS_RESOURCE_TYPE_NAME(cls) -> builtins.str:
'''The resource type name for this resource class.'''
return typing.cast(builtins.str, jsii.sget(cls, "ROS_RESOURCE_TYPE_NAME"))
@builtins.property
@jsii.member(jsii_name="rosProperties")
def _ros_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "rosProperties"))
@builtins.property
@jsii.member(jsii_name="enableResourcePropertyConstraint")
def enable_resource_property_constraint(self) -> builtins.bool:
'''A factory method that creates a new instance of this class from an object containing the properties of this ROS resource.'''
return typing.cast(builtins.bool, jsii.get(self, "enableResourcePropertyConstraint"))
@enable_resource_property_constraint.setter
def enable_resource_property_constraint(self, value: builtins.bool) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__ad4e141f0c62780e02a6d37240cae998eb287add36782d84871573b0ae969c58)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "enableResourcePropertyConstraint", value)
@builtins.property
@jsii.member(jsii_name="configName")
def config_name(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: configName: Apply config to the config name
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "configName"))
@config_name.setter
def config_name(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__30b716a11fc60ae769f44c954c8efdfae53cf934597adcbcb98a24e8d0602f7b)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "configName", value)
@builtins.property
@jsii.member(jsii_name="groupName")
def group_name(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: groupName: Apply config to the group name
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "groupName"))
@group_name.setter
def group_name(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__d9f8a87a2f0f569408590ffc26efaef5982dce3f5eebb9ab6d6ba0dbd50a5135)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "groupName", value)
@builtins.property
@jsii.member(jsii_name="projectName")
def project_name(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: projectName: Apply config to the project name.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "projectName"))
@project_name.setter
def project_name(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__6c777153b3ae0ff5ffb51374409be2ab6448452d10758f417c5329807b05ee59)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "projectName", value)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-sls.RosApplyConfigToMachineGroupProps",
jsii_struct_bases=[],
name_mapping={
"config_name": "configName",
"group_name": "groupName",
"project_name": "projectName",
},
)
class RosApplyConfigToMachineGroupProps:
def __init__(
self,
*,
config_name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
group_name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
project_name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::SLS::ApplyConfigToMachineGroup``.
:param config_name:
:param group_name:
:param project_name:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__192cc019a9c4b40b582b57524bf78829b5f94fc33f62ab700eb3a8624aae6ef5)
check_type(argname="argument config_name", value=config_name, expected_type=type_hints["config_name"])
check_type(argname="argument group_name", value=group_name, expected_type=type_hints["group_name"])
check_type(argname="argument project_name", value=project_name, expected_type=type_hints["project_name"])
self._values: typing.Dict[builtins.str, typing.Any] = {}
if config_name is not None:
self._values["config_name"] = config_name
if group_name is not None:
self._values["group_name"] = group_name
if project_name is not None:
self._values["project_name"] = project_name
@builtins.property
def config_name(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: configName: Apply config to the config name
'''
result = self._values.get("config_name")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def group_name(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: groupName: Apply config to the group name
'''
result = self._values.get("group_name")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def project_name(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: projectName: Apply config to the project name.
'''
result = self._values.get("project_name")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "RosApplyConfigToMachineGroupProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class RosAudit(
_ros_cdk_core_7adfd82f.RosResource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-sls.RosAudit",
):
'''A ROS template type: ``ALIYUN::SLS::Audit``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["RosAuditProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
'''Create a new ``ALIYUN::SLS::Audit``.
:param scope: - scope in which this resource is defined.
:param id: - scoped id of the resource.
:param props: - resource properties.
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__890a1962056ff122d07ae419445879d7b2f5faea95741af30a499a3ff32f8a4e)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@jsii.member(jsii_name="renderProperties")
def _render_properties(
self,
props: typing.Mapping[builtins.str, typing.Any],
) -> typing.Mapping[builtins.str, typing.Any]:
'''
:param props: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__b7ca55328c22e0103dc0a42399f0d4567e9ac1fcab9df4f14765320fec062de9)
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))
@jsii.python.classproperty
@jsii.member(jsii_name="ROS_RESOURCE_TYPE_NAME")
def ROS_RESOURCE_TYPE_NAME(cls) -> builtins.str:
'''The resource type name for this resource class.'''
return typing.cast(builtins.str, jsii.sget(cls, "ROS_RESOURCE_TYPE_NAME"))
@builtins.property
@jsii.member(jsii_name="attrDisplayName")
def attr_display_name(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: DisplayName: Name of SLS log audit.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrDisplayName"))
@builtins.property
@jsii.member(jsii_name="rosProperties")
def _ros_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "rosProperties"))
@builtins.property
@jsii.member(jsii_name="displayName")
def display_name(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: displayName: Name of SLS log audit.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "displayName"))
@display_name.setter
def display_name(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__bf33293395b9373c6ef70b59b742a68b6ac28cf041f036cc99ae2ed229816e75)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "displayName", value)
@builtins.property
@jsii.member(jsii_name="enableResourcePropertyConstraint")
def enable_resource_property_constraint(self) -> builtins.bool:
return typing.cast(builtins.bool, jsii.get(self, "enableResourcePropertyConstraint"))
@enable_resource_property_constraint.setter
def enable_resource_property_constraint(self, value: builtins.bool) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__faa37e69e70f953f7646bf82e0ce6ca88468f7b105492d9208b709aac0572e0d)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "enableResourcePropertyConstraint", value)
@builtins.property
@jsii.member(jsii_name="variableMap")
def variable_map(
self,
) -> typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosAudit.VariableMapProperty"]:
'''
:Property: variableMap: Log audit detailed configuration.
'''
return typing.cast(typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosAudit.VariableMapProperty"], jsii.get(self, "variableMap"))
@variable_map.setter
def variable_map(
self,
value: typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosAudit.VariableMapProperty"],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__e569cc2500a074f550f2f545e5f8f1d51ac4f94cf82972b5600a446a45a65dcc)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "variableMap", value)
@builtins.property
@jsii.member(jsii_name="multiAccount")
def multi_account(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]]:
'''
:Property: multiAccount: Multi-account configuration, please fill in multiple aliuid.
'''
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]], jsii.get(self, "multiAccount"))
@multi_account.setter
def multi_account(
self,
value: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__3f94fdcbe12723d6ae915c332b0c83101ceb1891bfa990a8d85b7f04d119445d)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "multiAccount", value)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-sls.RosAudit.VariableMapProperty",
jsii_struct_bases=[],
name_mapping={
"actiontrail_enabled": "actiontrailEnabled",
"actiontrail_openapi_collection_policy": "actiontrailOpenapiCollectionPolicy",
"actiontrail_openapi_policy_setting": "actiontrailOpenapiPolicySetting",
"actiontrail_ti_enabled": "actiontrailTiEnabled",
"actiontrail_ttl": "actiontrailTtl",
"apigateway_access_collection_policy": "apigatewayAccessCollectionPolicy",
"apigateway_access_policy_setting": "apigatewayAccessPolicySetting",
"apigateway_enabled": "apigatewayEnabled",
"apigateway_ti_enabled": "apigatewayTiEnabled",
"apigateway_ttl": "apigatewayTtl",
"appconnect_enabled": "appconnectEnabled",
"appconnect_op_collection_policy": "appconnectOpCollectionPolicy",
"appconnect_op_policy_setting": "appconnectOpPolicySetting",
"appconnect_ti_enabled": "appconnectTiEnabled",
"appconnect_ttl": "appconnectTtl",
"bastion_audit_collection_policy": "bastionAuditCollectionPolicy",
"bastion_audit_policy_setting": "bastionAuditPolicySetting",
"bastion_enabled": "bastionEnabled",
"bastion_ti_enabled": "bastionTiEnabled",
"bastion_ttl": "bastionTtl",
"cloudfirewall_access_collection_policy": "cloudfirewallAccessCollectionPolicy",
"cloudfirewall_access_policy_setting": "cloudfirewallAccessPolicySetting",
"cloudfirewall_enabled": "cloudfirewallEnabled",
"cloudfirewall_ti_enabled": "cloudfirewallTiEnabled",
"cloudfirewall_ttl": "cloudfirewallTtl",
"cps_callback_collection_policy": "cpsCallbackCollectionPolicy",
"cps_callback_policy_setting": "cpsCallbackPolicySetting",
"cps_enabled": "cpsEnabled",
"cps_ti_enabled": "cpsTiEnabled",
"cps_ttl": "cpsTtl",
"ddos_coo_access_collection_policy": "ddosCooAccessCollectionPolicy",
"ddos_coo_access_enabled": "ddosCooAccessEnabled",
"ddos_coo_access_policy_setting": "ddosCooAccessPolicySetting",
"ddos_coo_access_ti_enabled": "ddosCooAccessTiEnabled",
"ddos_coo_access_ttl": "ddosCooAccessTtl",
"drds_audit_collection_policy": "drdsAuditCollectionPolicy",
"drds_audit_enabled": "drdsAuditEnabled",
"drds_audit_policy_setting": "drdsAuditPolicySetting",
"drds_audit_ti_enabled": "drdsAuditTiEnabled",
"drds_audit_ttl": "drdsAuditTtl",
"drds_sync_enabled": "drdsSyncEnabled",
"drds_sync_ttl": "drdsSyncTtl",
"k8_s_audit_collection_policy": "k8SAuditCollectionPolicy",
"k8_s_audit_enabled": "k8SAuditEnabled",
"k8_s_audit_policy_setting": "k8SAuditPolicySetting",
"k8_s_audit_ti_enabled": "k8SAuditTiEnabled",
"k8_s_audit_ttl": "k8SAuditTtl",
"k8_s_event_collection_policy": "k8SEventCollectionPolicy",
"k8_s_event_enabled": "k8SEventEnabled",
"k8_s_event_policy_setting": "k8SEventPolicySetting",
"k8_s_event_ti_enabled": "k8SEventTiEnabled",
"k8_s_event_ttl": "k8SEventTtl",
"k8_s_ingress_collection_policy": "k8SIngressCollectionPolicy",
"k8_s_ingress_enabled": "k8SIngressEnabled",
"k8_s_ingress_policy_setting": "k8SIngressPolicySetting",
"k8_s_ingress_ti_enabled": "k8SIngressTiEnabled",
"k8_s_ingress_ttl": "k8SIngressTtl",
"nas_audit_collection_policy": "nasAuditCollectionPolicy",
"nas_audit_policy_setting": "nasAuditPolicySetting",
"nas_enabled": "nasEnabled",
"nas_ti_enabled": "nasTiEnabled",
"nas_ttl": "nasTtl",
"oss_access_collection_policy": "ossAccessCollectionPolicy",
"oss_access_enabled": "ossAccessEnabled",
"oss_access_policy_setting": "ossAccessPolicySetting",
"oss_access_ti_enabled": "ossAccessTiEnabled",
"oss_access_ttl": "ossAccessTtl",
"oss_metering_collection_policy": "ossMeteringCollectionPolicy",
"oss_metering_enabled": "ossMeteringEnabled",
"oss_metering_policy_setting": "ossMeteringPolicySetting",
"oss_metering_ti_enabled": "ossMeteringTiEnabled",
"oss_metering_ttl": "ossMeteringTtl",
"oss_sync_enabled": "ossSyncEnabled",
"oss_sync_ttl": "ossSyncTtl",
"polardb_audit_collection_policy": "polardbAuditCollectionPolicy",
"polardb_audit_policy_setting": "polardbAuditPolicySetting",
"polardb_enabled": "polardbEnabled",
"polardb_perf_collection_policy": "polardbPerfCollectionPolicy",
"polardb_perf_enabled": "polardbPerfEnabled",
"polardb_perf_policy_setting": "polardbPerfPolicySetting",
"polardb_perf_ti_enabled": "polardbPerfTiEnabled",
"polardb_perf_ttl": "polardbPerfTtl",
"polardb_slow_collection_policy": "polardbSlowCollectionPolicy",
"polardb_slow_enabled": "polardbSlowEnabled",
"polardb_slow_policy_setting": "polardbSlowPolicySetting",
"polardb_slow_ti_enabled": "polardbSlowTiEnabled",
"polardb_slow_ttl": "polardbSlowTtl",
"polardb_ti_enabled": "polardbTiEnabled",
"polardb_ttl": "polardbTtl",
"rds_audit_collection_policy": "rdsAuditCollectionPolicy",
"rds_audit_policy_setting": "rdsAuditPolicySetting",
"rds_enabled": "rdsEnabled",
"rds_perf_collection_policy": "rdsPerfCollectionPolicy",
"rds_perf_enabled": "rdsPerfEnabled",
"rds_perf_policy_setting": "rdsPerfPolicySetting",
"rds_perf_ti_enabled": "rdsPerfTiEnabled",
"rds_perf_ttl": "rdsPerfTtl",
"rds_slow_collection_policy": "rdsSlowCollectionPolicy",
"rds_slow_enabled": "rdsSlowEnabled",
"rds_slow_policy_setting": "rdsSlowPolicySetting",
"rds_slow_ti_enabled": "rdsSlowTiEnabled",
"rds_slow_ttl": "rdsSlowTtl",
"rds_ti_enabled": "rdsTiEnabled",
"rds_ttl": "rdsTtl",
"redis_audit_collection_policy": "redisAuditCollectionPolicy",
"redis_audit_enabled": "redisAuditEnabled",
"redis_audit_policy_setting": "redisAuditPolicySetting",
"redis_audit_ti_enabled": "redisAuditTiEnabled",
"redis_audit_ttl": "redisAuditTtl",
"redis_sync_enabled": "redisSyncEnabled",
"redis_sync_ttl": "redisSyncTtl",
"sas_crack_enabled": "sasCrackEnabled",
"sas_dns_enabled": "sasDnsEnabled",
"sas_http_enabled": "sasHttpEnabled",
"sas_local_dns_enabled": "sasLocalDnsEnabled",
"sas_login_enabled": "sasLoginEnabled",
"sas_network_enabled": "sasNetworkEnabled",
"sas_process_enabled": "sasProcessEnabled",
"sas_security_alert_enabled": "sasSecurityAlertEnabled",
"sas_security_hc_enabled": "sasSecurityHcEnabled",
"sas_security_vul_enabled": "sasSecurityVulEnabled",
"sas_session_enabled": "sasSessionEnabled",
"sas_snapshot_account_enabled": "sasSnapshotAccountEnabled",
"sas_snapshot_port_enabled": "sasSnapshotPortEnabled",
"sas_snapshot_process_enabled": "sasSnapshotProcessEnabled",
"sas_ti_enabled": "sasTiEnabled",
"sas_ttl": "sasTtl",
"slb_access_collection_policy": "slbAccessCollectionPolicy",
"slb_access_enabled": "slbAccessEnabled",
"slb_access_policy_setting": "slbAccessPolicySetting",
"slb_access_ti_enabled": "slbAccessTiEnabled",
"slb_access_ttl": "slbAccessTtl",
"slb_sync_enabled": "slbSyncEnabled",
"slb_sync_ttl": "slbSyncTtl",
"waf_access_collection_policy": "wafAccessCollectionPolicy",
"waf_access_policy_setting": "wafAccessPolicySetting",
"waf_enabled": "wafEnabled",
"waf_ti_enabled": "wafTiEnabled",
"waf_ttl": "wafTtl",
},
)
class VariableMapProperty:
def __init__(
self,
*,
actiontrail_enabled: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
actiontrail_openapi_collection_policy: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
actiontrail_openapi_policy_setting: typing.Optional[typing.Union[typing.Sequence[typing.Any], _ros_cdk_core_7adfd82f.IResolvable]] = None,
actiontrail_ti_enabled: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
actiontrail_ttl: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
apigateway_access_collection_policy: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
apigateway_access_policy_setting: typing.Optional[typing.Union[typing.Sequence[typing.Any], _ros_cdk_core_7adfd82f.IResolvable]] = None,
apigateway_enabled: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
apigateway_ti_enabled: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
apigateway_ttl: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
appconnect_enabled: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
appconnect_op_collection_policy: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
appconnect_op_policy_setting: typing.Optional[typing.Union[typing.Sequence[typing.Any], _ros_cdk_core_7adfd82f.IResolvable]] = None,
appconnect_ti_enabled: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
appconnect_ttl: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
bastion_audit_collection_policy: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
bastion_audit_policy_setting: typing.Optional[typing.Union[typing.Sequence[typing.Any], _ros_cdk_core_7adfd82f.IResolvable]] = None,
bastion_enabled: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
bastion_ti_enabled: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
bastion_ttl: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
cloudfirewall_access_collection_policy: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
cloudfirewall_access_policy_setting: typing.Optional[typing.Union[typing.Sequence[typing.Any], _ros_cdk_core_7adfd82f.IResolvable]] = None,
cloudfirewall_enabled: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
cloudfirewall_ti_enabled: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
cloudfirewall_ttl: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
cps_callback_collection_policy: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
cps_callback_policy_setting: typing.Optional[typing.Union[typing.Sequence[typing.Any], _ros_cdk_core_7adfd82f.IResolvable]] = None,
cps_enabled: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
cps_ti_enabled: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
cps_ttl: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
ddos_coo_access_collection_policy: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
ddos_coo_access_enabled: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
ddos_coo_access_policy_setting: typing.Optional[typing.Union[typing.Sequence[typing.Any], _ros_cdk_core_7adfd82f.IResolvable]] = None,
ddos_coo_access_ti_enabled: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
ddos_coo_access_ttl: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
drds_audit_collection_policy: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
drds_audit_enabled: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
drds_audit_policy_setting: typing.Optional[typing.Union[typing.Sequence[typing.Any], _ros_cdk_core_7adfd82f.IResolvable]] = None,
drds_audit_ti_enabled: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
drds_audit_ttl: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
drds_sync_enabled: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
drds_sync_ttl: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
k8_s_audit_collection_policy: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
k8_s_audit_enabled: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
k8_s_audit_policy_setting: typing.Optional[typing.Union[typing.Sequence[typing.Any], _ros_cdk_core_7adfd82f.IResolvable]] = None,
k8_s_audit_ti_enabled: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
k8_s_audit_ttl: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
k8_s_event_collection_policy: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
k8_s_event_enabled: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
k8_s_event_policy_setting: typing.Optional[typing.Union[typing.Sequence[typing.Any], _ros_cdk_core_7adfd82f.IResolvable]] = None,
k8_s_event_ti_enabled: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
k8_s_event_ttl: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
k8_s_ingress_collection_policy: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
k8_s_ingress_enabled: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
k8_s_ingress_policy_setting: typing.Optional[typing.Union[typing.Sequence[typing.Any], _ros_cdk_core_7adfd82f.IResolvable]] = None,
k8_s_ingress_ti_enabled: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
k8_s_ingress_ttl: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
nas_audit_collection_policy: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
nas_audit_policy_setting: typing.Optional[typing.Union[typing.Sequence[typing.Any], _ros_cdk_core_7adfd82f.IResolvable]] = None,
nas_enabled: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
nas_ti_enabled: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
nas_ttl: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
oss_access_collection_policy: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
oss_access_enabled: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
oss_access_policy_setting: typing.Optional[typing.Union[typing.Sequence[typing.Any], _ros_cdk_core_7adfd82f.IResolvable]] = None,
oss_access_ti_enabled: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
oss_access_ttl: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
oss_metering_collection_policy: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
oss_metering_enabled: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
oss_metering_policy_setting: typing.Optional[typing.Union[typing.Sequence[typing.Any], _ros_cdk_core_7adfd82f.IResolvable]] = None,
oss_metering_ti_enabled: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
oss_metering_ttl: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
oss_sync_enabled: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
oss_sync_ttl: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
polardb_audit_collection_policy: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
polardb_audit_policy_setting: typing.Optional[typing.Union[typing.Sequence[typing.Any], _ros_cdk_core_7adfd82f.IResolvable]] = None,
polardb_enabled: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
polardb_perf_collection_policy: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
polardb_perf_enabled: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
polardb_perf_policy_setting: typing.Optional[typing.Union[typing.Sequence[typing.Any], _ros_cdk_core_7adfd82f.IResolvable]] = None,
polardb_perf_ti_enabled: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
polardb_perf_ttl: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
polardb_slow_collection_policy: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
polardb_slow_enabled: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
polardb_slow_policy_setting: typing.Optional[typing.Union[typing.Sequence[typing.Any], _ros_cdk_core_7adfd82f.IResolvable]] = None,
polardb_slow_ti_enabled: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
polardb_slow_ttl: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
polardb_ti_enabled: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
polardb_ttl: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
rds_audit_collection_policy: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
rds_audit_policy_setting: typing.Optional[typing.Union[typing.Sequence[typing.Any], _ros_cdk_core_7adfd82f.IResolvable]] = None,
rds_enabled: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
rds_perf_collection_policy: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
rds_perf_enabled: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
rds_perf_policy_setting: typing.Optional[typing.Union[typing.Sequence[typing.Any], _ros_cdk_core_7adfd82f.IResolvable]] = None,
rds_perf_ti_enabled: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
rds_perf_ttl: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
rds_slow_collection_policy: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
rds_slow_enabled: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
rds_slow_policy_setting: typing.Optional[typing.Union[typing.Sequence[typing.Any], _ros_cdk_core_7adfd82f.IResolvable]] = None,
rds_slow_ti_enabled: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
rds_slow_ttl: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
rds_ti_enabled: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
rds_ttl: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
redis_audit_collection_policy: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
redis_audit_enabled: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
redis_audit_policy_setting: typing.Optional[typing.Union[typing.Sequence[typing.Any], _ros_cdk_core_7adfd82f.IResolvable]] = None,
redis_audit_ti_enabled: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
redis_audit_ttl: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
redis_sync_enabled: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
redis_sync_ttl: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
sas_crack_enabled: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
sas_dns_enabled: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
sas_http_enabled: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
sas_local_dns_enabled: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
sas_login_enabled: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
sas_network_enabled: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
sas_process_enabled: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
sas_security_alert_enabled: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
sas_security_hc_enabled: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
sas_security_vul_enabled: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
sas_session_enabled: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
sas_snapshot_account_enabled: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
sas_snapshot_port_enabled: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
sas_snapshot_process_enabled: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
sas_ti_enabled: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
sas_ttl: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
slb_access_collection_policy: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
slb_access_enabled: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
slb_access_policy_setting: typing.Optional[typing.Union[typing.Sequence[typing.Any], _ros_cdk_core_7adfd82f.IResolvable]] = None,
slb_access_ti_enabled: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
slb_access_ttl: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
slb_sync_enabled: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
slb_sync_ttl: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
waf_access_collection_policy: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
waf_access_policy_setting: typing.Optional[typing.Union[typing.Sequence[typing.Any], _ros_cdk_core_7adfd82f.IResolvable]] = None,
waf_enabled: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
waf_ti_enabled: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
waf_ttl: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''
:param actiontrail_enabled:
:param actiontrail_openapi_collection_policy:
:param actiontrail_openapi_policy_setting:
:param actiontrail_ti_enabled:
:param actiontrail_ttl:
:param apigateway_access_collection_policy:
:param apigateway_access_policy_setting:
:param apigateway_enabled:
:param apigateway_ti_enabled:
:param apigateway_ttl:
:param appconnect_enabled:
:param appconnect_op_collection_policy:
:param appconnect_op_policy_setting:
:param appconnect_ti_enabled:
:param appconnect_ttl:
:param bastion_audit_collection_policy:
:param bastion_audit_policy_setting:
:param bastion_enabled:
:param bastion_ti_enabled:
:param bastion_ttl:
:param cloudfirewall_access_collection_policy:
:param cloudfirewall_access_policy_setting:
:param cloudfirewall_enabled:
:param cloudfirewall_ti_enabled:
:param cloudfirewall_ttl:
:param cps_callback_collection_policy:
:param cps_callback_policy_setting:
:param cps_enabled:
:param cps_ti_enabled:
:param cps_ttl:
:param ddos_coo_access_collection_policy:
:param ddos_coo_access_enabled:
:param ddos_coo_access_policy_setting:
:param ddos_coo_access_ti_enabled:
:param ddos_coo_access_ttl:
:param drds_audit_collection_policy:
:param drds_audit_enabled:
:param drds_audit_policy_setting:
:param drds_audit_ti_enabled:
:param drds_audit_ttl:
:param drds_sync_enabled:
:param drds_sync_ttl:
:param k8_s_audit_collection_policy:
:param k8_s_audit_enabled:
:param k8_s_audit_policy_setting:
:param k8_s_audit_ti_enabled:
:param k8_s_audit_ttl:
:param k8_s_event_collection_policy:
:param k8_s_event_enabled:
:param k8_s_event_policy_setting:
:param k8_s_event_ti_enabled:
:param k8_s_event_ttl:
:param k8_s_ingress_collection_policy:
:param k8_s_ingress_enabled:
:param k8_s_ingress_policy_setting:
:param k8_s_ingress_ti_enabled:
:param k8_s_ingress_ttl:
:param nas_audit_collection_policy:
:param nas_audit_policy_setting:
:param nas_enabled:
:param nas_ti_enabled:
:param nas_ttl:
:param oss_access_collection_policy:
:param oss_access_enabled:
:param oss_access_policy_setting:
:param oss_access_ti_enabled:
:param oss_access_ttl:
:param oss_metering_collection_policy:
:param oss_metering_enabled:
:param oss_metering_policy_setting:
:param oss_metering_ti_enabled:
:param oss_metering_ttl:
:param oss_sync_enabled:
:param oss_sync_ttl:
:param polardb_audit_collection_policy:
:param polardb_audit_policy_setting:
:param polardb_enabled:
:param polardb_perf_collection_policy:
:param polardb_perf_enabled:
:param polardb_perf_policy_setting:
:param polardb_perf_ti_enabled:
:param polardb_perf_ttl:
:param polardb_slow_collection_policy:
:param polardb_slow_enabled:
:param polardb_slow_policy_setting:
:param polardb_slow_ti_enabled:
:param polardb_slow_ttl:
:param polardb_ti_enabled:
:param polardb_ttl:
:param rds_audit_collection_policy:
:param rds_audit_policy_setting:
:param rds_enabled:
:param rds_perf_collection_policy:
:param rds_perf_enabled:
:param rds_perf_policy_setting:
:param rds_perf_ti_enabled:
:param rds_perf_ttl:
:param rds_slow_collection_policy:
:param rds_slow_enabled:
:param rds_slow_policy_setting:
:param rds_slow_ti_enabled:
:param rds_slow_ttl:
:param rds_ti_enabled:
:param rds_ttl:
:param redis_audit_collection_policy:
:param redis_audit_enabled:
:param redis_audit_policy_setting:
:param redis_audit_ti_enabled:
:param redis_audit_ttl:
:param redis_sync_enabled:
:param redis_sync_ttl:
:param sas_crack_enabled:
:param sas_dns_enabled:
:param sas_http_enabled:
:param sas_local_dns_enabled:
:param sas_login_enabled:
:param sas_network_enabled:
:param sas_process_enabled:
:param sas_security_alert_enabled:
:param sas_security_hc_enabled:
:param sas_security_vul_enabled:
:param sas_session_enabled:
:param sas_snapshot_account_enabled:
:param sas_snapshot_port_enabled:
:param sas_snapshot_process_enabled:
:param sas_ti_enabled:
:param sas_ttl:
:param slb_access_collection_policy:
:param slb_access_enabled:
:param slb_access_policy_setting:
:param slb_access_ti_enabled:
:param slb_access_ttl:
:param slb_sync_enabled:
:param slb_sync_ttl:
:param waf_access_collection_policy:
:param waf_access_policy_setting:
:param waf_enabled:
:param waf_ti_enabled:
:param waf_ttl:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__4e86dadc77abd9f0591b0907ef25e31e7aad62ae1ae0ba4279815f3fb59a7e2d)
check_type(argname="argument actiontrail_enabled", value=actiontrail_enabled, expected_type=type_hints["actiontrail_enabled"])
check_type(argname="argument actiontrail_openapi_collection_policy", value=actiontrail_openapi_collection_policy, expected_type=type_hints["actiontrail_openapi_collection_policy"])
check_type(argname="argument actiontrail_openapi_policy_setting", value=actiontrail_openapi_policy_setting, expected_type=type_hints["actiontrail_openapi_policy_setting"])
check_type(argname="argument actiontrail_ti_enabled", value=actiontrail_ti_enabled, expected_type=type_hints["actiontrail_ti_enabled"])
check_type(argname="argument actiontrail_ttl", value=actiontrail_ttl, expected_type=type_hints["actiontrail_ttl"])
check_type(argname="argument apigateway_access_collection_policy", value=apigateway_access_collection_policy, expected_type=type_hints["apigateway_access_collection_policy"])
check_type(argname="argument apigateway_access_policy_setting", value=apigateway_access_policy_setting, expected_type=type_hints["apigateway_access_policy_setting"])
check_type(argname="argument apigateway_enabled", value=apigateway_enabled, expected_type=type_hints["apigateway_enabled"])
check_type(argname="argument apigateway_ti_enabled", value=apigateway_ti_enabled, expected_type=type_hints["apigateway_ti_enabled"])
check_type(argname="argument apigateway_ttl", value=apigateway_ttl, expected_type=type_hints["apigateway_ttl"])
check_type(argname="argument appconnect_enabled", value=appconnect_enabled, expected_type=type_hints["appconnect_enabled"])
check_type(argname="argument appconnect_op_collection_policy", value=appconnect_op_collection_policy, expected_type=type_hints["appconnect_op_collection_policy"])
check_type(argname="argument appconnect_op_policy_setting", value=appconnect_op_policy_setting, expected_type=type_hints["appconnect_op_policy_setting"])
check_type(argname="argument appconnect_ti_enabled", value=appconnect_ti_enabled, expected_type=type_hints["appconnect_ti_enabled"])
check_type(argname="argument appconnect_ttl", value=appconnect_ttl, expected_type=type_hints["appconnect_ttl"])
check_type(argname="argument bastion_audit_collection_policy", value=bastion_audit_collection_policy, expected_type=type_hints["bastion_audit_collection_policy"])
check_type(argname="argument bastion_audit_policy_setting", value=bastion_audit_policy_setting, expected_type=type_hints["bastion_audit_policy_setting"])
check_type(argname="argument bastion_enabled", value=bastion_enabled, expected_type=type_hints["bastion_enabled"])
check_type(argname="argument bastion_ti_enabled", value=bastion_ti_enabled, expected_type=type_hints["bastion_ti_enabled"])
check_type(argname="argument bastion_ttl", value=bastion_ttl, expected_type=type_hints["bastion_ttl"])
check_type(argname="argument cloudfirewall_access_collection_policy", value=cloudfirewall_access_collection_policy, expected_type=type_hints["cloudfirewall_access_collection_policy"])
check_type(argname="argument cloudfirewall_access_policy_setting", value=cloudfirewall_access_policy_setting, expected_type=type_hints["cloudfirewall_access_policy_setting"])
check_type(argname="argument cloudfirewall_enabled", value=cloudfirewall_enabled, expected_type=type_hints["cloudfirewall_enabled"])
check_type(argname="argument cloudfirewall_ti_enabled", value=cloudfirewall_ti_enabled, expected_type=type_hints["cloudfirewall_ti_enabled"])
check_type(argname="argument cloudfirewall_ttl", value=cloudfirewall_ttl, expected_type=type_hints["cloudfirewall_ttl"])
check_type(argname="argument cps_callback_collection_policy", value=cps_callback_collection_policy, expected_type=type_hints["cps_callback_collection_policy"])
check_type(argname="argument cps_callback_policy_setting", value=cps_callback_policy_setting, expected_type=type_hints["cps_callback_policy_setting"])
check_type(argname="argument cps_enabled", value=cps_enabled, expected_type=type_hints["cps_enabled"])
check_type(argname="argument cps_ti_enabled", value=cps_ti_enabled, expected_type=type_hints["cps_ti_enabled"])
check_type(argname="argument cps_ttl", value=cps_ttl, expected_type=type_hints["cps_ttl"])
check_type(argname="argument ddos_coo_access_collection_policy", value=ddos_coo_access_collection_policy, expected_type=type_hints["ddos_coo_access_collection_policy"])
check_type(argname="argument ddos_coo_access_enabled", value=ddos_coo_access_enabled, expected_type=type_hints["ddos_coo_access_enabled"])
check_type(argname="argument ddos_coo_access_policy_setting", value=ddos_coo_access_policy_setting, expected_type=type_hints["ddos_coo_access_policy_setting"])
check_type(argname="argument ddos_coo_access_ti_enabled", value=ddos_coo_access_ti_enabled, expected_type=type_hints["ddos_coo_access_ti_enabled"])
check_type(argname="argument ddos_coo_access_ttl", value=ddos_coo_access_ttl, expected_type=type_hints["ddos_coo_access_ttl"])
check_type(argname="argument drds_audit_collection_policy", value=drds_audit_collection_policy, expected_type=type_hints["drds_audit_collection_policy"])
check_type(argname="argument drds_audit_enabled", value=drds_audit_enabled, expected_type=type_hints["drds_audit_enabled"])
check_type(argname="argument drds_audit_policy_setting", value=drds_audit_policy_setting, expected_type=type_hints["drds_audit_policy_setting"])
check_type(argname="argument drds_audit_ti_enabled", value=drds_audit_ti_enabled, expected_type=type_hints["drds_audit_ti_enabled"])
check_type(argname="argument drds_audit_ttl", value=drds_audit_ttl, expected_type=type_hints["drds_audit_ttl"])
check_type(argname="argument drds_sync_enabled", value=drds_sync_enabled, expected_type=type_hints["drds_sync_enabled"])
check_type(argname="argument drds_sync_ttl", value=drds_sync_ttl, expected_type=type_hints["drds_sync_ttl"])
check_type(argname="argument k8_s_audit_collection_policy", value=k8_s_audit_collection_policy, expected_type=type_hints["k8_s_audit_collection_policy"])
check_type(argname="argument k8_s_audit_enabled", value=k8_s_audit_enabled, expected_type=type_hints["k8_s_audit_enabled"])
check_type(argname="argument k8_s_audit_policy_setting", value=k8_s_audit_policy_setting, expected_type=type_hints["k8_s_audit_policy_setting"])
check_type(argname="argument k8_s_audit_ti_enabled", value=k8_s_audit_ti_enabled, expected_type=type_hints["k8_s_audit_ti_enabled"])
check_type(argname="argument k8_s_audit_ttl", value=k8_s_audit_ttl, expected_type=type_hints["k8_s_audit_ttl"])
check_type(argname="argument k8_s_event_collection_policy", value=k8_s_event_collection_policy, expected_type=type_hints["k8_s_event_collection_policy"])
check_type(argname="argument k8_s_event_enabled", value=k8_s_event_enabled, expected_type=type_hints["k8_s_event_enabled"])
check_type(argname="argument k8_s_event_policy_setting", value=k8_s_event_policy_setting, expected_type=type_hints["k8_s_event_policy_setting"])
check_type(argname="argument k8_s_event_ti_enabled", value=k8_s_event_ti_enabled, expected_type=type_hints["k8_s_event_ti_enabled"])
check_type(argname="argument k8_s_event_ttl", value=k8_s_event_ttl, expected_type=type_hints["k8_s_event_ttl"])
check_type(argname="argument k8_s_ingress_collection_policy", value=k8_s_ingress_collection_policy, expected_type=type_hints["k8_s_ingress_collection_policy"])
check_type(argname="argument k8_s_ingress_enabled", value=k8_s_ingress_enabled, expected_type=type_hints["k8_s_ingress_enabled"])
check_type(argname="argument k8_s_ingress_policy_setting", value=k8_s_ingress_policy_setting, expected_type=type_hints["k8_s_ingress_policy_setting"])
check_type(argname="argument k8_s_ingress_ti_enabled", value=k8_s_ingress_ti_enabled, expected_type=type_hints["k8_s_ingress_ti_enabled"])
check_type(argname="argument k8_s_ingress_ttl", value=k8_s_ingress_ttl, expected_type=type_hints["k8_s_ingress_ttl"])
check_type(argname="argument nas_audit_collection_policy", value=nas_audit_collection_policy, expected_type=type_hints["nas_audit_collection_policy"])
check_type(argname="argument nas_audit_policy_setting", value=nas_audit_policy_setting, expected_type=type_hints["nas_audit_policy_setting"])
check_type(argname="argument nas_enabled", value=nas_enabled, expected_type=type_hints["nas_enabled"])
check_type(argname="argument nas_ti_enabled", value=nas_ti_enabled, expected_type=type_hints["nas_ti_enabled"])
check_type(argname="argument nas_ttl", value=nas_ttl, expected_type=type_hints["nas_ttl"])
check_type(argname="argument oss_access_collection_policy", value=oss_access_collection_policy, expected_type=type_hints["oss_access_collection_policy"])
check_type(argname="argument oss_access_enabled", value=oss_access_enabled, expected_type=type_hints["oss_access_enabled"])
check_type(argname="argument oss_access_policy_setting", value=oss_access_policy_setting, expected_type=type_hints["oss_access_policy_setting"])
check_type(argname="argument oss_access_ti_enabled", value=oss_access_ti_enabled, expected_type=type_hints["oss_access_ti_enabled"])
check_type(argname="argument oss_access_ttl", value=oss_access_ttl, expected_type=type_hints["oss_access_ttl"])
check_type(argname="argument oss_metering_collection_policy", value=oss_metering_collection_policy, expected_type=type_hints["oss_metering_collection_policy"])
check_type(argname="argument oss_metering_enabled", value=oss_metering_enabled, expected_type=type_hints["oss_metering_enabled"])
check_type(argname="argument oss_metering_policy_setting", value=oss_metering_policy_setting, expected_type=type_hints["oss_metering_policy_setting"])
check_type(argname="argument oss_metering_ti_enabled", value=oss_metering_ti_enabled, expected_type=type_hints["oss_metering_ti_enabled"])
check_type(argname="argument oss_metering_ttl", value=oss_metering_ttl, expected_type=type_hints["oss_metering_ttl"])
check_type(argname="argument oss_sync_enabled", value=oss_sync_enabled, expected_type=type_hints["oss_sync_enabled"])
check_type(argname="argument oss_sync_ttl", value=oss_sync_ttl, expected_type=type_hints["oss_sync_ttl"])
check_type(argname="argument polardb_audit_collection_policy", value=polardb_audit_collection_policy, expected_type=type_hints["polardb_audit_collection_policy"])
check_type(argname="argument polardb_audit_policy_setting", value=polardb_audit_policy_setting, expected_type=type_hints["polardb_audit_policy_setting"])
check_type(argname="argument polardb_enabled", value=polardb_enabled, expected_type=type_hints["polardb_enabled"])
check_type(argname="argument polardb_perf_collection_policy", value=polardb_perf_collection_policy, expected_type=type_hints["polardb_perf_collection_policy"])
check_type(argname="argument polardb_perf_enabled", value=polardb_perf_enabled, expected_type=type_hints["polardb_perf_enabled"])
check_type(argname="argument polardb_perf_policy_setting", value=polardb_perf_policy_setting, expected_type=type_hints["polardb_perf_policy_setting"])
check_type(argname="argument polardb_perf_ti_enabled", value=polardb_perf_ti_enabled, expected_type=type_hints["polardb_perf_ti_enabled"])
check_type(argname="argument polardb_perf_ttl", value=polardb_perf_ttl, expected_type=type_hints["polardb_perf_ttl"])
check_type(argname="argument polardb_slow_collection_policy", value=polardb_slow_collection_policy, expected_type=type_hints["polardb_slow_collection_policy"])
check_type(argname="argument polardb_slow_enabled", value=polardb_slow_enabled, expected_type=type_hints["polardb_slow_enabled"])
check_type(argname="argument polardb_slow_policy_setting", value=polardb_slow_policy_setting, expected_type=type_hints["polardb_slow_policy_setting"])
check_type(argname="argument polardb_slow_ti_enabled", value=polardb_slow_ti_enabled, expected_type=type_hints["polardb_slow_ti_enabled"])
check_type(argname="argument polardb_slow_ttl", value=polardb_slow_ttl, expected_type=type_hints["polardb_slow_ttl"])
check_type(argname="argument polardb_ti_enabled", value=polardb_ti_enabled, expected_type=type_hints["polardb_ti_enabled"])
check_type(argname="argument polardb_ttl", value=polardb_ttl, expected_type=type_hints["polardb_ttl"])
check_type(argname="argument rds_audit_collection_policy", value=rds_audit_collection_policy, expected_type=type_hints["rds_audit_collection_policy"])
check_type(argname="argument rds_audit_policy_setting", value=rds_audit_policy_setting, expected_type=type_hints["rds_audit_policy_setting"])
check_type(argname="argument rds_enabled", value=rds_enabled, expected_type=type_hints["rds_enabled"])
check_type(argname="argument rds_perf_collection_policy", value=rds_perf_collection_policy, expected_type=type_hints["rds_perf_collection_policy"])
check_type(argname="argument rds_perf_enabled", value=rds_perf_enabled, expected_type=type_hints["rds_perf_enabled"])
check_type(argname="argument rds_perf_policy_setting", value=rds_perf_policy_setting, expected_type=type_hints["rds_perf_policy_setting"])
check_type(argname="argument rds_perf_ti_enabled", value=rds_perf_ti_enabled, expected_type=type_hints["rds_perf_ti_enabled"])
check_type(argname="argument rds_perf_ttl", value=rds_perf_ttl, expected_type=type_hints["rds_perf_ttl"])
check_type(argname="argument rds_slow_collection_policy", value=rds_slow_collection_policy, expected_type=type_hints["rds_slow_collection_policy"])
check_type(argname="argument rds_slow_enabled", value=rds_slow_enabled, expected_type=type_hints["rds_slow_enabled"])
check_type(argname="argument rds_slow_policy_setting", value=rds_slow_policy_setting, expected_type=type_hints["rds_slow_policy_setting"])
check_type(argname="argument rds_slow_ti_enabled", value=rds_slow_ti_enabled, expected_type=type_hints["rds_slow_ti_enabled"])
check_type(argname="argument rds_slow_ttl", value=rds_slow_ttl, expected_type=type_hints["rds_slow_ttl"])
check_type(argname="argument rds_ti_enabled", value=rds_ti_enabled, expected_type=type_hints["rds_ti_enabled"])
check_type(argname="argument rds_ttl", value=rds_ttl, expected_type=type_hints["rds_ttl"])
check_type(argname="argument redis_audit_collection_policy", value=redis_audit_collection_policy, expected_type=type_hints["redis_audit_collection_policy"])
check_type(argname="argument redis_audit_enabled", value=redis_audit_enabled, expected_type=type_hints["redis_audit_enabled"])
check_type(argname="argument redis_audit_policy_setting", value=redis_audit_policy_setting, expected_type=type_hints["redis_audit_policy_setting"])
check_type(argname="argument redis_audit_ti_enabled", value=redis_audit_ti_enabled, expected_type=type_hints["redis_audit_ti_enabled"])
check_type(argname="argument redis_audit_ttl", value=redis_audit_ttl, expected_type=type_hints["redis_audit_ttl"])
check_type(argname="argument redis_sync_enabled", value=redis_sync_enabled, expected_type=type_hints["redis_sync_enabled"])
check_type(argname="argument redis_sync_ttl", value=redis_sync_ttl, expected_type=type_hints["redis_sync_ttl"])
check_type(argname="argument sas_crack_enabled", value=sas_crack_enabled, expected_type=type_hints["sas_crack_enabled"])
check_type(argname="argument sas_dns_enabled", value=sas_dns_enabled, expected_type=type_hints["sas_dns_enabled"])
check_type(argname="argument sas_http_enabled", value=sas_http_enabled, expected_type=type_hints["sas_http_enabled"])
check_type(argname="argument sas_local_dns_enabled", value=sas_local_dns_enabled, expected_type=type_hints["sas_local_dns_enabled"])
check_type(argname="argument sas_login_enabled", value=sas_login_enabled, expected_type=type_hints["sas_login_enabled"])
check_type(argname="argument sas_network_enabled", value=sas_network_enabled, expected_type=type_hints["sas_network_enabled"])
check_type(argname="argument sas_process_enabled", value=sas_process_enabled, expected_type=type_hints["sas_process_enabled"])
check_type(argname="argument sas_security_alert_enabled", value=sas_security_alert_enabled, expected_type=type_hints["sas_security_alert_enabled"])
check_type(argname="argument sas_security_hc_enabled", value=sas_security_hc_enabled, expected_type=type_hints["sas_security_hc_enabled"])
check_type(argname="argument sas_security_vul_enabled", value=sas_security_vul_enabled, expected_type=type_hints["sas_security_vul_enabled"])
check_type(argname="argument sas_session_enabled", value=sas_session_enabled, expected_type=type_hints["sas_session_enabled"])
check_type(argname="argument sas_snapshot_account_enabled", value=sas_snapshot_account_enabled, expected_type=type_hints["sas_snapshot_account_enabled"])
check_type(argname="argument sas_snapshot_port_enabled", value=sas_snapshot_port_enabled, expected_type=type_hints["sas_snapshot_port_enabled"])
check_type(argname="argument sas_snapshot_process_enabled", value=sas_snapshot_process_enabled, expected_type=type_hints["sas_snapshot_process_enabled"])
check_type(argname="argument sas_ti_enabled", value=sas_ti_enabled, expected_type=type_hints["sas_ti_enabled"])
check_type(argname="argument sas_ttl", value=sas_ttl, expected_type=type_hints["sas_ttl"])
check_type(argname="argument slb_access_collection_policy", value=slb_access_collection_policy, expected_type=type_hints["slb_access_collection_policy"])
check_type(argname="argument slb_access_enabled", value=slb_access_enabled, expected_type=type_hints["slb_access_enabled"])
check_type(argname="argument slb_access_policy_setting", value=slb_access_policy_setting, expected_type=type_hints["slb_access_policy_setting"])
check_type(argname="argument slb_access_ti_enabled", value=slb_access_ti_enabled, expected_type=type_hints["slb_access_ti_enabled"])
check_type(argname="argument slb_access_ttl", value=slb_access_ttl, expected_type=type_hints["slb_access_ttl"])
check_type(argname="argument slb_sync_enabled", value=slb_sync_enabled, expected_type=type_hints["slb_sync_enabled"])
check_type(argname="argument slb_sync_ttl", value=slb_sync_ttl, expected_type=type_hints["slb_sync_ttl"])
check_type(argname="argument waf_access_collection_policy", value=waf_access_collection_policy, expected_type=type_hints["waf_access_collection_policy"])
check_type(argname="argument waf_access_policy_setting", value=waf_access_policy_setting, expected_type=type_hints["waf_access_policy_setting"])
check_type(argname="argument waf_enabled", value=waf_enabled, expected_type=type_hints["waf_enabled"])
check_type(argname="argument waf_ti_enabled", value=waf_ti_enabled, expected_type=type_hints["waf_ti_enabled"])
check_type(argname="argument waf_ttl", value=waf_ttl, expected_type=type_hints["waf_ttl"])
self._values: typing.Dict[builtins.str, typing.Any] = {}
if actiontrail_enabled is not None:
self._values["actiontrail_enabled"] = actiontrail_enabled
if actiontrail_openapi_collection_policy is not None:
self._values["actiontrail_openapi_collection_policy"] = actiontrail_openapi_collection_policy
if actiontrail_openapi_policy_setting is not None:
self._values["actiontrail_openapi_policy_setting"] = actiontrail_openapi_policy_setting
if actiontrail_ti_enabled is not None:
self._values["actiontrail_ti_enabled"] = actiontrail_ti_enabled
if actiontrail_ttl is not None:
self._values["actiontrail_ttl"] = actiontrail_ttl
if apigateway_access_collection_policy is not None:
self._values["apigateway_access_collection_policy"] = apigateway_access_collection_policy
if apigateway_access_policy_setting is not None:
self._values["apigateway_access_policy_setting"] = apigateway_access_policy_setting
if apigateway_enabled is not None:
self._values["apigateway_enabled"] = apigateway_enabled
if apigateway_ti_enabled is not None:
self._values["apigateway_ti_enabled"] = apigateway_ti_enabled
if apigateway_ttl is not None:
self._values["apigateway_ttl"] = apigateway_ttl
if appconnect_enabled is not None:
self._values["appconnect_enabled"] = appconnect_enabled
if appconnect_op_collection_policy is not None:
self._values["appconnect_op_collection_policy"] = appconnect_op_collection_policy
if appconnect_op_policy_setting is not None:
self._values["appconnect_op_policy_setting"] = appconnect_op_policy_setting
if appconnect_ti_enabled is not None:
self._values["appconnect_ti_enabled"] = appconnect_ti_enabled
if appconnect_ttl is not None:
self._values["appconnect_ttl"] = appconnect_ttl
if bastion_audit_collection_policy is not None:
self._values["bastion_audit_collection_policy"] = bastion_audit_collection_policy
if bastion_audit_policy_setting is not None:
self._values["bastion_audit_policy_setting"] = bastion_audit_policy_setting
if bastion_enabled is not None:
self._values["bastion_enabled"] = bastion_enabled
if bastion_ti_enabled is not None:
self._values["bastion_ti_enabled"] = bastion_ti_enabled
if bastion_ttl is not None:
self._values["bastion_ttl"] = bastion_ttl
if cloudfirewall_access_collection_policy is not None:
self._values["cloudfirewall_access_collection_policy"] = cloudfirewall_access_collection_policy
if cloudfirewall_access_policy_setting is not None:
self._values["cloudfirewall_access_policy_setting"] = cloudfirewall_access_policy_setting
if cloudfirewall_enabled is not None:
self._values["cloudfirewall_enabled"] = cloudfirewall_enabled
if cloudfirewall_ti_enabled is not None:
self._values["cloudfirewall_ti_enabled"] = cloudfirewall_ti_enabled
if cloudfirewall_ttl is not None:
self._values["cloudfirewall_ttl"] = cloudfirewall_ttl
if cps_callback_collection_policy is not None:
self._values["cps_callback_collection_policy"] = cps_callback_collection_policy
if cps_callback_policy_setting is not None:
self._values["cps_callback_policy_setting"] = cps_callback_policy_setting
if cps_enabled is not None:
self._values["cps_enabled"] = cps_enabled
if cps_ti_enabled is not None:
self._values["cps_ti_enabled"] = cps_ti_enabled
if cps_ttl is not None:
self._values["cps_ttl"] = cps_ttl
if ddos_coo_access_collection_policy is not None:
self._values["ddos_coo_access_collection_policy"] = ddos_coo_access_collection_policy
if ddos_coo_access_enabled is not None:
self._values["ddos_coo_access_enabled"] = ddos_coo_access_enabled
if ddos_coo_access_policy_setting is not None:
self._values["ddos_coo_access_policy_setting"] = ddos_coo_access_policy_setting
if ddos_coo_access_ti_enabled is not None:
self._values["ddos_coo_access_ti_enabled"] = ddos_coo_access_ti_enabled
if ddos_coo_access_ttl is not None:
self._values["ddos_coo_access_ttl"] = ddos_coo_access_ttl
if drds_audit_collection_policy is not None:
self._values["drds_audit_collection_policy"] = drds_audit_collection_policy
if drds_audit_enabled is not None:
self._values["drds_audit_enabled"] = drds_audit_enabled
if drds_audit_policy_setting is not None:
self._values["drds_audit_policy_setting"] = drds_audit_policy_setting
if drds_audit_ti_enabled is not None:
self._values["drds_audit_ti_enabled"] = drds_audit_ti_enabled
if drds_audit_ttl is not None:
self._values["drds_audit_ttl"] = drds_audit_ttl
if drds_sync_enabled is not None:
self._values["drds_sync_enabled"] = drds_sync_enabled
if drds_sync_ttl is not None:
self._values["drds_sync_ttl"] = drds_sync_ttl
if k8_s_audit_collection_policy is not None:
self._values["k8_s_audit_collection_policy"] = k8_s_audit_collection_policy
if k8_s_audit_enabled is not None:
self._values["k8_s_audit_enabled"] = k8_s_audit_enabled
if k8_s_audit_policy_setting is not None:
self._values["k8_s_audit_policy_setting"] = k8_s_audit_policy_setting
if k8_s_audit_ti_enabled is not None:
self._values["k8_s_audit_ti_enabled"] = k8_s_audit_ti_enabled
if k8_s_audit_ttl is not None:
self._values["k8_s_audit_ttl"] = k8_s_audit_ttl
if k8_s_event_collection_policy is not None:
self._values["k8_s_event_collection_policy"] = k8_s_event_collection_policy
if k8_s_event_enabled is not None:
self._values["k8_s_event_enabled"] = k8_s_event_enabled
if k8_s_event_policy_setting is not None:
self._values["k8_s_event_policy_setting"] = k8_s_event_policy_setting
if k8_s_event_ti_enabled is not None:
self._values["k8_s_event_ti_enabled"] = k8_s_event_ti_enabled
if k8_s_event_ttl is not None:
self._values["k8_s_event_ttl"] = k8_s_event_ttl
if k8_s_ingress_collection_policy is not None:
self._values["k8_s_ingress_collection_policy"] = k8_s_ingress_collection_policy
if k8_s_ingress_enabled is not None:
self._values["k8_s_ingress_enabled"] = k8_s_ingress_enabled
if k8_s_ingress_policy_setting is not None:
self._values["k8_s_ingress_policy_setting"] = k8_s_ingress_policy_setting
if k8_s_ingress_ti_enabled is not None:
self._values["k8_s_ingress_ti_enabled"] = k8_s_ingress_ti_enabled
if k8_s_ingress_ttl is not None:
self._values["k8_s_ingress_ttl"] = k8_s_ingress_ttl
if nas_audit_collection_policy is not None:
self._values["nas_audit_collection_policy"] = nas_audit_collection_policy
if nas_audit_policy_setting is not None:
self._values["nas_audit_policy_setting"] = nas_audit_policy_setting
if nas_enabled is not None:
self._values["nas_enabled"] = nas_enabled
if nas_ti_enabled is not None:
self._values["nas_ti_enabled"] = nas_ti_enabled
if nas_ttl is not None:
self._values["nas_ttl"] = nas_ttl
if oss_access_collection_policy is not None:
self._values["oss_access_collection_policy"] = oss_access_collection_policy
if oss_access_enabled is not None:
self._values["oss_access_enabled"] = oss_access_enabled
if oss_access_policy_setting is not None:
self._values["oss_access_policy_setting"] = oss_access_policy_setting
if oss_access_ti_enabled is not None:
self._values["oss_access_ti_enabled"] = oss_access_ti_enabled
if oss_access_ttl is not None:
self._values["oss_access_ttl"] = oss_access_ttl
if oss_metering_collection_policy is not None:
self._values["oss_metering_collection_policy"] = oss_metering_collection_policy
if oss_metering_enabled is not None:
self._values["oss_metering_enabled"] = oss_metering_enabled
if oss_metering_policy_setting is not None:
self._values["oss_metering_policy_setting"] = oss_metering_policy_setting
if oss_metering_ti_enabled is not None:
self._values["oss_metering_ti_enabled"] = oss_metering_ti_enabled
if oss_metering_ttl is not None:
self._values["oss_metering_ttl"] = oss_metering_ttl
if oss_sync_enabled is not None:
self._values["oss_sync_enabled"] = oss_sync_enabled
if oss_sync_ttl is not None:
self._values["oss_sync_ttl"] = oss_sync_ttl
if polardb_audit_collection_policy is not None:
self._values["polardb_audit_collection_policy"] = polardb_audit_collection_policy
if polardb_audit_policy_setting is not None:
self._values["polardb_audit_policy_setting"] = polardb_audit_policy_setting
if polardb_enabled is not None:
self._values["polardb_enabled"] = polardb_enabled
if polardb_perf_collection_policy is not None:
self._values["polardb_perf_collection_policy"] = polardb_perf_collection_policy
if polardb_perf_enabled is not None:
self._values["polardb_perf_enabled"] = polardb_perf_enabled
if polardb_perf_policy_setting is not None:
self._values["polardb_perf_policy_setting"] = polardb_perf_policy_setting
if polardb_perf_ti_enabled is not None:
self._values["polardb_perf_ti_enabled"] = polardb_perf_ti_enabled
if polardb_perf_ttl is not None:
self._values["polardb_perf_ttl"] = polardb_perf_ttl
if polardb_slow_collection_policy is not None:
self._values["polardb_slow_collection_policy"] = polardb_slow_collection_policy
if polardb_slow_enabled is not None:
self._values["polardb_slow_enabled"] = polardb_slow_enabled
if polardb_slow_policy_setting is not None:
self._values["polardb_slow_policy_setting"] = polardb_slow_policy_setting
if polardb_slow_ti_enabled is not None:
self._values["polardb_slow_ti_enabled"] = polardb_slow_ti_enabled
if polardb_slow_ttl is not None:
self._values["polardb_slow_ttl"] = polardb_slow_ttl
if polardb_ti_enabled is not None:
self._values["polardb_ti_enabled"] = polardb_ti_enabled
if polardb_ttl is not None:
self._values["polardb_ttl"] = polardb_ttl
if rds_audit_collection_policy is not None:
self._values["rds_audit_collection_policy"] = rds_audit_collection_policy
if rds_audit_policy_setting is not None:
self._values["rds_audit_policy_setting"] = rds_audit_policy_setting
if rds_enabled is not None:
self._values["rds_enabled"] = rds_enabled
if rds_perf_collection_policy is not None:
self._values["rds_perf_collection_policy"] = rds_perf_collection_policy
if rds_perf_enabled is not None:
self._values["rds_perf_enabled"] = rds_perf_enabled
if rds_perf_policy_setting is not None:
self._values["rds_perf_policy_setting"] = rds_perf_policy_setting
if rds_perf_ti_enabled is not None:
self._values["rds_perf_ti_enabled"] = rds_perf_ti_enabled
if rds_perf_ttl is not None:
self._values["rds_perf_ttl"] = rds_perf_ttl
if rds_slow_collection_policy is not None:
self._values["rds_slow_collection_policy"] = rds_slow_collection_policy
if rds_slow_enabled is not None:
self._values["rds_slow_enabled"] = rds_slow_enabled
if rds_slow_policy_setting is not None:
self._values["rds_slow_policy_setting"] = rds_slow_policy_setting
if rds_slow_ti_enabled is not None:
self._values["rds_slow_ti_enabled"] = rds_slow_ti_enabled
if rds_slow_ttl is not None:
self._values["rds_slow_ttl"] = rds_slow_ttl
if rds_ti_enabled is not None:
self._values["rds_ti_enabled"] = rds_ti_enabled
if rds_ttl is not None:
self._values["rds_ttl"] = rds_ttl
if redis_audit_collection_policy is not None:
self._values["redis_audit_collection_policy"] = redis_audit_collection_policy
if redis_audit_enabled is not None:
self._values["redis_audit_enabled"] = redis_audit_enabled
if redis_audit_policy_setting is not None:
self._values["redis_audit_policy_setting"] = redis_audit_policy_setting
if redis_audit_ti_enabled is not None:
self._values["redis_audit_ti_enabled"] = redis_audit_ti_enabled
if redis_audit_ttl is not None:
self._values["redis_audit_ttl"] = redis_audit_ttl
if redis_sync_enabled is not None:
self._values["redis_sync_enabled"] = redis_sync_enabled
if redis_sync_ttl is not None:
self._values["redis_sync_ttl"] = redis_sync_ttl
if sas_crack_enabled is not None:
self._values["sas_crack_enabled"] = sas_crack_enabled
if sas_dns_enabled is not None:
self._values["sas_dns_enabled"] = sas_dns_enabled
if sas_http_enabled is not None:
self._values["sas_http_enabled"] = sas_http_enabled
if sas_local_dns_enabled is not None:
self._values["sas_local_dns_enabled"] = sas_local_dns_enabled
if sas_login_enabled is not None:
self._values["sas_login_enabled"] = sas_login_enabled
if sas_network_enabled is not None:
self._values["sas_network_enabled"] = sas_network_enabled
if sas_process_enabled is not None:
self._values["sas_process_enabled"] = sas_process_enabled
if sas_security_alert_enabled is not None:
self._values["sas_security_alert_enabled"] = sas_security_alert_enabled
if sas_security_hc_enabled is not None:
self._values["sas_security_hc_enabled"] = sas_security_hc_enabled
if sas_security_vul_enabled is not None:
self._values["sas_security_vul_enabled"] = sas_security_vul_enabled
if sas_session_enabled is not None:
self._values["sas_session_enabled"] = sas_session_enabled
if sas_snapshot_account_enabled is not None:
self._values["sas_snapshot_account_enabled"] = sas_snapshot_account_enabled
if sas_snapshot_port_enabled is not None:
self._values["sas_snapshot_port_enabled"] = sas_snapshot_port_enabled
if sas_snapshot_process_enabled is not None:
self._values["sas_snapshot_process_enabled"] = sas_snapshot_process_enabled
if sas_ti_enabled is not None:
self._values["sas_ti_enabled"] = sas_ti_enabled
if sas_ttl is not None:
self._values["sas_ttl"] = sas_ttl
if slb_access_collection_policy is not None:
self._values["slb_access_collection_policy"] = slb_access_collection_policy
if slb_access_enabled is not None:
self._values["slb_access_enabled"] = slb_access_enabled
if slb_access_policy_setting is not None:
self._values["slb_access_policy_setting"] = slb_access_policy_setting
if slb_access_ti_enabled is not None:
self._values["slb_access_ti_enabled"] = slb_access_ti_enabled
if slb_access_ttl is not None:
self._values["slb_access_ttl"] = slb_access_ttl
if slb_sync_enabled is not None:
self._values["slb_sync_enabled"] = slb_sync_enabled
if slb_sync_ttl is not None:
self._values["slb_sync_ttl"] = slb_sync_ttl
if waf_access_collection_policy is not None:
self._values["waf_access_collection_policy"] = waf_access_collection_policy
if waf_access_policy_setting is not None:
self._values["waf_access_policy_setting"] = waf_access_policy_setting
if waf_enabled is not None:
self._values["waf_enabled"] = waf_enabled
if waf_ti_enabled is not None:
self._values["waf_ti_enabled"] = waf_ti_enabled
if waf_ttl is not None:
self._values["waf_ttl"] = waf_ttl
@builtins.property
def actiontrail_enabled(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: actiontrailEnabled: Notification type. Support Email, SMS, DingTalk. Default true.
'''
result = self._values.get("actiontrail_enabled")
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def actiontrail_openapi_collection_policy(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: actiontrailOpenapiCollectionPolicy: Actiontrail openapi collection policy
'''
result = self._values.get("actiontrail_openapi_collection_policy")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def actiontrail_openapi_policy_setting(
self,
) -> typing.Optional[typing.Union[typing.List[typing.Any], _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: actiontrailOpenapiPolicySetting: Actiontrail openapi policy setting.
'''
result = self._values.get("actiontrail_openapi_policy_setting")
return typing.cast(typing.Optional[typing.Union[typing.List[typing.Any], _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def actiontrail_ti_enabled(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: actiontrailTiEnabled: Threat Intelligence of actiontrail.
'''
result = self._values.get("actiontrail_ti_enabled")
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def actiontrail_ttl(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: actiontrailTtl: Actiontrail action log TTL.
'''
result = self._values.get("actiontrail_ttl")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def apigateway_access_collection_policy(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: apigatewayAccessCollectionPolicy: Apigateway audit collection policy
'''
result = self._values.get("apigateway_access_collection_policy")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def apigateway_access_policy_setting(
self,
) -> typing.Optional[typing.Union[typing.List[typing.Any], _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: apigatewayAccessPolicySetting: Apigateway audit policy setting.
'''
result = self._values.get("apigateway_access_policy_setting")
return typing.cast(typing.Optional[typing.Union[typing.List[typing.Any], _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def apigateway_enabled(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: apigatewayEnabled: API Gateway Log Switch. Default true.
'''
result = self._values.get("apigateway_enabled")
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def apigateway_ti_enabled(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: apigatewayTiEnabled: Threat Intelligence of Apigateway.
'''
result = self._values.get("apigateway_ti_enabled")
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def apigateway_ttl(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: apigatewayTtl: API Gateway ttl. Default 180.
'''
result = self._values.get("apigateway_ttl")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def appconnect_enabled(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: appconnectEnabled: Appconnect access log switch. Default false.
'''
result = self._values.get("appconnect_enabled")
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def appconnect_op_collection_policy(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: appconnectOpCollectionPolicy: Appconnect audit collection policy
'''
result = self._values.get("appconnect_op_collection_policy")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def appconnect_op_policy_setting(
self,
) -> typing.Optional[typing.Union[typing.List[typing.Any], _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: appconnectOpPolicySetting: Appconnect audit policy setting.
'''
result = self._values.get("appconnect_op_policy_setting")
return typing.cast(typing.Optional[typing.Union[typing.List[typing.Any], _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def appconnect_ti_enabled(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: appconnectTiEnabled: Threat Intelligence of Appconnect.
'''
result = self._values.get("appconnect_ti_enabled")
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def appconnect_ttl(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: appconnectTtl: Appconnect log centralization ttl. Default 180.
'''
result = self._values.get("appconnect_ttl")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def bastion_audit_collection_policy(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: bastionAuditCollectionPolicy: Bastion audit collection policy
'''
result = self._values.get("bastion_audit_collection_policy")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def bastion_audit_policy_setting(
self,
) -> typing.Optional[typing.Union[typing.List[typing.Any], _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: bastionAuditPolicySetting: Bastion audit policy setting.
'''
result = self._values.get("bastion_audit_policy_setting")
return typing.cast(typing.Optional[typing.Union[typing.List[typing.Any], _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def bastion_enabled(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: bastionEnabled: Fortress machine operation log switch.Default true.
'''
result = self._values.get("bastion_enabled")
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def bastion_ti_enabled(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: bastionTiEnabled: Threat Intelligence of Bastion.
'''
result = self._values.get("bastion_ti_enabled")
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def bastion_ttl(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: bastionTtl: Fort machine centralized ttl. Default 180.
'''
result = self._values.get("bastion_ttl")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def cloudfirewall_access_collection_policy(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: cloudfirewallAccessCollectionPolicy: Cloud firewall audit collection policy
'''
result = self._values.get("cloudfirewall_access_collection_policy")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def cloudfirewall_access_policy_setting(
self,
) -> typing.Optional[typing.Union[typing.List[typing.Any], _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: cloudfirewallAccessPolicySetting: Cloud firewall audit policy setting.
'''
result = self._values.get("cloudfirewall_access_policy_setting")
return typing.cast(typing.Optional[typing.Union[typing.List[typing.Any], _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def cloudfirewall_enabled(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: cloudfirewallEnabled: Cloud firewall log switch. Default true.
'''
result = self._values.get("cloudfirewall_enabled")
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def cloudfirewall_ti_enabled(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: cloudfirewallTiEnabled: Threat Intelligence of Cloud firewall.
'''
result = self._values.get("cloudfirewall_ti_enabled")
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def cloudfirewall_ttl(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: cloudfirewallTtl: Cloud firewall log centralized ttl. Default 180.
'''
result = self._values.get("cloudfirewall_ttl")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def cps_callback_collection_policy(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: cpsCallbackCollectionPolicy: Mobile push collection policy
'''
result = self._values.get("cps_callback_collection_policy")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def cps_callback_policy_setting(
self,
) -> typing.Optional[typing.Union[typing.List[typing.Any], _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: cpsCallbackPolicySetting: Mobile push policy setting.
'''
result = self._values.get("cps_callback_policy_setting")
return typing.cast(typing.Optional[typing.Union[typing.List[typing.Any], _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def cps_enabled(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: cpsEnabled: Mobile push log switch. Default true.
'''
result = self._values.get("cps_enabled")
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def cps_ti_enabled(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: cpsTiEnabled: Threat Intelligence of mobile push.
'''
result = self._values.get("cps_ti_enabled")
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def cps_ttl(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: cpsTtl: Mobile push ttl. Default 180.
'''
result = self._values.get("cps_ttl")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def ddos_coo_access_collection_policy(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: ddosCooAccessCollectionPolicy: Ddos audit collection policy
'''
result = self._values.get("ddos_coo_access_collection_policy")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def ddos_coo_access_enabled(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: ddosCooAccessEnabled: Ddos access log switch. Default false.
'''
result = self._values.get("ddos_coo_access_enabled")
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def ddos_coo_access_policy_setting(
self,
) -> typing.Optional[typing.Union[typing.List[typing.Any], _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: ddosCooAccessPolicySetting: Ddos audit policy setting.
'''
result = self._values.get("ddos_coo_access_policy_setting")
return typing.cast(typing.Optional[typing.Union[typing.List[typing.Any], _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def ddos_coo_access_ti_enabled(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: ddosCooAccessTiEnabled: Threat Intelligence of Ddos.
'''
result = self._values.get("ddos_coo_access_ti_enabled")
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def ddos_coo_access_ttl(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: ddosCooAccessTtl: Ddos log centralization ttl. Default 180.
'''
result = self._values.get("ddos_coo_access_ttl")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def drds_audit_collection_policy(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: drdsAuditCollectionPolicy: DRDS audit collection policy
'''
result = self._values.get("drds_audit_collection_policy")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def drds_audit_enabled(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: drdsAuditEnabled: DRDS audit log switch. Default true.
'''
result = self._values.get("drds_audit_enabled")
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def drds_audit_policy_setting(
self,
) -> typing.Optional[typing.Union[typing.List[typing.Any], _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: drdsAuditPolicySetting: DRDS audit policy setting.
'''
result = self._values.get("drds_audit_policy_setting")
return typing.cast(typing.Optional[typing.Union[typing.List[typing.Any], _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def drds_audit_ti_enabled(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: drdsAuditTiEnabled: Threat Intelligence of DRDS.
'''
result = self._values.get("drds_audit_ti_enabled")
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def drds_audit_ttl(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: drdsAuditTtl: DRDS log centralization ttl. Default 7.
'''
result = self._values.get("drds_audit_ttl")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def drds_sync_enabled(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: drdsSyncEnabled: DRDS sync to center switch. Default true.
'''
result = self._values.get("drds_sync_enabled")
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def drds_sync_ttl(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: drdsSyncTtl: DRDS sync to center ttl. Default 180.
'''
result = self._values.get("drds_sync_ttl")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def k8_s_audit_collection_policy(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: k8SAuditCollectionPolicy: K8s audit collection policy
'''
result = self._values.get("k8_s_audit_collection_policy")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def k8_s_audit_enabled(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: k8SAuditEnabled: K8s access log switch. Default false.
'''
result = self._values.get("k8_s_audit_enabled")
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def k8_s_audit_policy_setting(
self,
) -> typing.Optional[typing.Union[typing.List[typing.Any], _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: k8SAuditPolicySetting: K8s audit policy setting.
'''
result = self._values.get("k8_s_audit_policy_setting")
return typing.cast(typing.Optional[typing.Union[typing.List[typing.Any], _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def k8_s_audit_ti_enabled(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: k8SAuditTiEnabled: Threat Intelligence of K8s.
'''
result = self._values.get("k8_s_audit_ti_enabled")
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def k8_s_audit_ttl(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: k8SAuditTtl: K8s log centralization ttl. Default 180.
'''
result = self._values.get("k8_s_audit_ttl")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def k8_s_event_collection_policy(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: k8SEventCollectionPolicy: K8s event collection policy
'''
result = self._values.get("k8_s_event_collection_policy")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def k8_s_event_enabled(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: k8SEventEnabled: K8s event log switch. Default false.
'''
result = self._values.get("k8_s_event_enabled")
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def k8_s_event_policy_setting(
self,
) -> typing.Optional[typing.Union[typing.List[typing.Any], _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: k8SEventPolicySetting: K8s event policy setting.
'''
result = self._values.get("k8_s_event_policy_setting")
return typing.cast(typing.Optional[typing.Union[typing.List[typing.Any], _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def k8_s_event_ti_enabled(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: k8SEventTiEnabled: Threat Intelligence of k8s event.
'''
result = self._values.get("k8_s_event_ti_enabled")
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def k8_s_event_ttl(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: k8SEventTtl: K8s event log centralization ttl. Default 180.
'''
result = self._values.get("k8_s_event_ttl")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def k8_s_ingress_collection_policy(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: k8SIngressCollectionPolicy: K8s Ingress collection policy
'''
result = self._values.get("k8_s_ingress_collection_policy")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def k8_s_ingress_enabled(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: k8SIngressEnabled: K8s Ingress log switch. Default false.
'''
result = self._values.get("k8_s_ingress_enabled")
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def k8_s_ingress_policy_setting(
self,
) -> typing.Optional[typing.Union[typing.List[typing.Any], _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: k8SIngressPolicySetting: K8s Ingress policy setting.
'''
result = self._values.get("k8_s_ingress_policy_setting")
return typing.cast(typing.Optional[typing.Union[typing.List[typing.Any], _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def k8_s_ingress_ti_enabled(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: k8SIngressTiEnabled: Threat Intelligence of k8s Ingress.
'''
result = self._values.get("k8_s_ingress_ti_enabled")
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def k8_s_ingress_ttl(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: k8SIngressTtl: K8s Ingress log centralization ttl. Default 180.
'''
result = self._values.get("k8_s_ingress_ttl")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def nas_audit_collection_policy(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: nasAuditCollectionPolicy: Nas audit collection policy
'''
result = self._values.get("nas_audit_collection_policy")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def nas_audit_policy_setting(
self,
) -> typing.Optional[typing.Union[typing.List[typing.Any], _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: nasAuditPolicySetting: Nas audit policy setting.
'''
result = self._values.get("nas_audit_policy_setting")
return typing.cast(typing.Optional[typing.Union[typing.List[typing.Any], _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def nas_enabled(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: nasEnabled: Nas log switch. Default true.
'''
result = self._values.get("nas_enabled")
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def nas_ti_enabled(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: nasTiEnabled: Threat Intelligence of Nas.
'''
result = self._values.get("nas_ti_enabled")
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def nas_ttl(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: nasTtl: Nas centralized ttl. Default 180.
'''
result = self._values.get("nas_ttl")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def oss_access_collection_policy(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: ossAccessCollectionPolicy: Oss access collection policy.
'''
result = self._values.get("oss_access_collection_policy")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def oss_access_enabled(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: ossAccessEnabled: Access log switch of OSS. Default true.
'''
result = self._values.get("oss_access_enabled")
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def oss_access_policy_setting(
self,
) -> typing.Optional[typing.Union[typing.List[typing.Any], _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: ossAccessPolicySetting: Oss access policy setting.
'''
result = self._values.get("oss_access_policy_setting")
return typing.cast(typing.Optional[typing.Union[typing.List[typing.Any], _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def oss_access_ti_enabled(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: ossAccessTiEnabled: Threat Intelligence of oss.
'''
result = self._values.get("oss_access_ti_enabled")
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def oss_access_ttl(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: ossAccessTtl: Access log TTL of OSS. Default 180.
'''
result = self._values.get("oss_access_ttl")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def oss_metering_collection_policy(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: ossMeteringCollectionPolicy: Oss metering collection policy.
'''
result = self._values.get("oss_metering_collection_policy")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def oss_metering_enabled(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: ossMeteringEnabled: OSS metering log switch.Default true.
'''
result = self._values.get("oss_metering_enabled")
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def oss_metering_policy_setting(
self,
) -> typing.Optional[typing.Union[typing.List[typing.Any], _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: ossMeteringPolicySetting: Oss metering policy setting.
'''
result = self._values.get("oss_metering_policy_setting")
return typing.cast(typing.Optional[typing.Union[typing.List[typing.Any], _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def oss_metering_ti_enabled(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: ossMeteringTiEnabled: Threat Intelligence of oss metering.
'''
result = self._values.get("oss_metering_ti_enabled")
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def oss_metering_ttl(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: ossMeteringTtl: OSS measurement log TTL. Default 180.
'''
result = self._values.get("oss_metering_ttl")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def oss_sync_enabled(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: ossSyncEnabled: OSS synchronization to central configuration switch. Default true.
'''
result = self._values.get("oss_sync_enabled")
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def oss_sync_ttl(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: ossSyncTtl: OSS synchronization to central TTL. Default 180.
'''
result = self._values.get("oss_sync_ttl")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def polardb_audit_collection_policy(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: polardbAuditCollectionPolicy: POLARDB audit collection policy
'''
result = self._values.get("polardb_audit_collection_policy")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def polardb_audit_policy_setting(
self,
) -> typing.Optional[typing.Union[typing.List[typing.Any], _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: polardbAuditPolicySetting: POLARDB audit policy setting.
'''
result = self._values.get("polardb_audit_policy_setting")
return typing.cast(typing.Optional[typing.Union[typing.List[typing.Any], _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def polardb_enabled(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: polardbEnabled: POLARDB audit log switch. Default true.
'''
result = self._values.get("polardb_enabled")
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def polardb_perf_collection_policy(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: polardbPerfCollectionPolicy: POLARDB perf collection policy.
'''
result = self._values.get("polardb_perf_collection_policy")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def polardb_perf_enabled(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: polardbPerfEnabled: POLARDB perf log switch. Default false.
'''
result = self._values.get("polardb_perf_enabled")
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def polardb_perf_policy_setting(
self,
) -> typing.Optional[typing.Union[typing.List[typing.Any], _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: polardbPerfPolicySetting: POLARDB perf policy setting.
'''
result = self._values.get("polardb_perf_policy_setting")
return typing.cast(typing.Optional[typing.Union[typing.List[typing.Any], _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def polardb_perf_ti_enabled(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: polardbPerfTiEnabled: Threat Intelligence of POLARDB perf log.
'''
result = self._values.get("polardb_perf_ti_enabled")
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def polardb_perf_ttl(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: polardbPerfTtl: POLARDB perf log centralization ttl. Default 180.
'''
result = self._values.get("polardb_perf_ttl")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def polardb_slow_collection_policy(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: polardbSlowCollectionPolicy: POLARDB slow collection policy.
'''
result = self._values.get("polardb_slow_collection_policy")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def polardb_slow_enabled(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: polardbSlowEnabled: POLARDB slow log switch. Default false.
'''
result = self._values.get("polardb_slow_enabled")
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def polardb_slow_policy_setting(
self,
) -> typing.Optional[typing.Union[typing.List[typing.Any], _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: polardbSlowPolicySetting: POLARDB slow policy setting.
'''
result = self._values.get("polardb_slow_policy_setting")
return typing.cast(typing.Optional[typing.Union[typing.List[typing.Any], _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def polardb_slow_ti_enabled(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: polardbSlowTiEnabled: Threat Intelligence of POLARDB slow log.
'''
result = self._values.get("polardb_slow_ti_enabled")
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def polardb_slow_ttl(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: polardbSlowTtl: POLARDB slow log centralization ttl. Default 180.
'''
result = self._values.get("polardb_slow_ttl")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def polardb_ti_enabled(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: polardbTiEnabled: Threat Intelligence of POLARDB.
'''
result = self._values.get("polardb_ti_enabled")
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def polardb_ttl(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: polardbTtl: POLARDB log centralization ttl. Default 180.
'''
result = self._values.get("polardb_ttl")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def rds_audit_collection_policy(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: rdsAuditCollectionPolicy: Rds audit collection policy
'''
result = self._values.get("rds_audit_collection_policy")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def rds_audit_policy_setting(
self,
) -> typing.Optional[typing.Union[typing.List[typing.Any], _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: rdsAuditPolicySetting: Rds audit policy setting.
'''
result = self._values.get("rds_audit_policy_setting")
return typing.cast(typing.Optional[typing.Union[typing.List[typing.Any], _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def rds_enabled(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: rdsEnabled: RDS audit log switch. Default true.
'''
result = self._values.get("rds_enabled")
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def rds_perf_collection_policy(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: rdsPerfCollectionPolicy: Rds perf collection policy.
'''
result = self._values.get("rds_perf_collection_policy")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def rds_perf_enabled(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: rdsPerfEnabled: RDS perf log switch. Default false.
'''
result = self._values.get("rds_perf_enabled")
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def rds_perf_policy_setting(
self,
) -> typing.Optional[typing.Union[typing.List[typing.Any], _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: rdsPerfPolicySetting: Rds perf policy setting.
'''
result = self._values.get("rds_perf_policy_setting")
return typing.cast(typing.Optional[typing.Union[typing.List[typing.Any], _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def rds_perf_ti_enabled(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: rdsPerfTiEnabled: Threat Intelligence of rds perf log.
'''
result = self._values.get("rds_perf_ti_enabled")
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def rds_perf_ttl(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: rdsPerfTtl: Rds perf log centralization ttl. Default 180.
'''
result = self._values.get("rds_perf_ttl")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def rds_slow_collection_policy(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: rdsSlowCollectionPolicy: Rds slow collection policy.
'''
result = self._values.get("rds_slow_collection_policy")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def rds_slow_enabled(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: rdsSlowEnabled: RDS slow log switch. Default false.
'''
result = self._values.get("rds_slow_enabled")
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def rds_slow_policy_setting(
self,
) -> typing.Optional[typing.Union[typing.List[typing.Any], _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: rdsSlowPolicySetting: Rds slow policy setting.
'''
result = self._values.get("rds_slow_policy_setting")
return typing.cast(typing.Optional[typing.Union[typing.List[typing.Any], _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def rds_slow_ti_enabled(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: rdsSlowTiEnabled: Threat Intelligence of rds slow log.
'''
result = self._values.get("rds_slow_ti_enabled")
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def rds_slow_ttl(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: rdsSlowTtl: Rds slow log centralization ttl. Default 180.
'''
result = self._values.get("rds_slow_ttl")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def rds_ti_enabled(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: rdsTiEnabled: Threat Intelligence of rds.
'''
result = self._values.get("rds_ti_enabled")
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def rds_ttl(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: rdsTtl: Rds log centralization ttl. Default 180.
'''
result = self._values.get("rds_ttl")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def redis_audit_collection_policy(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: redisAuditCollectionPolicy: Redis audit collection policy
'''
result = self._values.get("redis_audit_collection_policy")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def redis_audit_enabled(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: redisAuditEnabled: Redis audit log switch. Default true.
'''
result = self._values.get("redis_audit_enabled")
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def redis_audit_policy_setting(
self,
) -> typing.Optional[typing.Union[typing.List[typing.Any], _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: redisAuditPolicySetting: Redis audit policy setting.
'''
result = self._values.get("redis_audit_policy_setting")
return typing.cast(typing.Optional[typing.Union[typing.List[typing.Any], _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def redis_audit_ti_enabled(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: redisAuditTiEnabled: Threat Intelligence of Redis audit.
'''
result = self._values.get("redis_audit_ti_enabled")
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def redis_audit_ttl(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: redisAuditTtl: Redis audit log centralization ttl. Default 7.
'''
result = self._values.get("redis_audit_ttl")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def redis_sync_enabled(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: redisSyncEnabled: Redis sync to center switch. Default true.
'''
result = self._values.get("redis_sync_enabled")
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def redis_sync_ttl(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: redisSyncTtl: Redis sync to center switch. Default 180.
'''
result = self._values.get("redis_sync_ttl")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def sas_crack_enabled(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: sasCrackEnabled: Cloud Security Center Brute Force Log Switch. Default false.
'''
result = self._values.get("sas_crack_enabled")
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def sas_dns_enabled(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: sasDnsEnabled: Cloud Security Center DNS resolution log switch. Default false.
'''
result = self._values.get("sas_dns_enabled")
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def sas_http_enabled(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: sasHttpEnabled: Cloud Security Center WEB access log switch. Default false.
'''
result = self._values.get("sas_http_enabled")
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def sas_local_dns_enabled(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: sasLocalDnsEnabled: Cloud security center local DNS log switch. Default false.
'''
result = self._values.get("sas_local_dns_enabled")
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def sas_login_enabled(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: sasLoginEnabled: Cloud security center login flow log switch. Default false.
'''
result = self._values.get("sas_login_enabled")
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def sas_network_enabled(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: sasNetworkEnabled: Cloud security center network connection log switch. Default false.
'''
result = self._values.get("sas_network_enabled")
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def sas_process_enabled(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: sasProcessEnabled: Cloud Security Center process startup log switch. Default false.
'''
result = self._values.get("sas_process_enabled")
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def sas_security_alert_enabled(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: sasSecurityAlertEnabled: Cloud Security Center Security Alarm Log Switch .Default false.
'''
result = self._values.get("sas_security_alert_enabled")
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def sas_security_hc_enabled(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: sasSecurityHcEnabled: Cloud Security Center Baseline Log Switch. Default false.
'''
result = self._values.get("sas_security_hc_enabled")
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def sas_security_vul_enabled(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: sasSecurityVulEnabled: Cloud Security Center Vulnerability Log Switch.Default false.
'''
result = self._values.get("sas_security_vul_enabled")
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def sas_session_enabled(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: sasSessionEnabled: Cloud security center network session log switch.Default false.
'''
result = self._values.get("sas_session_enabled")
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def sas_snapshot_account_enabled(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: sasSnapshotAccountEnabled: Cloud Security Center account snapshot switch. Default false.
'''
result = self._values.get("sas_snapshot_account_enabled")
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def sas_snapshot_port_enabled(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: sasSnapshotPortEnabled: Cloud Security Center Port Snapshot Switch. Default false.
'''
result = self._values.get("sas_snapshot_port_enabled")
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def sas_snapshot_process_enabled(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: sasSnapshotProcessEnabled: Cloud Security Center process snapshot switch. Default false.
'''
result = self._values.get("sas_snapshot_process_enabled")
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def sas_ti_enabled(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: sasTiEnabled: Threat Intelligence of Cloud Security Center.
'''
result = self._values.get("sas_ti_enabled")
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def sas_ttl(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: sasTtl: Cloud Security Center centralized ttl. Default 180.
'''
result = self._values.get("sas_ttl")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def slb_access_collection_policy(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: slbAccessCollectionPolicy: SLB audit collection policy
'''
result = self._values.get("slb_access_collection_policy")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def slb_access_enabled(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: slbAccessEnabled: Slb log switch. Default true.
'''
result = self._values.get("slb_access_enabled")
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def slb_access_policy_setting(
self,
) -> typing.Optional[typing.Union[typing.List[typing.Any], _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: slbAccessPolicySetting: SLB audit policy setting.
'''
result = self._values.get("slb_access_policy_setting")
return typing.cast(typing.Optional[typing.Union[typing.List[typing.Any], _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def slb_access_ti_enabled(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: slbAccessTiEnabled: Threat Intelligence of SLB.
'''
result = self._values.get("slb_access_ti_enabled")
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def slb_access_ttl(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: slbAccessTtl: Slb centralized ttl. Default 7.
'''
result = self._values.get("slb_access_ttl")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def slb_sync_enabled(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: slbSyncEnabled: Slb sync to center switch. Default true.
'''
result = self._values.get("slb_sync_enabled")
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def slb_sync_ttl(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: slbSyncTtl: Slb sync to center switch. Default 180.
'''
result = self._values.get("slb_sync_ttl")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def waf_access_collection_policy(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: wafAccessCollectionPolicy: Waf audit collection policy
'''
result = self._values.get("waf_access_collection_policy")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def waf_access_policy_setting(
self,
) -> typing.Optional[typing.Union[typing.List[typing.Any], _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: wafAccessPolicySetting: Waf audit policy setting.
'''
result = self._values.get("waf_access_policy_setting")
return typing.cast(typing.Optional[typing.Union[typing.List[typing.Any], _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def waf_enabled(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: wafEnabled: Waf log switch. Default true.
'''
result = self._values.get("waf_enabled")
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def waf_ti_enabled(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: wafTiEnabled: Threat Intelligence of Waf.
'''
result = self._values.get("waf_ti_enabled")
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def waf_ttl(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: wafTtl: Waf centralized ttl. Default true.
'''
result = self._values.get("waf_ttl")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "VariableMapProperty(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-sls.RosAuditProps",
jsii_struct_bases=[],
name_mapping={
"display_name": "displayName",
"variable_map": "variableMap",
"multi_account": "multiAccount",
},
)
class RosAuditProps:
def __init__(
self,
*,
display_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
variable_map: typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union[RosAudit.VariableMapProperty, typing.Dict[builtins.str, typing.Any]]],
multi_account: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::SLS::Audit``.
:param display_name:
:param variable_map:
:param multi_account:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__1d2861046ac4d48cde619a94d8919ee5e9c24ee45791046b89dfc9fb8d1d8e42)
check_type(argname="argument display_name", value=display_name, expected_type=type_hints["display_name"])
check_type(argname="argument variable_map", value=variable_map, expected_type=type_hints["variable_map"])
check_type(argname="argument multi_account", value=multi_account, expected_type=type_hints["multi_account"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"display_name": display_name,
"variable_map": variable_map,
}
if multi_account is not None:
self._values["multi_account"] = multi_account
@builtins.property
def display_name(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: displayName: Name of SLS log audit.
'''
result = self._values.get("display_name")
assert result is not None, "Required property 'display_name' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def variable_map(
self,
) -> typing.Union[_ros_cdk_core_7adfd82f.IResolvable, RosAudit.VariableMapProperty]:
'''
:Property: variableMap: Log audit detailed configuration.
'''
result = self._values.get("variable_map")
assert result is not None, "Required property 'variable_map' is missing"
return typing.cast(typing.Union[_ros_cdk_core_7adfd82f.IResolvable, RosAudit.VariableMapProperty], result)
@builtins.property
def multi_account(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]]:
'''
:Property: multiAccount: Multi-account configuration, please fill in multiple aliuid.
'''
result = self._values.get("multi_account")
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "RosAuditProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class RosDashboard(
_ros_cdk_core_7adfd82f.RosResource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-sls.RosDashboard",
):
'''A ROS template type: ``ALIYUN::SLS::Dashboard``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["RosDashboardProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
'''Create a new ``ALIYUN::SLS::Dashboard``.
:param scope: - scope in which this resource is defined.
:param id: - scoped id of the resource.
:param props: - resource properties.
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__fd50f65d29bc70c859f0193198038e1f8bb1d06f1d48b13646eaa5811c34cb78)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@jsii.member(jsii_name="renderProperties")
def _render_properties(
self,
props: typing.Mapping[builtins.str, typing.Any],
) -> typing.Mapping[builtins.str, typing.Any]:
'''
:param props: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__b10123e297b0bd87f1531d795fd616db36165eb2a822dde28d1600151f9de981)
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))
@jsii.python.classproperty
@jsii.member(jsii_name="ROS_RESOURCE_TYPE_NAME")
def ROS_RESOURCE_TYPE_NAME(cls) -> builtins.str:
'''The resource type name for this resource class.'''
return typing.cast(builtins.str, jsii.sget(cls, "ROS_RESOURCE_TYPE_NAME"))
@builtins.property
@jsii.member(jsii_name="attrDashboardName")
def attr_dashboard_name(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: DashboardName: Dashboard name.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrDashboardName"))
@builtins.property
@jsii.member(jsii_name="attrDisplayName")
def attr_display_name(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: DisplayName: Display name.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrDisplayName"))
@builtins.property
@jsii.member(jsii_name="rosProperties")
def _ros_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "rosProperties"))
@builtins.property
@jsii.member(jsii_name="charts")
def charts(
self,
) -> typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Mapping[builtins.str, typing.Any]]]:
'''
:Property: charts: Chart list.
'''
return typing.cast(typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Mapping[builtins.str, typing.Any]]], jsii.get(self, "charts"))
@charts.setter
def charts(
self,
value: typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Mapping[builtins.str, typing.Any]]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__cb09229de9b13f454f82a24993cb6f24401ab5ff300dea9120fd22c4c1b1f00f)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "charts", value)
@builtins.property
@jsii.member(jsii_name="dashboardName")
def dashboard_name(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: dashboardName: Dashboard name.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "dashboardName"))
@dashboard_name.setter
def dashboard_name(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__a8fb543f50a85a4b565866c57626719892e7d61e88ec6377a6c4af0202933f36)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "dashboardName", value)
@builtins.property
@jsii.member(jsii_name="enableResourcePropertyConstraint")
def enable_resource_property_constraint(self) -> builtins.bool:
return typing.cast(builtins.bool, jsii.get(self, "enableResourcePropertyConstraint"))
@enable_resource_property_constraint.setter
def enable_resource_property_constraint(self, value: builtins.bool) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__439bbc6870978e93eed81f405e3a75c5b7326485ec7a80dd8cc17c0baa2f9958)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "enableResourcePropertyConstraint", value)
@builtins.property
@jsii.member(jsii_name="projectName")
def project_name(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
projectName: Project name:
1. Only supports lowercase letters, numbers, hyphens (-) and underscores (_).
2. Must start and end with lowercase letters and numbers.
3. The name length is 3-63 characters.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "projectName"))
@project_name.setter
def project_name(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__c9bc5d0198c94fb52870bd05f1791ac5581591fdafa04b4bb0dc7eb818a3352c)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "projectName", value)
@builtins.property
@jsii.member(jsii_name="description")
def description(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: description: Dashboard description.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "description"))
@description.setter
def description(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__cddded3fddc15c08b72183294f32f51b7a0e7b61f692adeb6a21c0a0218bcb95)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "description", value)
@builtins.property
@jsii.member(jsii_name="displayName")
def display_name(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: displayName: Dashboard display name.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "displayName"))
@display_name.setter
def display_name(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__fe911883fffd2344bcc81368339aa13d9893f1deb704301f8c77ff1eee5bd1fb)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "displayName", value)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-sls.RosDashboardProps",
jsii_struct_bases=[],
name_mapping={
"charts": "charts",
"dashboard_name": "dashboardName",
"project_name": "projectName",
"description": "description",
"display_name": "displayName",
},
)
class RosDashboardProps:
def __init__(
self,
*,
charts: typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Mapping[builtins.str, typing.Any]]],
dashboard_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
project_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
description: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
display_name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::SLS::Dashboard``.
:param charts:
:param dashboard_name:
:param project_name:
:param description:
:param display_name:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__cc97c1c3bf010a5ce2fbb4b8c6229fafd53acb09a877429a7944c70bfacb1d6b)
check_type(argname="argument charts", value=charts, expected_type=type_hints["charts"])
check_type(argname="argument dashboard_name", value=dashboard_name, expected_type=type_hints["dashboard_name"])
check_type(argname="argument project_name", value=project_name, expected_type=type_hints["project_name"])
check_type(argname="argument description", value=description, expected_type=type_hints["description"])
check_type(argname="argument display_name", value=display_name, expected_type=type_hints["display_name"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"charts": charts,
"dashboard_name": dashboard_name,
"project_name": project_name,
}
if description is not None:
self._values["description"] = description
if display_name is not None:
self._values["display_name"] = display_name
@builtins.property
def charts(
self,
) -> typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Mapping[builtins.str, typing.Any]]]:
'''
:Property: charts: Chart list.
'''
result = self._values.get("charts")
assert result is not None, "Required property 'charts' is missing"
return typing.cast(typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Mapping[builtins.str, typing.Any]]], result)
@builtins.property
def dashboard_name(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: dashboardName: Dashboard name.
'''
result = self._values.get("dashboard_name")
assert result is not None, "Required property 'dashboard_name' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def project_name(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
projectName: Project name:
1. Only supports lowercase letters, numbers, hyphens (-) and underscores (_).
2. Must start and end with lowercase letters and numbers.
3. The name length is 3-63 characters.
'''
result = self._values.get("project_name")
assert result is not None, "Required property 'project_name' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def description(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: description: Dashboard description.
'''
result = self._values.get("description")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def display_name(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: displayName: Dashboard display name.
'''
result = self._values.get("display_name")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "RosDashboardProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class RosEtl(
_ros_cdk_core_7adfd82f.RosResource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-sls.RosEtl",
):
'''A ROS template type: ``ALIYUN::SLS::Etl``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["RosEtlProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
'''Create a new ``ALIYUN::SLS::Etl``.
:param scope: - scope in which this resource is defined.
:param id: - scoped id of the resource.
:param props: - resource properties.
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__cee91076e193c92146eb93c8756d807308a573c4dbb6f640f4b797dfb8d86278)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@jsii.member(jsii_name="renderProperties")
def _render_properties(
self,
props: typing.Mapping[builtins.str, typing.Any],
) -> typing.Mapping[builtins.str, typing.Any]:
'''
:param props: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__e7a340b1b1e4c697934de0451aa1c7331e64e5611f505f966eca4918488b3faf)
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))
@jsii.python.classproperty
@jsii.member(jsii_name="ROS_RESOURCE_TYPE_NAME")
def ROS_RESOURCE_TYPE_NAME(cls) -> builtins.str:
'''The resource type name for this resource class.'''
return typing.cast(builtins.str, jsii.sget(cls, "ROS_RESOURCE_TYPE_NAME"))
@builtins.property
@jsii.member(jsii_name="attrName")
def attr_name(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: Name: ETL name.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrName"))
@builtins.property
@jsii.member(jsii_name="rosProperties")
def _ros_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "rosProperties"))
@builtins.property
@jsii.member(jsii_name="configuration")
def configuration(
self,
) -> typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosEtl.ConfigurationProperty"]:
'''
:Property: configuration: The configuration of ETL task
'''
return typing.cast(typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosEtl.ConfigurationProperty"], jsii.get(self, "configuration"))
@configuration.setter
def configuration(
self,
value: typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosEtl.ConfigurationProperty"],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__92b196e0ce9e6d731e7b057fb07e10c8d062fc90c9811e8171730711a8519252)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "configuration", value)
@builtins.property
@jsii.member(jsii_name="displayName")
def display_name(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: displayName: ETL display name
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "displayName"))
@display_name.setter
def display_name(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__986a3f1614fc9039f94c6acfc7cc2e274d14a302f44b81e5d712c83e7a11fa97)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "displayName", value)
@builtins.property
@jsii.member(jsii_name="enableResourcePropertyConstraint")
def enable_resource_property_constraint(self) -> builtins.bool:
return typing.cast(builtins.bool, jsii.get(self, "enableResourcePropertyConstraint"))
@enable_resource_property_constraint.setter
def enable_resource_property_constraint(self, value: builtins.bool) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__f49a3ca5092a23e35b5970fa51b5c37c42a2b2ad56a93a3e8840ca9794b119dc)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "enableResourcePropertyConstraint", value)
@builtins.property
@jsii.member(jsii_name="name")
def name(self) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: name: ETL name
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "name"))
@name.setter
def name(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__4e52fe6ab379e81e2db7402e819733676b20a0117dabc665ac6cdfd4e5743a38)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "name", value)
@builtins.property
@jsii.member(jsii_name="projectName")
def project_name(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: projectName: Project name
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "projectName"))
@project_name.setter
def project_name(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__229bf768ee665446a15e05cf25e084765eda239e0a64f9a08bf09bc458142561)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "projectName", value)
@builtins.property
@jsii.member(jsii_name="schedule")
def schedule(
self,
) -> typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosEtl.ScheduleProperty"]:
'''
:Property: schedule: Task scheduling strategy
'''
return typing.cast(typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosEtl.ScheduleProperty"], jsii.get(self, "schedule"))
@schedule.setter
def schedule(
self,
value: typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosEtl.ScheduleProperty"],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__be98996241ebe2d3e1a5ba2f9e4142cd1d6144eed0260bf66ee0a87290a8e876)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "schedule", value)
@builtins.property
@jsii.member(jsii_name="description")
def description(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: description: ETL description message.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "description"))
@description.setter
def description(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__0d3b541beec74566db83233cc704409d70bd0c0bcfa2433c7495d8ef9d8a8d4a)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "description", value)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-sls.RosEtl.ConfigurationProperty",
jsii_struct_bases=[],
name_mapping={
"logstore": "logstore",
"script": "script",
"sinks": "sinks",
"from_time": "fromTime",
"parameters": "parameters",
"role_arn": "roleArn",
"to_time": "toTime",
"version": "version",
},
)
class ConfigurationProperty:
def __init__(
self,
*,
logstore: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
script: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
sinks: typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union["RosEtl.SinksProperty", typing.Dict[builtins.str, typing.Any]]]]],
from_time: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
parameters: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]] = None,
role_arn: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
to_time: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
version: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''
:param logstore:
:param script:
:param sinks:
:param from_time:
:param parameters:
:param role_arn:
:param to_time:
:param version:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__bf246d0e31ea2a23bbf398a5a71e102a739d43371572c597135c8dcda16be38e)
check_type(argname="argument logstore", value=logstore, expected_type=type_hints["logstore"])
check_type(argname="argument script", value=script, expected_type=type_hints["script"])
check_type(argname="argument sinks", value=sinks, expected_type=type_hints["sinks"])
check_type(argname="argument from_time", value=from_time, expected_type=type_hints["from_time"])
check_type(argname="argument parameters", value=parameters, expected_type=type_hints["parameters"])
check_type(argname="argument role_arn", value=role_arn, expected_type=type_hints["role_arn"])
check_type(argname="argument to_time", value=to_time, expected_type=type_hints["to_time"])
check_type(argname="argument version", value=version, expected_type=type_hints["version"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"logstore": logstore,
"script": script,
"sinks": sinks,
}
if from_time is not None:
self._values["from_time"] = from_time
if parameters is not None:
self._values["parameters"] = parameters
if role_arn is not None:
self._values["role_arn"] = role_arn
if to_time is not None:
self._values["to_time"] = to_time
if version is not None:
self._values["version"] = version
@builtins.property
def logstore(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: logstore: The source logstore of the processing job.
'''
result = self._values.get("logstore")
assert result is not None, "Required property 'logstore' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def script(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: script: Processing operation grammar.
'''
result = self._values.get("script")
assert result is not None, "Required property 'script' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def sinks(
self,
) -> typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosEtl.SinksProperty"]]]:
'''
:Property: sinks: target logstore configuration for delivery after data processing.
'''
result = self._values.get("sinks")
assert result is not None, "Required property 'sinks' is missing"
return typing.cast(typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosEtl.SinksProperty"]]], result)
@builtins.property
def from_time(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: fromTime: The start time of the processing job, the default starts from the current time.
'''
result = self._values.get("from_time")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def parameters(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]]:
'''
:Property: parameters: Advanced parameter configuration of processing operations.
'''
result = self._values.get("parameters")
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]], result)
@builtins.property
def role_arn(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: roleArn: Sts role info under delivery target logstore.
'''
result = self._values.get("role_arn")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def to_time(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: toTime: Deadline of processing job, the default value is None
'''
result = self._values.get("to_time")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def version(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: version: The script version.
'''
result = self._values.get("version")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "ConfigurationProperty(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-sls.RosEtl.ScheduleProperty",
jsii_struct_bases=[],
name_mapping={"type": "type"},
)
class ScheduleProperty:
def __init__(
self,
*,
type: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
'''
:param type:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__4f64a84148b18d95ef18365a2ad3a1752c45ce6b9a05fd9e1b973a8e1408a8b0)
check_type(argname="argument type", value=type, expected_type=type_hints["type"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"type": type,
}
@builtins.property
def type(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: type: The type of task scheduling strategies, value: Resident
'''
result = self._values.get("type")
assert result is not None, "Required property 'type' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "ScheduleProperty(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-sls.RosEtl.SinksProperty",
jsii_struct_bases=[],
name_mapping={
"logstore": "logstore",
"name": "name",
"project": "project",
"endpoint": "endpoint",
"role_arn": "roleArn",
"type": "type",
},
)
class SinksProperty:
def __init__(
self,
*,
logstore: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
project: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
endpoint: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
role_arn: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''
:param logstore:
:param name:
:param project:
:param endpoint:
:param role_arn:
:param type:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__632876a1e42214bb020ccdf46163e7d34055ebb30c52a08d926414bf4286d93e)
check_type(argname="argument logstore", value=logstore, expected_type=type_hints["logstore"])
check_type(argname="argument name", value=name, expected_type=type_hints["name"])
check_type(argname="argument project", value=project, expected_type=type_hints["project"])
check_type(argname="argument endpoint", value=endpoint, expected_type=type_hints["endpoint"])
check_type(argname="argument role_arn", value=role_arn, expected_type=type_hints["role_arn"])
check_type(argname="argument type", value=type, expected_type=type_hints["type"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"logstore": logstore,
"name": name,
"project": project,
}
if endpoint is not None:
self._values["endpoint"] = endpoint
if role_arn is not None:
self._values["role_arn"] = role_arn
if type is not None:
self._values["type"] = type
@builtins.property
def logstore(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: logstore: Delivery target logstore.
'''
result = self._values.get("logstore")
assert result is not None, "Required property 'logstore' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def name(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: name: Delivery target name.
'''
result = self._values.get("name")
assert result is not None, "Required property 'name' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def project(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: project: The project where the target logstore is delivered.
'''
result = self._values.get("project")
assert result is not None, "Required property 'project' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def endpoint(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: endpoint: Delivery target logstore region.
'''
result = self._values.get("endpoint")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def role_arn(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: roleArn: Sts role info under delivery target logstore.
'''
result = self._values.get("role_arn")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def type(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: type: ETL sinks type, the default value is AliyunLOG.
'''
result = self._values.get("type")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "SinksProperty(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-sls.RosEtlProps",
jsii_struct_bases=[],
name_mapping={
"configuration": "configuration",
"display_name": "displayName",
"name": "name",
"project_name": "projectName",
"schedule": "schedule",
"description": "description",
},
)
class RosEtlProps:
def __init__(
self,
*,
configuration: typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union[RosEtl.ConfigurationProperty, typing.Dict[builtins.str, typing.Any]]],
display_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
project_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
schedule: typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union[RosEtl.ScheduleProperty, typing.Dict[builtins.str, typing.Any]]],
description: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::SLS::Etl``.
:param configuration:
:param display_name:
:param name:
:param project_name:
:param schedule:
:param description:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__cd5c0c77487f9a99e8a5949ee53700c39bb2b387d8d7e298f528d5e470c58217)
check_type(argname="argument configuration", value=configuration, expected_type=type_hints["configuration"])
check_type(argname="argument display_name", value=display_name, expected_type=type_hints["display_name"])
check_type(argname="argument name", value=name, expected_type=type_hints["name"])
check_type(argname="argument project_name", value=project_name, expected_type=type_hints["project_name"])
check_type(argname="argument schedule", value=schedule, expected_type=type_hints["schedule"])
check_type(argname="argument description", value=description, expected_type=type_hints["description"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"configuration": configuration,
"display_name": display_name,
"name": name,
"project_name": project_name,
"schedule": schedule,
}
if description is not None:
self._values["description"] = description
@builtins.property
def configuration(
self,
) -> typing.Union[_ros_cdk_core_7adfd82f.IResolvable, RosEtl.ConfigurationProperty]:
'''
:Property: configuration: The configuration of ETL task
'''
result = self._values.get("configuration")
assert result is not None, "Required property 'configuration' is missing"
return typing.cast(typing.Union[_ros_cdk_core_7adfd82f.IResolvable, RosEtl.ConfigurationProperty], result)
@builtins.property
def display_name(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: displayName: ETL display name
'''
result = self._values.get("display_name")
assert result is not None, "Required property 'display_name' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def name(self) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: name: ETL name
'''
result = self._values.get("name")
assert result is not None, "Required property 'name' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def project_name(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: projectName: Project name
'''
result = self._values.get("project_name")
assert result is not None, "Required property 'project_name' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def schedule(
self,
) -> typing.Union[_ros_cdk_core_7adfd82f.IResolvable, RosEtl.ScheduleProperty]:
'''
:Property: schedule: Task scheduling strategy
'''
result = self._values.get("schedule")
assert result is not None, "Required property 'schedule' is missing"
return typing.cast(typing.Union[_ros_cdk_core_7adfd82f.IResolvable, RosEtl.ScheduleProperty], result)
@builtins.property
def description(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: description: ETL description message.
'''
result = self._values.get("description")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "RosEtlProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class RosIndex(
_ros_cdk_core_7adfd82f.RosResource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-sls.RosIndex",
):
'''A ROS template type: ``ALIYUN::SLS::Index``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["RosIndexProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
'''Create a new ``ALIYUN::SLS::Index``.
:param scope: - scope in which this resource is defined.
:param id: - scoped id of the resource.
:param props: - resource properties.
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__37f495e2bfa9abf956c9392aa2f8709463c449c5ffe8d1de60b88201775d05b2)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@jsii.member(jsii_name="renderProperties")
def _render_properties(
self,
props: typing.Mapping[builtins.str, typing.Any],
) -> typing.Mapping[builtins.str, typing.Any]:
'''
:param props: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__1efa356708c9f6976afd733ef3e2533a8e4020bc02341fe33b8bd384d056d5e2)
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))
@jsii.python.classproperty
@jsii.member(jsii_name="ROS_RESOURCE_TYPE_NAME")
def ROS_RESOURCE_TYPE_NAME(cls) -> builtins.str:
'''The resource type name for this resource class.'''
return typing.cast(builtins.str, jsii.sget(cls, "ROS_RESOURCE_TYPE_NAME"))
@builtins.property
@jsii.member(jsii_name="rosProperties")
def _ros_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "rosProperties"))
@builtins.property
@jsii.member(jsii_name="enableResourcePropertyConstraint")
def enable_resource_property_constraint(self) -> builtins.bool:
'''A factory method that creates a new instance of this class from an object containing the properties of this ROS resource.'''
return typing.cast(builtins.bool, jsii.get(self, "enableResourcePropertyConstraint"))
@enable_resource_property_constraint.setter
def enable_resource_property_constraint(self, value: builtins.bool) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__c2e15e2874891bfbfad283076b534ecb7c53ce77135f5d3994b67571fcdd79dd)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "enableResourcePropertyConstraint", value)
@builtins.property
@jsii.member(jsii_name="fullTextIndex")
def full_text_index(
self,
) -> typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosIndex.FullTextIndexProperty"]:
'''
:Property:
fullTextIndex: Full-text indexing configuration.
Full-text indexing and key indexing must have at least one enabled.
'''
return typing.cast(typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosIndex.FullTextIndexProperty"], jsii.get(self, "fullTextIndex"))
@full_text_index.setter
def full_text_index(
self,
value: typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosIndex.FullTextIndexProperty"],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__5a8297738a61654c125b945e7df17d6cad7f9cd343e54f113699bbe43ccbb991)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "fullTextIndex", value)
@builtins.property
@jsii.member(jsii_name="logstoreName")
def logstore_name(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
logstoreName: Logstore name:
1. Only supports lowercase letters, numbers, hyphens (-) and underscores (_).
2. Must start and end with lowercase letters and numbers.
3. The name length is 3-63 characters.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "logstoreName"))
@logstore_name.setter
def logstore_name(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__8d63092da3741744d0b1ebed6e91eb3c4fd0593ea747e0819d73ebf13535c1f0)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "logstoreName", value)
@builtins.property
@jsii.member(jsii_name="projectName")
def project_name(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
projectName: Project name:
1. Only supports lowercase letters, numbers, hyphens (-) and underscores (_).
2. Must start and end with lowercase letters and numbers.
3. The name length is 3-63 characters.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "projectName"))
@project_name.setter
def project_name(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__14a0325c6a3c22d152d3d73a42f1a710e7e61a24165f79c4253c762286834e9f)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "projectName", value)
@builtins.property
@jsii.member(jsii_name="keyIndices")
def key_indices(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosIndex.KeyIndicesProperty"]]]]:
'''
:Property:
keyIndices: Key index configurations.
Full-text indexing and key indexing must have at least one enabled.
'''
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosIndex.KeyIndicesProperty"]]]], jsii.get(self, "keyIndices"))
@key_indices.setter
def key_indices(
self,
value: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosIndex.KeyIndicesProperty"]]]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__68bbf95f114dcf8be54931485e82ed1b47dff468ee5621f09d278bd53637fa9a)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "keyIndices", value)
@builtins.property
@jsii.member(jsii_name="logReduce")
def log_reduce(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: logReduce: Whether to enable log reduce. Default to false.
'''
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "logReduce"))
@log_reduce.setter
def log_reduce(
self,
value: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__f2f49703976a6c4004246fcd06b4f1f6163ab03e8268d04cc94c3b84bcf57894)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "logReduce", value)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-sls.RosIndex.FullTextIndexProperty",
jsii_struct_bases=[],
name_mapping={
"enable": "enable",
"case_sensitive": "caseSensitive",
"delimiter": "delimiter",
"include_chinese": "includeChinese",
},
)
class FullTextIndexProperty:
def __init__(
self,
*,
enable: typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable],
case_sensitive: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
delimiter: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
include_chinese: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''
:param enable:
:param case_sensitive:
:param delimiter:
:param include_chinese:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__de2ec08454981a62199bef98eb856a556b723526f9b8cbd3effd3b1434903aee)
check_type(argname="argument enable", value=enable, expected_type=type_hints["enable"])
check_type(argname="argument case_sensitive", value=case_sensitive, expected_type=type_hints["case_sensitive"])
check_type(argname="argument delimiter", value=delimiter, expected_type=type_hints["delimiter"])
check_type(argname="argument include_chinese", value=include_chinese, expected_type=type_hints["include_chinese"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"enable": enable,
}
if case_sensitive is not None:
self._values["case_sensitive"] = case_sensitive
if delimiter is not None:
self._values["delimiter"] = delimiter
if include_chinese is not None:
self._values["include_chinese"] = include_chinese
@builtins.property
def enable(
self,
) -> typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: enable: Whether to enable full-text indexing. Default to true.
'''
result = self._values.get("enable")
assert result is not None, "Required property 'enable' is missing"
return typing.cast(typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def case_sensitive(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: caseSensitive: Whether it is case sensitive. Default to false.
'''
result = self._values.get("case_sensitive")
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def delimiter(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:: &<>/:\\n\\t\\r )).
:Property: delimiter: Delimiter. Default to (( , '";=()[]{}?
'''
result = self._values.get("delimiter")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def include_chinese(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: includeChinese: Whether it contains Chinese. Default to false.
'''
result = self._values.get("include_chinese")
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "FullTextIndexProperty(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-sls.RosIndex.JsonKeyIndicesProperty",
jsii_struct_bases=[],
name_mapping={
"name": "name",
"type": "type",
"alias": "alias",
"enable_analytics": "enableAnalytics",
},
)
class JsonKeyIndicesProperty:
def __init__(
self,
*,
name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
type: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
alias: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
enable_analytics: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''
:param name:
:param type:
:param alias:
:param enable_analytics:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__16dc17dd234ed1b812f66947478d6c879cb3bcd68450b5807a20ada37bdbd3af)
check_type(argname="argument name", value=name, expected_type=type_hints["name"])
check_type(argname="argument type", value=type, expected_type=type_hints["type"])
check_type(argname="argument alias", value=alias, expected_type=type_hints["alias"])
check_type(argname="argument enable_analytics", value=enable_analytics, expected_type=type_hints["enable_analytics"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"name": name,
"type": type,
}
if alias is not None:
self._values["alias"] = alias
if enable_analytics is not None:
self._values["enable_analytics"] = enable_analytics
@builtins.property
def name(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: name: Json key name. It can be nested by dot(.), such as k1.k2.k3.
'''
result = self._values.get("name")
assert result is not None, "Required property 'name' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def type(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: type: Json key type. Allowed types: text, long, double. Default to text.
'''
result = self._values.get("type")
assert result is not None, "Required property 'type' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def alias(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: alias: Json key alias.
'''
result = self._values.get("alias")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def enable_analytics(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: enableAnalytics: Whether this json key is enabled for statistics. Default to true.
'''
result = self._values.get("enable_analytics")
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "JsonKeyIndicesProperty(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-sls.RosIndex.KeyIndicesProperty",
jsii_struct_bases=[],
name_mapping={
"name": "name",
"type": "type",
"alias": "alias",
"case_sensitive": "caseSensitive",
"delimiter": "delimiter",
"enable_analytics": "enableAnalytics",
"include_chinese": "includeChinese",
"json_key_indices": "jsonKeyIndices",
},
)
class KeyIndicesProperty:
def __init__(
self,
*,
name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
type: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
alias: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
case_sensitive: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
delimiter: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
enable_analytics: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
include_chinese: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
json_key_indices: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union["RosIndex.JsonKeyIndicesProperty", typing.Dict[builtins.str, typing.Any]]]]]] = None,
) -> None:
'''
:param name:
:param type:
:param alias:
:param case_sensitive:
:param delimiter:
:param enable_analytics:
:param include_chinese:
:param json_key_indices:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__bfe03b0f2c5fecef23eff4c706134418d426969d7b16ca2278a2ce16a185e5f5)
check_type(argname="argument name", value=name, expected_type=type_hints["name"])
check_type(argname="argument type", value=type, expected_type=type_hints["type"])
check_type(argname="argument alias", value=alias, expected_type=type_hints["alias"])
check_type(argname="argument case_sensitive", value=case_sensitive, expected_type=type_hints["case_sensitive"])
check_type(argname="argument delimiter", value=delimiter, expected_type=type_hints["delimiter"])
check_type(argname="argument enable_analytics", value=enable_analytics, expected_type=type_hints["enable_analytics"])
check_type(argname="argument include_chinese", value=include_chinese, expected_type=type_hints["include_chinese"])
check_type(argname="argument json_key_indices", value=json_key_indices, expected_type=type_hints["json_key_indices"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"name": name,
"type": type,
}
if alias is not None:
self._values["alias"] = alias
if case_sensitive is not None:
self._values["case_sensitive"] = case_sensitive
if delimiter is not None:
self._values["delimiter"] = delimiter
if enable_analytics is not None:
self._values["enable_analytics"] = enable_analytics
if include_chinese is not None:
self._values["include_chinese"] = include_chinese
if json_key_indices is not None:
self._values["json_key_indices"] = json_key_indices
@builtins.property
def name(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: name: Key name.
'''
result = self._values.get("name")
assert result is not None, "Required property 'name' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def type(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: type: Key type. Allowed types: text, long, double, json. Default to text.
'''
result = self._values.get("type")
assert result is not None, "Required property 'type' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def alias(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: alias: Key alias.
'''
result = self._values.get("alias")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def case_sensitive(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: caseSensitive: Whether it is case sensitive. It takes effect when Type is text or json. Default to false.
'''
result = self._values.get("case_sensitive")
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def delimiter(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:: &<>/:\\n\\t\\r )).
:Property: delimiter: Delimiter. It takes effect when Type is text or json. Default to (( , '";=()[]{}?
'''
result = self._values.get("delimiter")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def enable_analytics(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: enableAnalytics: Whether this key is enabled for statistics. Default to false for json type, else true.
'''
result = self._values.get("enable_analytics")
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def include_chinese(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: includeChinese: Whether it contains Chinese. It takes effect when Type is text or json. Default to false.
'''
result = self._values.get("include_chinese")
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def json_key_indices(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosIndex.JsonKeyIndicesProperty"]]]]:
'''
:Property: jsonKeyIndices: Json key index configurations.
'''
result = self._values.get("json_key_indices")
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosIndex.JsonKeyIndicesProperty"]]]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "KeyIndicesProperty(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-sls.RosIndexProps",
jsii_struct_bases=[],
name_mapping={
"full_text_index": "fullTextIndex",
"logstore_name": "logstoreName",
"project_name": "projectName",
"key_indices": "keyIndices",
"log_reduce": "logReduce",
},
)
class RosIndexProps:
def __init__(
self,
*,
full_text_index: typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union[RosIndex.FullTextIndexProperty, typing.Dict[builtins.str, typing.Any]]],
logstore_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
project_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
key_indices: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union[RosIndex.KeyIndicesProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
log_reduce: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::SLS::Index``.
:param full_text_index:
:param logstore_name:
:param project_name:
:param key_indices:
:param log_reduce:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__61e9320e6265a141ad3fb19c272fe7dbcee64aea49c5aa2626e4a841feaf24a8)
check_type(argname="argument full_text_index", value=full_text_index, expected_type=type_hints["full_text_index"])
check_type(argname="argument logstore_name", value=logstore_name, expected_type=type_hints["logstore_name"])
check_type(argname="argument project_name", value=project_name, expected_type=type_hints["project_name"])
check_type(argname="argument key_indices", value=key_indices, expected_type=type_hints["key_indices"])
check_type(argname="argument log_reduce", value=log_reduce, expected_type=type_hints["log_reduce"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"full_text_index": full_text_index,
"logstore_name": logstore_name,
"project_name": project_name,
}
if key_indices is not None:
self._values["key_indices"] = key_indices
if log_reduce is not None:
self._values["log_reduce"] = log_reduce
@builtins.property
def full_text_index(
self,
) -> typing.Union[_ros_cdk_core_7adfd82f.IResolvable, RosIndex.FullTextIndexProperty]:
'''
:Property:
fullTextIndex: Full-text indexing configuration.
Full-text indexing and key indexing must have at least one enabled.
'''
result = self._values.get("full_text_index")
assert result is not None, "Required property 'full_text_index' is missing"
return typing.cast(typing.Union[_ros_cdk_core_7adfd82f.IResolvable, RosIndex.FullTextIndexProperty], result)
@builtins.property
def logstore_name(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
logstoreName: Logstore name:
1. Only supports lowercase letters, numbers, hyphens (-) and underscores (_).
2. Must start and end with lowercase letters and numbers.
3. The name length is 3-63 characters.
'''
result = self._values.get("logstore_name")
assert result is not None, "Required property 'logstore_name' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def project_name(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
projectName: Project name:
1. Only supports lowercase letters, numbers, hyphens (-) and underscores (_).
2. Must start and end with lowercase letters and numbers.
3. The name length is 3-63 characters.
'''
result = self._values.get("project_name")
assert result is not None, "Required property 'project_name' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def key_indices(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, RosIndex.KeyIndicesProperty]]]]:
'''
:Property:
keyIndices: Key index configurations.
Full-text indexing and key indexing must have at least one enabled.
'''
result = self._values.get("key_indices")
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, RosIndex.KeyIndicesProperty]]]], result)
@builtins.property
def log_reduce(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: logReduce: Whether to enable log reduce. Default to false.
'''
result = self._values.get("log_reduce")
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "RosIndexProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class RosLogstore(
_ros_cdk_core_7adfd82f.RosResource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-sls.RosLogstore",
):
'''A ROS template type: ``ALIYUN::SLS::Logstore``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["RosLogstoreProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
'''Create a new ``ALIYUN::SLS::Logstore``.
:param scope: - scope in which this resource is defined.
:param id: - scoped id of the resource.
:param props: - resource properties.
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__e99911c25ef1771030dc1aff0f4622acd22c72d91b62967fa50502445e9e1daa)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@jsii.member(jsii_name="renderProperties")
def _render_properties(
self,
props: typing.Mapping[builtins.str, typing.Any],
) -> typing.Mapping[builtins.str, typing.Any]:
'''
:param props: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__ca09612fbd1dfb6ce94c68f4b31b1bded3e41747535c836851bef796f56df9c4)
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))
@jsii.python.classproperty
@jsii.member(jsii_name="ROS_RESOURCE_TYPE_NAME")
def ROS_RESOURCE_TYPE_NAME(cls) -> builtins.str:
'''The resource type name for this resource class.'''
return typing.cast(builtins.str, jsii.sget(cls, "ROS_RESOURCE_TYPE_NAME"))
@builtins.property
@jsii.member(jsii_name="attrLogstoreName")
def attr_logstore_name(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: LogstoreName: Logstore name.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrLogstoreName"))
@builtins.property
@jsii.member(jsii_name="rosProperties")
def _ros_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "rosProperties"))
@builtins.property
@jsii.member(jsii_name="enableResourcePropertyConstraint")
def enable_resource_property_constraint(self) -> builtins.bool:
return typing.cast(builtins.bool, jsii.get(self, "enableResourcePropertyConstraint"))
@enable_resource_property_constraint.setter
def enable_resource_property_constraint(self, value: builtins.bool) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__14be6e6178234d789a03b622398e2e0eaf87d9efe1f02684dac49283119aab2d)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "enableResourcePropertyConstraint", value)
@builtins.property
@jsii.member(jsii_name="logstoreName")
def logstore_name(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
logstoreName: Logstore name:
1. Only supports lowercase letters, numbers, hyphens (-) and underscores (_).
2. Must start and end with lowercase letters and numbers.
3. The name length is 3-63 characters.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "logstoreName"))
@logstore_name.setter
def logstore_name(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__f3205ff0bf4813b85ce8caf586d88d9b95deaa5732d8977ac73d8dad4b9e5c28)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "logstoreName", value)
@builtins.property
@jsii.member(jsii_name="projectName")
def project_name(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
projectName: Project name:
1. Only supports lowercase letters, numbers, hyphens (-) and underscores (_).
2. Must start and end with lowercase letters and numbers.
3. The name length is 3-63 characters.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "projectName"))
@project_name.setter
def project_name(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__c24dca99c400b487486acc38e61d30ae7ec5214830dbb65bd3337f17503c5018)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "projectName", value)
@builtins.property
@jsii.member(jsii_name="appendMeta")
def append_meta(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
appendMeta: Whether to add client external network IP and log arrival time after receiving the log.
Default to false.
'''
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "appendMeta"))
@append_meta.setter
def append_meta(
self,
value: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__6b10d2e874bbb32709b515f8358a31b727241714cdd02fa054b1e442a14a39bb)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "appendMeta", value)
@builtins.property
@jsii.member(jsii_name="autoSplit")
def auto_split(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
autoSplit: Whether to automatically split the shard.
Default to false.
'''
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "autoSplit"))
@auto_split.setter
def auto_split(
self,
value: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__dc147794358c6c51ac6aa1d7c1074f4c04d3262317196ea5d5dde593d82dedd3)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "autoSplit", value)
@builtins.property
@jsii.member(jsii_name="enableTracking")
def enable_tracking(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
enableTracking: Whether to enable WebTracking, which supports fast capture of various browsers and iOS/Android/APP access information.
Default to false.
'''
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "enableTracking"))
@enable_tracking.setter
def enable_tracking(
self,
value: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__5e1de55c3c6af4f5945029917237529f54392d50bbe587726e3ca6840d885861)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "enableTracking", value)
@builtins.property
@jsii.member(jsii_name="encryptConf")
def encrypt_conf(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosLogstore.EncryptConfProperty"]]:
'''
:Property: encryptConf: Data encryption config
'''
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosLogstore.EncryptConfProperty"]], jsii.get(self, "encryptConf"))
@encrypt_conf.setter
def encrypt_conf(
self,
value: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosLogstore.EncryptConfProperty"]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__047500645b3f2e3bd6f3df19b1e2d99c848f6e0ddeaaec1485ea51d26d0ae32b)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "encryptConf", value)
@builtins.property
@jsii.member(jsii_name="maxSplitShard")
def max_split_shard(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
maxSplitShard: The maximum number of shards when splitting automatically. Must be specified if AutoSplit is set to true.
Allowed Values: 1-64.
'''
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "maxSplitShard"))
@max_split_shard.setter
def max_split_shard(
self,
value: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__d9f1f593938163ac49aa924abe5ce358144fb41168fcbce43ecb941981086b44)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "maxSplitShard", value)
@builtins.property
@jsii.member(jsii_name="preserveStorage")
def preserve_storage(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
preserveStorage: Whether to keep the log permanently.
If set to true, TTL will be ignored.
Default to false.
'''
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "preserveStorage"))
@preserve_storage.setter
def preserve_storage(
self,
value: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__e01696a95b514f403c6b21a31c83062a1b24103a25b8c2b71af35ab88cfedf69)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "preserveStorage", value)
@builtins.property
@jsii.member(jsii_name="shardCount")
def shard_count(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
shardCount: The number of Shards.
Allowed Values: 1-100, default to 2.
'''
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "shardCount"))
@shard_count.setter
def shard_count(
self,
value: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__d3c5cd42a790ab0c0dac531af4c4a4d54f2cc88ce3f45b01e342a6aa26ebd1bf)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "shardCount", value)
@builtins.property
@jsii.member(jsii_name="ttl")
def ttl(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
ttl: The lifecycle of log in the logstore in days.
Allowed Values: 1-3600, default to 30.
'''
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "ttl"))
@ttl.setter
def ttl(
self,
value: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__929b5c2fd95bd3f831fb38f2913dabd6bd5c794c02f0fc118e338374b4781987)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "ttl", value)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-sls.RosLogstore.EncryptConfProperty",
jsii_struct_bases=[],
name_mapping={
"enable": "enable",
"encrypt_type": "encryptType",
"user_cmk_info": "userCmkInfo",
},
)
class EncryptConfProperty:
def __init__(
self,
*,
enable: typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable],
encrypt_type: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
user_cmk_info: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union["RosLogstore.UserCmkInfoProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
'''
:param enable:
:param encrypt_type:
:param user_cmk_info:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__ae51c1b1297fbcd609b31020090e99e91eedd6d795bdd27e4c53cc18e344dbca)
check_type(argname="argument enable", value=enable, expected_type=type_hints["enable"])
check_type(argname="argument encrypt_type", value=encrypt_type, expected_type=type_hints["encrypt_type"])
check_type(argname="argument user_cmk_info", value=user_cmk_info, expected_type=type_hints["user_cmk_info"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"enable": enable,
"encrypt_type": encrypt_type,
}
if user_cmk_info is not None:
self._values["user_cmk_info"] = user_cmk_info
@builtins.property
def enable(
self,
) -> typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: enable: Specifies whether data encryption is enabled.
'''
result = self._values.get("enable")
assert result is not None, "Required property 'enable' is missing"
return typing.cast(typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def encrypt_type(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
encryptType: The encryption algorithm. The encrypt_type
parameter can be set to only default or m4.
'''
result = self._values.get("encrypt_type")
assert result is not None, "Required property 'encrypt_type' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def user_cmk_info(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosLogstore.UserCmkInfoProperty"]]:
'''
:Property:
userCmkInfo: If this parameter is specified, the BYOK key is used.
Otherwise, the service key is used.
'''
result = self._values.get("user_cmk_info")
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosLogstore.UserCmkInfoProperty"]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "EncryptConfProperty(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-sls.RosLogstore.UserCmkInfoProperty",
jsii_struct_bases=[],
name_mapping={"arn": "arn", "cmk_key_id": "cmkKeyId", "region_id": "regionId"},
)
class UserCmkInfoProperty:
def __init__(
self,
*,
arn: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
cmk_key_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
region_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
'''
:param arn:
:param cmk_key_id:
:param region_id:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__89cfea88e93938bdb7c0d2d2d439b7b999aa37d643de878d5be444b97822a2d6)
check_type(argname="argument arn", value=arn, expected_type=type_hints["arn"])
check_type(argname="argument cmk_key_id", value=cmk_key_id, expected_type=type_hints["cmk_key_id"])
check_type(argname="argument region_id", value=region_id, expected_type=type_hints["region_id"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"arn": arn,
"cmk_key_id": cmk_key_id,
"region_id": region_id,
}
@builtins.property
def arn(self) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
arn: The ARN of the RAM role. For more information
about how to obtain the ARN of a RAM role,
see Ship log data from Log Service to OSS.
'''
result = self._values.get("arn")
assert result is not None, "Required property 'arn' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def cmk_key_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
cmkKeyId: The ID of the CMK to which the BYOK key belongs,
for example, f5136b95-2420-ab31-xxxxxxxxx.
'''
result = self._values.get("cmk_key_id")
assert result is not None, "Required property 'cmk_key_id' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def region_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: regionId: The ID of the region where the CMK resides.
'''
result = self._values.get("region_id")
assert result is not None, "Required property 'region_id' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "UserCmkInfoProperty(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-sls.RosLogstoreProps",
jsii_struct_bases=[],
name_mapping={
"logstore_name": "logstoreName",
"project_name": "projectName",
"append_meta": "appendMeta",
"auto_split": "autoSplit",
"enable_tracking": "enableTracking",
"encrypt_conf": "encryptConf",
"max_split_shard": "maxSplitShard",
"preserve_storage": "preserveStorage",
"shard_count": "shardCount",
"ttl": "ttl",
},
)
class RosLogstoreProps:
def __init__(
self,
*,
logstore_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
project_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
append_meta: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
auto_split: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
enable_tracking: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
encrypt_conf: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union[RosLogstore.EncryptConfProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
max_split_shard: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
preserve_storage: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
shard_count: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
ttl: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::SLS::Logstore``.
:param logstore_name:
:param project_name:
:param append_meta:
:param auto_split:
:param enable_tracking:
:param encrypt_conf:
:param max_split_shard:
:param preserve_storage:
:param shard_count:
:param ttl:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__fc4a4748fe1c43946564ba15ce1137dc87e445eaf58614d72a09430b459eaa25)
check_type(argname="argument logstore_name", value=logstore_name, expected_type=type_hints["logstore_name"])
check_type(argname="argument project_name", value=project_name, expected_type=type_hints["project_name"])
check_type(argname="argument append_meta", value=append_meta, expected_type=type_hints["append_meta"])
check_type(argname="argument auto_split", value=auto_split, expected_type=type_hints["auto_split"])
check_type(argname="argument enable_tracking", value=enable_tracking, expected_type=type_hints["enable_tracking"])
check_type(argname="argument encrypt_conf", value=encrypt_conf, expected_type=type_hints["encrypt_conf"])
check_type(argname="argument max_split_shard", value=max_split_shard, expected_type=type_hints["max_split_shard"])
check_type(argname="argument preserve_storage", value=preserve_storage, expected_type=type_hints["preserve_storage"])
check_type(argname="argument shard_count", value=shard_count, expected_type=type_hints["shard_count"])
check_type(argname="argument ttl", value=ttl, expected_type=type_hints["ttl"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"logstore_name": logstore_name,
"project_name": project_name,
}
if append_meta is not None:
self._values["append_meta"] = append_meta
if auto_split is not None:
self._values["auto_split"] = auto_split
if enable_tracking is not None:
self._values["enable_tracking"] = enable_tracking
if encrypt_conf is not None:
self._values["encrypt_conf"] = encrypt_conf
if max_split_shard is not None:
self._values["max_split_shard"] = max_split_shard
if preserve_storage is not None:
self._values["preserve_storage"] = preserve_storage
if shard_count is not None:
self._values["shard_count"] = shard_count
if ttl is not None:
self._values["ttl"] = ttl
@builtins.property
def logstore_name(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
logstoreName: Logstore name:
1. Only supports lowercase letters, numbers, hyphens (-) and underscores (_).
2. Must start and end with lowercase letters and numbers.
3. The name length is 3-63 characters.
'''
result = self._values.get("logstore_name")
assert result is not None, "Required property 'logstore_name' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def project_name(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
projectName: Project name:
1. Only supports lowercase letters, numbers, hyphens (-) and underscores (_).
2. Must start and end with lowercase letters and numbers.
3. The name length is 3-63 characters.
'''
result = self._values.get("project_name")
assert result is not None, "Required property 'project_name' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def append_meta(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
appendMeta: Whether to add client external network IP and log arrival time after receiving the log.
Default to false.
'''
result = self._values.get("append_meta")
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def auto_split(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
autoSplit: Whether to automatically split the shard.
Default to false.
'''
result = self._values.get("auto_split")
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def enable_tracking(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
enableTracking: Whether to enable WebTracking, which supports fast capture of various browsers and iOS/Android/APP access information.
Default to false.
'''
result = self._values.get("enable_tracking")
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def encrypt_conf(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, RosLogstore.EncryptConfProperty]]:
'''
:Property: encryptConf: Data encryption config
'''
result = self._values.get("encrypt_conf")
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, RosLogstore.EncryptConfProperty]], result)
@builtins.property
def max_split_shard(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
maxSplitShard: The maximum number of shards when splitting automatically. Must be specified if AutoSplit is set to true.
Allowed Values: 1-64.
'''
result = self._values.get("max_split_shard")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def preserve_storage(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
preserveStorage: Whether to keep the log permanently.
If set to true, TTL will be ignored.
Default to false.
'''
result = self._values.get("preserve_storage")
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def shard_count(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
shardCount: The number of Shards.
Allowed Values: 1-100, default to 2.
'''
result = self._values.get("shard_count")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def ttl(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
ttl: The lifecycle of log in the logstore in days.
Allowed Values: 1-3600, default to 30.
'''
result = self._values.get("ttl")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "RosLogstoreProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class RosLogtailConfig(
_ros_cdk_core_7adfd82f.RosResource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-sls.RosLogtailConfig",
):
'''A ROS template type: ``ALIYUN::SLS::LogtailConfig``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["RosLogtailConfigProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
'''Create a new ``ALIYUN::SLS::LogtailConfig``.
:param scope: - scope in which this resource is defined.
:param id: - scoped id of the resource.
:param props: - resource properties.
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__575fec4ea1be80faa42157f7d7b3093633a76abde41983322c5b96de52d32d2e)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@jsii.member(jsii_name="renderProperties")
def _render_properties(
self,
props: typing.Mapping[builtins.str, typing.Any],
) -> typing.Mapping[builtins.str, typing.Any]:
'''
:param props: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__cd20e01bfc8fafd3d9ef0862e32ea2b942dfc68850bf99f291266b9c1ddf3b73)
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))
@jsii.python.classproperty
@jsii.member(jsii_name="ROS_RESOURCE_TYPE_NAME")
def ROS_RESOURCE_TYPE_NAME(cls) -> builtins.str:
'''The resource type name for this resource class.'''
return typing.cast(builtins.str, jsii.sget(cls, "ROS_RESOURCE_TYPE_NAME"))
@builtins.property
@jsii.member(jsii_name="attrAppliedMachineGroups")
def attr_applied_machine_groups(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: AppliedMachineGroups: Applied machine groups.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrAppliedMachineGroups"))
@builtins.property
@jsii.member(jsii_name="attrEndpoint")
def attr_endpoint(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: Endpoint: Endpoint address.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrEndpoint"))
@builtins.property
@jsii.member(jsii_name="attrLogtailConfigName")
def attr_logtail_config_name(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: LogtailConfigName: Logtail config name.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrLogtailConfigName"))
@builtins.property
@jsii.member(jsii_name="rosProperties")
def _ros_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "rosProperties"))
@builtins.property
@jsii.member(jsii_name="enableResourcePropertyConstraint")
def enable_resource_property_constraint(self) -> builtins.bool:
return typing.cast(builtins.bool, jsii.get(self, "enableResourcePropertyConstraint"))
@enable_resource_property_constraint.setter
def enable_resource_property_constraint(self, value: builtins.bool) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__ffdd50dd56ad6630720b6e1e78b901edf9fd66a198cd451aa191c330de151f27)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "enableResourcePropertyConstraint", value)
@builtins.property
@jsii.member(jsii_name="logstoreName")
def logstore_name(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
logstoreName: Logstore name:
1. Only supports lowercase letters, numbers, hyphens (-) and underscores (_).
2. Must start and end with lowercase letters and numbers.
3. The name length is 3-63 characters.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "logstoreName"))
@logstore_name.setter
def logstore_name(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__9e0d43703eba35b9974f8ba13a49fcab9ac3ae87f9fcd64eace9d2bb1ead7308)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "logstoreName", value)
@builtins.property
@jsii.member(jsii_name="logtailConfigName")
def logtail_config_name(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
logtailConfigName: Logtail config name:
1. Only supports lowercase letters, numbers, hyphens (-) and underscores (_).
2. Must start and end with lowercase letters and numbers.
3. The name length is 3-63 characters.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "logtailConfigName"))
@logtail_config_name.setter
def logtail_config_name(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__7ffaa0a6a0821b6dc58b230f81bb91e403e31dfff4f523a402e6badf6f91a84d)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "logtailConfigName", value)
@builtins.property
@jsii.member(jsii_name="projectName")
def project_name(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
projectName: Project name:
1. Only supports lowercase letters, numbers, hyphens (-) and underscores (_).
2. Must start and end with lowercase letters and numbers.
3. The name length is 3-63 characters.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "projectName"))
@project_name.setter
def project_name(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__590d9229743075c4733038a888fe2fa8e51d03916378e60a3ba509cec4905c7b)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "projectName", value)
@builtins.property
@jsii.member(jsii_name="cloneFrom")
def clone_from(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosLogtailConfig.CloneFromProperty"]]:
'''
:Property:
cloneFrom: Clone logtail config data from existing logtail config.
Either CloneFrom or RawConfigData must be specified. If CloneFrom and RawConfigData are both specified, logtail config data will be merged from both with RawConfigData first.
'''
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosLogtailConfig.CloneFromProperty"]], jsii.get(self, "cloneFrom"))
@clone_from.setter
def clone_from(
self,
value: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosLogtailConfig.CloneFromProperty"]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__5ec9f6e431392df03d37d1080860050758a7a6a1ad0bf9c990d5eced75808a06)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "cloneFrom", value)
@builtins.property
@jsii.member(jsii_name="rawConfigData")
def raw_config_data(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]]:
'''
:Property:
rawConfigData: The format is the same as the response of SLS API GetConfig.
Either CloneFrom or RawConfigData must be specified. If CloneFrom and RawConfigData are both specified, logtail config data will be merged from both with RawConfigData first.
configName, outputType, outputDetail in data will be ignored.For example:
{
"configName": "test-logtail-config",
"createTime": 1574843554,
"inputDetail": {
"acceptNoEnoughKeys": false,
"adjustTimezone": false,
"advanced": {
"force_multiconfig": false
},
"autoExtend": true,
"delayAlarmBytes": 0,
"delaySkipBytes": 0,
"discardNonUtf8": false,
"discardUnmatch": false,
"dockerExcludeEnv": {},
"dockerExcludeLabel": {},
"dockerFile": false,
"dockerIncludeEnv": {},
"dockerIncludeLabel": {},
"enableRawLog": false,
"enableTag": false,
"fileEncoding": "utf8",
"filePattern": "test.log*",
"filterKey": [],
"filterRegex": [],
"key": [
"time",
"logger",
"level",
"request_id",
"user_id",
"region_id",
"content"
],
"localStorage": true,
"logPath": "/var/log/test",
"logTimezone": "",
"logType": "delimiter_log",
"maxDepth": 100,
"maxSendRate": -1,
"mergeType": "topic",
"preserve": true,
"preserveDepth": 1,
"priority": 0,
"quote": "\\u0001",
"sendRateExpire": 0,
"sensitive_keys": [],
"separator": ",,,",
"shardHashKey": [],
"tailExisted": false,
"timeFormat": "",
"timeKey": "",
"topicFormat": "none"
},
"inputType": "file",
"lastModifyTime": 1574843554,
"logSample": "2019-11-27 10:48:23,160,,,MAIN,,,INFO,,,98DCC51D-BE5D-49C7-B3FD-37B2BAEFB296,,,123456789,,,cn-hangzhou,,,this is a simple test.",
"outputDetail": {
"endpoint": "cn-hangzhou-intranet.log.aliyuncs.com",
"logstoreName": "test-logstore",
"region": "cn-hangzhou"
},
"outputType": "LogService"
}
'''
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]], jsii.get(self, "rawConfigData"))
@raw_config_data.setter
def raw_config_data(
self,
value: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__e92dd84454d18182ce5e90a291f1a400193d965f8abe0aed4ae8b6bbc6c3147c)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "rawConfigData", value)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-sls.RosLogtailConfig.CloneFromProperty",
jsii_struct_bases=[],
name_mapping={
"logtail_config_name": "logtailConfigName",
"project_name": "projectName",
},
)
class CloneFromProperty:
def __init__(
self,
*,
logtail_config_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
project_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
'''
:param logtail_config_name:
:param project_name:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__bd4c3d39edca26d97f75583f415b7fd36790ab2630c2fd89da5aa92326dfb58a)
check_type(argname="argument logtail_config_name", value=logtail_config_name, expected_type=type_hints["logtail_config_name"])
check_type(argname="argument project_name", value=project_name, expected_type=type_hints["project_name"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"logtail_config_name": logtail_config_name,
"project_name": project_name,
}
@builtins.property
def logtail_config_name(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
logtailConfigName: Logtail config name:
1. Only supports lowercase letters, numbers, hyphens (-) and underscores (_).
2. Must start and end with lowercase letters and numbers.
3. The name length is 3-63 characters.
'''
result = self._values.get("logtail_config_name")
assert result is not None, "Required property 'logtail_config_name' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def project_name(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
projectName: Project name:
1. Only supports lowercase letters, numbers, hyphens (-) and underscores (_).
2. Must start and end with lowercase letters and numbers.
3. The name length is 3-63 characters.
'''
result = self._values.get("project_name")
assert result is not None, "Required property 'project_name' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "CloneFromProperty(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-sls.RosLogtailConfigProps",
jsii_struct_bases=[],
name_mapping={
"logstore_name": "logstoreName",
"logtail_config_name": "logtailConfigName",
"project_name": "projectName",
"clone_from": "cloneFrom",
"raw_config_data": "rawConfigData",
},
)
class RosLogtailConfigProps:
def __init__(
self,
*,
logstore_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
logtail_config_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
project_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
clone_from: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union[RosLogtailConfig.CloneFromProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
raw_config_data: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::SLS::LogtailConfig``.
:param logstore_name:
:param logtail_config_name:
:param project_name:
:param clone_from:
:param raw_config_data:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__25087996a9532cdffeaa27214286e1df397df759a1757848ad254cac7bf2da39)
check_type(argname="argument logstore_name", value=logstore_name, expected_type=type_hints["logstore_name"])
check_type(argname="argument logtail_config_name", value=logtail_config_name, expected_type=type_hints["logtail_config_name"])
check_type(argname="argument project_name", value=project_name, expected_type=type_hints["project_name"])
check_type(argname="argument clone_from", value=clone_from, expected_type=type_hints["clone_from"])
check_type(argname="argument raw_config_data", value=raw_config_data, expected_type=type_hints["raw_config_data"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"logstore_name": logstore_name,
"logtail_config_name": logtail_config_name,
"project_name": project_name,
}
if clone_from is not None:
self._values["clone_from"] = clone_from
if raw_config_data is not None:
self._values["raw_config_data"] = raw_config_data
@builtins.property
def logstore_name(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
logstoreName: Logstore name:
1. Only supports lowercase letters, numbers, hyphens (-) and underscores (_).
2. Must start and end with lowercase letters and numbers.
3. The name length is 3-63 characters.
'''
result = self._values.get("logstore_name")
assert result is not None, "Required property 'logstore_name' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def logtail_config_name(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
logtailConfigName: Logtail config name:
1. Only supports lowercase letters, numbers, hyphens (-) and underscores (_).
2. Must start and end with lowercase letters and numbers.
3. The name length is 3-63 characters.
'''
result = self._values.get("logtail_config_name")
assert result is not None, "Required property 'logtail_config_name' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def project_name(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
projectName: Project name:
1. Only supports lowercase letters, numbers, hyphens (-) and underscores (_).
2. Must start and end with lowercase letters and numbers.
3. The name length is 3-63 characters.
'''
result = self._values.get("project_name")
assert result is not None, "Required property 'project_name' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def clone_from(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, RosLogtailConfig.CloneFromProperty]]:
'''
:Property:
cloneFrom: Clone logtail config data from existing logtail config.
Either CloneFrom or RawConfigData must be specified. If CloneFrom and RawConfigData are both specified, logtail config data will be merged from both with RawConfigData first.
'''
result = self._values.get("clone_from")
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, RosLogtailConfig.CloneFromProperty]], result)
@builtins.property
def raw_config_data(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]]:
'''
:Property:
rawConfigData: The format is the same as the response of SLS API GetConfig.
Either CloneFrom or RawConfigData must be specified. If CloneFrom and RawConfigData are both specified, logtail config data will be merged from both with RawConfigData first.
configName, outputType, outputDetail in data will be ignored.For example:
{
"configName": "test-logtail-config",
"createTime": 1574843554,
"inputDetail": {
"acceptNoEnoughKeys": false,
"adjustTimezone": false,
"advanced": {
"force_multiconfig": false
},
"autoExtend": true,
"delayAlarmBytes": 0,
"delaySkipBytes": 0,
"discardNonUtf8": false,
"discardUnmatch": false,
"dockerExcludeEnv": {},
"dockerExcludeLabel": {},
"dockerFile": false,
"dockerIncludeEnv": {},
"dockerIncludeLabel": {},
"enableRawLog": false,
"enableTag": false,
"fileEncoding": "utf8",
"filePattern": "test.log*",
"filterKey": [],
"filterRegex": [],
"key": [
"time",
"logger",
"level",
"request_id",
"user_id",
"region_id",
"content"
],
"localStorage": true,
"logPath": "/var/log/test",
"logTimezone": "",
"logType": "delimiter_log",
"maxDepth": 100,
"maxSendRate": -1,
"mergeType": "topic",
"preserve": true,
"preserveDepth": 1,
"priority": 0,
"quote": "\\u0001",
"sendRateExpire": 0,
"sensitive_keys": [],
"separator": ",,,",
"shardHashKey": [],
"tailExisted": false,
"timeFormat": "",
"timeKey": "",
"topicFormat": "none"
},
"inputType": "file",
"lastModifyTime": 1574843554,
"logSample": "2019-11-27 10:48:23,160,,,MAIN,,,INFO,,,98DCC51D-BE5D-49C7-B3FD-37B2BAEFB296,,,123456789,,,cn-hangzhou,,,this is a simple test.",
"outputDetail": {
"endpoint": "cn-hangzhou-intranet.log.aliyuncs.com",
"logstoreName": "test-logstore",
"region": "cn-hangzhou"
},
"outputType": "LogService"
}
'''
result = self._values.get("raw_config_data")
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "RosLogtailConfigProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class RosMachineGroup(
_ros_cdk_core_7adfd82f.RosResource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-sls.RosMachineGroup",
):
'''A ROS template type: ``ALIYUN::SLS::MachineGroup``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["RosMachineGroupProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
'''Create a new ``ALIYUN::SLS::MachineGroup``.
:param scope: - scope in which this resource is defined.
:param id: - scoped id of the resource.
:param props: - resource properties.
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__6a42b2eab7a43080f80c9908f46208e45e112912f1f3385791472173f57e8dbb)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@jsii.member(jsii_name="renderProperties")
def _render_properties(
self,
props: typing.Mapping[builtins.str, typing.Any],
) -> typing.Mapping[builtins.str, typing.Any]:
'''
:param props: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__7f9451afe70285e91b7c4676ad7a92580ee42afd3fa5d1c377d5d1cf5d5e5695)
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))
@jsii.python.classproperty
@jsii.member(jsii_name="ROS_RESOURCE_TYPE_NAME")
def ROS_RESOURCE_TYPE_NAME(cls) -> builtins.str:
'''The resource type name for this resource class.'''
return typing.cast(builtins.str, jsii.sget(cls, "ROS_RESOURCE_TYPE_NAME"))
@builtins.property
@jsii.member(jsii_name="attrGroupName")
def attr_group_name(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: GroupName: GroupName of SLS.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrGroupName"))
@builtins.property
@jsii.member(jsii_name="attrProjectName")
def attr_project_name(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: ProjectName: ProjectName of SLS.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrProjectName"))
@builtins.property
@jsii.member(jsii_name="rosProperties")
def _ros_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "rosProperties"))
@builtins.property
@jsii.member(jsii_name="enableResourcePropertyConstraint")
def enable_resource_property_constraint(self) -> builtins.bool:
return typing.cast(builtins.bool, jsii.get(self, "enableResourcePropertyConstraint"))
@enable_resource_property_constraint.setter
def enable_resource_property_constraint(self, value: builtins.bool) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__191cdef9c79284db9e62826a25fe4229f5db0b87ccb1ec4b8a599c475e350130)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "enableResourcePropertyConstraint", value)
@builtins.property
@jsii.member(jsii_name="groupAttribute")
def group_attribute(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: groupAttribute: Group attribute, default is null. The object value is groupToic and externalName
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "groupAttribute"))
@group_attribute.setter
def group_attribute(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__dbcd9d6c08c05685f10ba2c33faa1fad8d60203f4158289a2dcd092af2455688)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "groupAttribute", value)
@builtins.property
@jsii.member(jsii_name="groupName")
def group_name(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: groupName: Display name of the group name, the Project only. [2, 128] English or Chinese characters, must start with a letter or Chinese in size, can contain numbers, '_' or '.', '-'
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "groupName"))
@group_name.setter
def group_name(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__a20e5e4f569064875d96d43eb1bdcc7d0f5c53d0260467eff1d7d1518a9450d0)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "groupName", value)
@builtins.property
@jsii.member(jsii_name="groupType")
def group_type(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: groupType: MachineGroup type, the value is empty or Armory
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "groupType"))
@group_type.setter
def group_type(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__097cf54e1bfa9aa585ca89c8278c59b7713d7fac9c54e4f6dc91ca5c88e2c1b0)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "groupType", value)
@builtins.property
@jsii.member(jsii_name="machineIdentifyType")
def machine_identify_type(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: machineIdentifyType: Machine indentify type, the value is 'ip' or 'userdefined'
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "machineIdentifyType"))
@machine_identify_type.setter
def machine_identify_type(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__f2d2ada03e20b922d7af0991c424ec372a87aa9f3a32cab6b08e1171c0a86e07)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "machineIdentifyType", value)
@builtins.property
@jsii.member(jsii_name="machineList")
def machine_list(
self,
) -> typing.Optional[typing.Union[typing.List[typing.Any], _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: machineList: The machine tag, the value is ip or userdefined-id.
'''
return typing.cast(typing.Optional[typing.Union[typing.List[typing.Any], _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "machineList"))
@machine_list.setter
def machine_list(
self,
value: typing.Optional[typing.Union[typing.List[typing.Any], _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__34bc65b21c8bbb7d82df291218b293f229090fab039191b5cab300b966323345)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "machineList", value)
@builtins.property
@jsii.member(jsii_name="projectName")
def project_name(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: projectName: MachineGroup created in project.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "projectName"))
@project_name.setter
def project_name(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__8bda85b8de49bb54c758eac251b9c0988d269fc90fa73de41eed1a53638f410a)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "projectName", value)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-sls.RosMachineGroupProps",
jsii_struct_bases=[],
name_mapping={
"group_attribute": "groupAttribute",
"group_name": "groupName",
"group_type": "groupType",
"machine_identify_type": "machineIdentifyType",
"machine_list": "machineList",
"project_name": "projectName",
},
)
class RosMachineGroupProps:
def __init__(
self,
*,
group_attribute: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
group_name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
group_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
machine_identify_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
machine_list: typing.Optional[typing.Union[typing.Sequence[typing.Any], _ros_cdk_core_7adfd82f.IResolvable]] = None,
project_name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::SLS::MachineGroup``.
:param group_attribute:
:param group_name:
:param group_type:
:param machine_identify_type:
:param machine_list:
:param project_name:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__885aeb7c14b65270b96554da6f93ec97bace9e50aa88e9e316d540661d983a65)
check_type(argname="argument group_attribute", value=group_attribute, expected_type=type_hints["group_attribute"])
check_type(argname="argument group_name", value=group_name, expected_type=type_hints["group_name"])
check_type(argname="argument group_type", value=group_type, expected_type=type_hints["group_type"])
check_type(argname="argument machine_identify_type", value=machine_identify_type, expected_type=type_hints["machine_identify_type"])
check_type(argname="argument machine_list", value=machine_list, expected_type=type_hints["machine_list"])
check_type(argname="argument project_name", value=project_name, expected_type=type_hints["project_name"])
self._values: typing.Dict[builtins.str, typing.Any] = {}
if group_attribute is not None:
self._values["group_attribute"] = group_attribute
if group_name is not None:
self._values["group_name"] = group_name
if group_type is not None:
self._values["group_type"] = group_type
if machine_identify_type is not None:
self._values["machine_identify_type"] = machine_identify_type
if machine_list is not None:
self._values["machine_list"] = machine_list
if project_name is not None:
self._values["project_name"] = project_name
@builtins.property
def group_attribute(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: groupAttribute: Group attribute, default is null. The object value is groupToic and externalName
'''
result = self._values.get("group_attribute")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def group_name(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: groupName: Display name of the group name, the Project only. [2, 128] English or Chinese characters, must start with a letter or Chinese in size, can contain numbers, '_' or '.', '-'
'''
result = self._values.get("group_name")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def group_type(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: groupType: MachineGroup type, the value is empty or Armory
'''
result = self._values.get("group_type")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def machine_identify_type(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: machineIdentifyType: Machine indentify type, the value is 'ip' or 'userdefined'
'''
result = self._values.get("machine_identify_type")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def machine_list(
self,
) -> typing.Optional[typing.Union[typing.List[typing.Any], _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: machineList: The machine tag, the value is ip or userdefined-id.
'''
result = self._values.get("machine_list")
return typing.cast(typing.Optional[typing.Union[typing.List[typing.Any], _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def project_name(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: projectName: MachineGroup created in project.
'''
result = self._values.get("project_name")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "RosMachineGroupProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class RosMetricStore(
_ros_cdk_core_7adfd82f.RosResource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-sls.RosMetricStore",
):
'''A ROS template type: ``ALIYUN::SLS::MetricStore``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["RosMetricStoreProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
'''Create a new ``ALIYUN::SLS::MetricStore``.
:param scope: - scope in which this resource is defined.
:param id: - scoped id of the resource.
:param props: - resource properties.
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__1fddef050da68afb68b22771ca25cd858e8927bacb6fc4c39a3d3d078db07a8f)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@jsii.member(jsii_name="renderProperties")
def _render_properties(
self,
props: typing.Mapping[builtins.str, typing.Any],
) -> typing.Mapping[builtins.str, typing.Any]:
'''
:param props: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__a9e91cdc2567a239becec870c41e56bbc6918cebaa2832385d1871e60f60aa4e)
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))
@jsii.python.classproperty
@jsii.member(jsii_name="ROS_RESOURCE_TYPE_NAME")
def ROS_RESOURCE_TYPE_NAME(cls) -> builtins.str:
'''The resource type name for this resource class.'''
return typing.cast(builtins.str, jsii.sget(cls, "ROS_RESOURCE_TYPE_NAME"))
@builtins.property
@jsii.member(jsii_name="attrLogstoreName")
def attr_logstore_name(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: LogstoreName: Metric store name.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrLogstoreName"))
@builtins.property
@jsii.member(jsii_name="rosProperties")
def _ros_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "rosProperties"))
@builtins.property
@jsii.member(jsii_name="enableResourcePropertyConstraint")
def enable_resource_property_constraint(self) -> builtins.bool:
return typing.cast(builtins.bool, jsii.get(self, "enableResourcePropertyConstraint"))
@enable_resource_property_constraint.setter
def enable_resource_property_constraint(self, value: builtins.bool) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__db4efdbe966d4dc5e514607d183d9a0c3d5caede43ce41faab4c9263bc9b2483)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "enableResourcePropertyConstraint", value)
@builtins.property
@jsii.member(jsii_name="logstoreName")
def logstore_name(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
logstoreName: Metric store name:
1. Only supports lowercase letters, numbers, hyphens (-) and underscores (_).
2. Must start and end with lowercase letters and numbers.
3. The name length is 3-63 characters.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "logstoreName"))
@logstore_name.setter
def logstore_name(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__c528355f24501c7d849ddc151f2aea435743eb479f1bc73959f42913238e00e2)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "logstoreName", value)
@builtins.property
@jsii.member(jsii_name="projectName")
def project_name(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
projectName: Project name:
1. Only supports lowercase letters, numbers, hyphens (-) and underscores (_).
2. Must start and end with lowercase letters and numbers.
3. The name length is 3-63 characters.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "projectName"))
@project_name.setter
def project_name(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__79d73d74a7f726d08fdb3e14b3779123666ba8c822da3886de5906b78c44053a)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "projectName", value)
@builtins.property
@jsii.member(jsii_name="preserveStorage")
def preserve_storage(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
preserveStorage: Whether to keep the log permanently.
If set to true, TTL will be ignored.
Default to false.
'''
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "preserveStorage"))
@preserve_storage.setter
def preserve_storage(
self,
value: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__4489138315151e5ccc92958a670d850b5e0cff5b3d34ba6212f6321b747ef1b3)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "preserveStorage", value)
@builtins.property
@jsii.member(jsii_name="shardCount")
def shard_count(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
shardCount: The number of Shards.
Allowed Values: 1-10, default to 2.
'''
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "shardCount"))
@shard_count.setter
def shard_count(
self,
value: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__fa964e589700e8f21cacf38ca48de0dc419be0996952e7a6a3f616753ccbe56f)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "shardCount", value)
@builtins.property
@jsii.member(jsii_name="ttl")
def ttl(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
ttl: The lifecycle of log in the metrice store in days.
Allowed Values: 1-3000, default to 30.
'''
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "ttl"))
@ttl.setter
def ttl(
self,
value: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__f8e94b098142b0de758fb4a71f509b9dda865ccdfc467aa64f9a3fa729379371)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "ttl", value)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-sls.RosMetricStoreProps",
jsii_struct_bases=[],
name_mapping={
"logstore_name": "logstoreName",
"project_name": "projectName",
"preserve_storage": "preserveStorage",
"shard_count": "shardCount",
"ttl": "ttl",
},
)
class RosMetricStoreProps:
def __init__(
self,
*,
logstore_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
project_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
preserve_storage: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
shard_count: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
ttl: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::SLS::MetricStore``.
:param logstore_name:
:param project_name:
:param preserve_storage:
:param shard_count:
:param ttl:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__3e37eb04ea66385b49a63e0c05eff511770563a72306240e160632f2f28ef914)
check_type(argname="argument logstore_name", value=logstore_name, expected_type=type_hints["logstore_name"])
check_type(argname="argument project_name", value=project_name, expected_type=type_hints["project_name"])
check_type(argname="argument preserve_storage", value=preserve_storage, expected_type=type_hints["preserve_storage"])
check_type(argname="argument shard_count", value=shard_count, expected_type=type_hints["shard_count"])
check_type(argname="argument ttl", value=ttl, expected_type=type_hints["ttl"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"logstore_name": logstore_name,
"project_name": project_name,
}
if preserve_storage is not None:
self._values["preserve_storage"] = preserve_storage
if shard_count is not None:
self._values["shard_count"] = shard_count
if ttl is not None:
self._values["ttl"] = ttl
@builtins.property
def logstore_name(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
logstoreName: Metric store name:
1. Only supports lowercase letters, numbers, hyphens (-) and underscores (_).
2. Must start and end with lowercase letters and numbers.
3. The name length is 3-63 characters.
'''
result = self._values.get("logstore_name")
assert result is not None, "Required property 'logstore_name' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def project_name(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
projectName: Project name:
1. Only supports lowercase letters, numbers, hyphens (-) and underscores (_).
2. Must start and end with lowercase letters and numbers.
3. The name length is 3-63 characters.
'''
result = self._values.get("project_name")
assert result is not None, "Required property 'project_name' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def preserve_storage(
self,
) -> typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
preserveStorage: Whether to keep the log permanently.
If set to true, TTL will be ignored.
Default to false.
'''
result = self._values.get("preserve_storage")
return typing.cast(typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def shard_count(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
shardCount: The number of Shards.
Allowed Values: 1-10, default to 2.
'''
result = self._values.get("shard_count")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def ttl(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
ttl: The lifecycle of log in the metrice store in days.
Allowed Values: 1-3000, default to 30.
'''
result = self._values.get("ttl")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "RosMetricStoreProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class RosProject(
_ros_cdk_core_7adfd82f.RosResource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-sls.RosProject",
):
'''A ROS template type: ``ALIYUN::SLS::Project``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["RosProjectProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
'''Create a new ``ALIYUN::SLS::Project``.
:param scope: - scope in which this resource is defined.
:param id: - scoped id of the resource.
:param props: - resource properties.
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__38a7af9ea5b5e764f37121b3cf403526a1b4c66420c7ffe80556610eb94b0a84)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@jsii.member(jsii_name="renderProperties")
def _render_properties(
self,
props: typing.Mapping[builtins.str, typing.Any],
) -> typing.Mapping[builtins.str, typing.Any]:
'''
:param props: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__1641ef3b0f008269d7cb1f8ccf79d180e6e1852ace6ec26ff20ecedb3f9211e6)
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))
@jsii.python.classproperty
@jsii.member(jsii_name="ROS_RESOURCE_TYPE_NAME")
def ROS_RESOURCE_TYPE_NAME(cls) -> builtins.str:
'''The resource type name for this resource class.'''
return typing.cast(builtins.str, jsii.sget(cls, "ROS_RESOURCE_TYPE_NAME"))
@builtins.property
@jsii.member(jsii_name="attrName")
def attr_name(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: Name: Project name.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrName"))
@builtins.property
@jsii.member(jsii_name="rosProperties")
def _ros_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "rosProperties"))
@builtins.property
@jsii.member(jsii_name="enableResourcePropertyConstraint")
def enable_resource_property_constraint(self) -> builtins.bool:
return typing.cast(builtins.bool, jsii.get(self, "enableResourcePropertyConstraint"))
@enable_resource_property_constraint.setter
def enable_resource_property_constraint(self, value: builtins.bool) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__6c029aa59f998b498df772c9774bc3430dc84a3a13158252d7ad7148b90b03ce)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "enableResourcePropertyConstraint", value)
@builtins.property
@jsii.member(jsii_name="name")
def name(self) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
name: Project name:
1. Only supports lowercase letters, numbers, hyphens (-) and underscores (_).
2. Must start and end with lowercase letters and numbers.
3. The name length is 3-63 characters.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "name"))
@name.setter
def name(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__fb8e142c132b888d5c4654d9eb94dc54768a0e63c44f4e76c074cbc180e5b4b9)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "name", value)
@builtins.property
@jsii.member(jsii_name="description")
def description(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: description: Project description: <>'"\\ is not supported, up to 64 characters.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "description"))
@description.setter
def description(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__26f055a2c2f4717089f86145879345e33573886f27696c8af3de79916d58bef4)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "description", value)
@builtins.property
@jsii.member(jsii_name="tags")
def tags(self) -> typing.Optional[typing.List["RosProject.TagsProperty"]]:
'''
:Property: tags: Tags to attach to project. Max support 20 tags to add during create project. Each tag with two properties Key and Value, and Key is required.
'''
return typing.cast(typing.Optional[typing.List["RosProject.TagsProperty"]], jsii.get(self, "tags"))
@tags.setter
def tags(
self,
value: typing.Optional[typing.List["RosProject.TagsProperty"]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__d6a59f8bd6ba8a6d93d290f3c4b11c612773d74d83efba92159a8e4a30881df7)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "tags", value)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-sls.RosProject.TagsProperty",
jsii_struct_bases=[],
name_mapping={"key": "key", "value": "value"},
)
class TagsProperty:
def __init__(
self,
*,
key: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''
:param key:
:param value:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__a72e6dcd789c2dcaa2d07ca250a132f64d678c64115e8f4b55c76eb1514f9857)
check_type(argname="argument key", value=key, expected_type=type_hints["key"])
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"key": key,
}
if value is not None:
self._values["value"] = value
@builtins.property
def key(self) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: key: undefined
'''
result = self._values.get("key")
assert result is not None, "Required property 'key' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def value(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: value: undefined
'''
result = self._values.get("value")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "TagsProperty(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-sls.RosProjectProps",
jsii_struct_bases=[],
name_mapping={"name": "name", "description": "description", "tags": "tags"},
)
class RosProjectProps:
def __init__(
self,
*,
name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
description: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
tags: typing.Optional[typing.Sequence[typing.Union[RosProject.TagsProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::SLS::Project``.
:param name:
:param description:
:param tags:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__3784af050a0cb65f900ea3b984feccd3c0a8f0f3db206be5c1e9d19d884b8593)
check_type(argname="argument name", value=name, expected_type=type_hints["name"])
check_type(argname="argument description", value=description, expected_type=type_hints["description"])
check_type(argname="argument tags", value=tags, expected_type=type_hints["tags"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"name": name,
}
if description is not None:
self._values["description"] = description
if tags is not None:
self._values["tags"] = tags
@builtins.property
def name(self) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
name: Project name:
1. Only supports lowercase letters, numbers, hyphens (-) and underscores (_).
2. Must start and end with lowercase letters and numbers.
3. The name length is 3-63 characters.
'''
result = self._values.get("name")
assert result is not None, "Required property 'name' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def description(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: description: Project description: <>'"\\ is not supported, up to 64 characters.
'''
result = self._values.get("description")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def tags(self) -> typing.Optional[typing.List[RosProject.TagsProperty]]:
'''
:Property: tags: Tags to attach to project. Max support 20 tags to add during create project. Each tag with two properties Key and Value, and Key is required.
'''
result = self._values.get("tags")
return typing.cast(typing.Optional[typing.List[RosProject.TagsProperty]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "RosProjectProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class RosSavedsearch(
_ros_cdk_core_7adfd82f.RosResource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-sls.RosSavedsearch",
):
'''A ROS template type: ``ALIYUN::SLS::Savedsearch``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["RosSavedsearchProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
'''Create a new ``ALIYUN::SLS::Savedsearch``.
:param scope: - scope in which this resource is defined.
:param id: - scoped id of the resource.
:param props: - resource properties.
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__63cdff2941d2aaa0d3b23c7fabd077a489003541fce47432b25840ad2a14d8d4)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@jsii.member(jsii_name="renderProperties")
def _render_properties(
self,
props: typing.Mapping[builtins.str, typing.Any],
) -> typing.Mapping[builtins.str, typing.Any]:
'''
:param props: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__077eb76bb7d0d0917657a66a47111e98ce71cc38cd7e5d6307fed8a926aaa871)
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))
@jsii.python.classproperty
@jsii.member(jsii_name="ROS_RESOURCE_TYPE_NAME")
def ROS_RESOURCE_TYPE_NAME(cls) -> builtins.str:
'''The resource type name for this resource class.'''
return typing.cast(builtins.str, jsii.sget(cls, "ROS_RESOURCE_TYPE_NAME"))
@builtins.property
@jsii.member(jsii_name="attrSavedsearchName")
def attr_savedsearch_name(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: SavedsearchName: Savedsearch name.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrSavedsearchName"))
@builtins.property
@jsii.member(jsii_name="rosProperties")
def _ros_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "rosProperties"))
@builtins.property
@jsii.member(jsii_name="detail")
def detail(
self,
) -> typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosSavedsearch.DetailProperty"]:
'''
:Property: detail:
'''
return typing.cast(typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosSavedsearch.DetailProperty"], jsii.get(self, "detail"))
@detail.setter
def detail(
self,
value: typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosSavedsearch.DetailProperty"],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__c6510412b2082ebfacd12a3b3700d095cef8fce737dc28b19dbf3b2f4a8336f5)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "detail", value)
@builtins.property
@jsii.member(jsii_name="enableResourcePropertyConstraint")
def enable_resource_property_constraint(self) -> builtins.bool:
return typing.cast(builtins.bool, jsii.get(self, "enableResourcePropertyConstraint"))
@enable_resource_property_constraint.setter
def enable_resource_property_constraint(self, value: builtins.bool) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__a2eec3d6125611bdd1f3ca67b4e0c7fc7e60c9843679896b1471e59893a5bd7c)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "enableResourcePropertyConstraint", value)
@builtins.property
@jsii.member(jsii_name="project")
def project(self) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: project: Project name
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "project"))
@project.setter
def project(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__667d871155eff750a2e1b7608da42b671b6a20219fb7a87d4e9cb785f21c3b73)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "project", value)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-sls.RosSavedsearch.DetailProperty",
jsii_struct_bases=[],
name_mapping={
"logstore": "logstore",
"savedsearch_name": "savedsearchName",
"search_query": "searchQuery",
"topic": "topic",
"display_name": "displayName",
},
)
class DetailProperty:
def __init__(
self,
*,
logstore: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
savedsearch_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
search_query: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
topic: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
display_name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''
:param logstore:
:param savedsearch_name:
:param search_query:
:param topic:
:param display_name:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__59ae1b270bae267d4f788fad936d5b73b37f3acc3c0df7c1dac27b6a8a4336f2)
check_type(argname="argument logstore", value=logstore, expected_type=type_hints["logstore"])
check_type(argname="argument savedsearch_name", value=savedsearch_name, expected_type=type_hints["savedsearch_name"])
check_type(argname="argument search_query", value=search_query, expected_type=type_hints["search_query"])
check_type(argname="argument topic", value=topic, expected_type=type_hints["topic"])
check_type(argname="argument display_name", value=display_name, expected_type=type_hints["display_name"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"logstore": logstore,
"savedsearch_name": savedsearch_name,
"search_query": search_query,
"topic": topic,
}
if display_name is not None:
self._values["display_name"] = display_name
@builtins.property
def logstore(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: logstore: Logstore name.
'''
result = self._values.get("logstore")
assert result is not None, "Required property 'logstore' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def savedsearch_name(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: savedsearchName: Savedsearch name.
'''
result = self._values.get("savedsearch_name")
assert result is not None, "Required property 'savedsearch_name' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def search_query(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: searchQuery: Check sentence.
'''
result = self._values.get("search_query")
assert result is not None, "Required property 'search_query' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def topic(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: topic: Topic name
'''
result = self._values.get("topic")
assert result is not None, "Required property 'topic' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def display_name(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: displayName: Display name.
'''
result = self._values.get("display_name")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "DetailProperty(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-sls.RosSavedsearchProps",
jsii_struct_bases=[],
name_mapping={"detail": "detail", "project": "project"},
)
class RosSavedsearchProps:
def __init__(
self,
*,
detail: typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union[RosSavedsearch.DetailProperty, typing.Dict[builtins.str, typing.Any]]],
project: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
'''Properties for defining a ``ALIYUN::SLS::Savedsearch``.
:param detail:
:param project:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__f47599eb1ddc82dff23faeca78a8ccd7dc22cd8c98219b7f48612be6ae539736)
check_type(argname="argument detail", value=detail, expected_type=type_hints["detail"])
check_type(argname="argument project", value=project, expected_type=type_hints["project"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"detail": detail,
"project": project,
}
@builtins.property
def detail(
self,
) -> typing.Union[_ros_cdk_core_7adfd82f.IResolvable, RosSavedsearch.DetailProperty]:
'''
:Property: detail:
'''
result = self._values.get("detail")
assert result is not None, "Required property 'detail' is missing"
return typing.cast(typing.Union[_ros_cdk_core_7adfd82f.IResolvable, RosSavedsearch.DetailProperty], result)
@builtins.property
def project(self) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: project: Project name
'''
result = self._values.get("project")
assert result is not None, "Required property 'project' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "RosSavedsearchProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class Savedsearch(
_ros_cdk_core_7adfd82f.Resource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-sls.Savedsearch",
):
'''A ROS resource type: ``ALIYUN::SLS::Savedsearch``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["SavedsearchProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
'''Create a new ``ALIYUN::SLS::Savedsearch``.
Param scope - scope in which this resource is defined
Param id - scoped id of the resource
Param props - resource properties
:param scope: -
:param id: -
:param props: -
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__458a07583ab8bee446484154b86ec9ad5f79b3e3be831442878c01ff66e71e74)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@builtins.property
@jsii.member(jsii_name="attrSavedsearchName")
def attr_savedsearch_name(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute SavedsearchName: Savedsearch name.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrSavedsearchName"))
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-sls.SavedsearchProps",
jsii_struct_bases=[],
name_mapping={"detail": "detail", "project": "project"},
)
class SavedsearchProps:
def __init__(
self,
*,
detail: typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union[RosSavedsearch.DetailProperty, typing.Dict[builtins.str, typing.Any]]],
project: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
'''Properties for defining a ``ALIYUN::SLS::Savedsearch``.
:param detail: Property detail:.
:param project: Property project: Project name.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__a6972516e071b7a7b27a7772549622bc99bef356a2b30bc2d18d026172e6ed28)
check_type(argname="argument detail", value=detail, expected_type=type_hints["detail"])
check_type(argname="argument project", value=project, expected_type=type_hints["project"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"detail": detail,
"project": project,
}
@builtins.property
def detail(
self,
) -> typing.Union[_ros_cdk_core_7adfd82f.IResolvable, RosSavedsearch.DetailProperty]:
'''Property detail:.'''
result = self._values.get("detail")
assert result is not None, "Required property 'detail' is missing"
return typing.cast(typing.Union[_ros_cdk_core_7adfd82f.IResolvable, RosSavedsearch.DetailProperty], result)
@builtins.property
def project(self) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property project: Project name.'''
result = self._values.get("project")
assert result is not None, "Required property 'project' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "SavedsearchProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
__all__ = [
"Alert",
"AlertProps",
"ApplyConfigToMachineGroup",
"ApplyConfigToMachineGroupProps",
"Audit",
"AuditProps",
"Dashboard",
"DashboardProps",
"Etl",
"EtlProps",
"Index",
"IndexProps",
"Logstore",
"LogstoreProps",
"LogtailConfig",
"LogtailConfigProps",
"MachineGroup",
"MachineGroupProps",
"MetricStore",
"MetricStoreProps",
"Project",
"ProjectProps",
"RosAlert",
"RosAlertProps",
"RosApplyConfigToMachineGroup",
"RosApplyConfigToMachineGroupProps",
"RosAudit",
"RosAuditProps",
"RosDashboard",
"RosDashboardProps",
"RosEtl",
"RosEtlProps",
"RosIndex",
"RosIndexProps",
"RosLogstore",
"RosLogstoreProps",
"RosLogtailConfig",
"RosLogtailConfigProps",
"RosMachineGroup",
"RosMachineGroupProps",
"RosMetricStore",
"RosMetricStoreProps",
"RosProject",
"RosProjectProps",
"RosSavedsearch",
"RosSavedsearchProps",
"Savedsearch",
"SavedsearchProps",
"datasource",
]
publication.publish()
# Loading modules to ensure their types are registered with the jsii runtime library
from . import datasource
def _typecheckingstub__4dc90d5eb990de440a55f36fefa7ba92d25bf22b7c503f361ce5506d11d4cad0(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[AlertProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__3915aaafcbce9b37683554165f5ef18d4047883b83d2acc3696d4f04edbd3d00(
*,
detail: typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union[RosAlert.DetailProperty, typing.Dict[builtins.str, typing.Any]]],
project: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__939f798867cdbdd3ccac4a71da46d977541b7535df2acc8acf96d4b2fb1532d8(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Optional[typing.Union[ApplyConfigToMachineGroupProps, typing.Dict[builtins.str, typing.Any]]] = None,
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__2e841975a95f0caaef38704a787ff0fa3aa4f36c0404a05c0478c221b7b60a3f(
*,
config_name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
group_name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
project_name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__f71af29470adc4f3830048e02c84c908818932ae9d7e9fe3cb445d358ec121ce(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[AuditProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__ca39effacb160cba87db70b32051e2903b282cd4c0b9680d83ffa990931dad6d(
*,
display_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
variable_map: typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union[RosAudit.VariableMapProperty, typing.Dict[builtins.str, typing.Any]]],
multi_account: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__0a612850618f1228ee78250a54ce5b64a134718cdc0866e17c6c5241dcd92cd8(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[DashboardProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__02bccad83b27835df2ad9a17842b3b5a447fa55e96c1dcbe1743ca027925c5ae(
*,
charts: typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Mapping[builtins.str, typing.Any]]],
dashboard_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
project_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
description: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
display_name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__29fc8efa98adb9273024b08d52cba929ca77378561006bf0c9c31f8298610651(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[EtlProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__7844781c2020366512942ad290c99edac6cd8eaf9c14acd4e2137e86d318ddf6(
*,
configuration: typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union[RosEtl.ConfigurationProperty, typing.Dict[builtins.str, typing.Any]]],
display_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
project_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
schedule: typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union[RosEtl.ScheduleProperty, typing.Dict[builtins.str, typing.Any]]],
description: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__37ce56cf99a18afc6ffc83bdf68f8d54a6c421ecc5be7b831935e0ce3191b534(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[IndexProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__87a3553e99bb30490cd4d8a4606bb24823b1f2d5fb7a923d6a3196ad70dacb9c(
*,
full_text_index: typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union[RosIndex.FullTextIndexProperty, typing.Dict[builtins.str, typing.Any]]],
logstore_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
project_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
key_indices: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union[RosIndex.KeyIndicesProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
log_reduce: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__c79bb65dcabce61b887a71b17ddce83bdae93928e2a65252e7a2b7ff3a264b9e(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[LogstoreProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__e93c4fefc36d5232872c87439488763bf3f8c4c3075cdb5894f83c2d2de01d77(
*,
logstore_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
project_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
append_meta: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
auto_split: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
enable_tracking: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
encrypt_conf: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union[RosLogstore.EncryptConfProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
max_split_shard: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
preserve_storage: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
shard_count: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
ttl: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__70ffb82ed17c7a61e3451a40493e2f4eeb542c6ff00318fd972681920c0f24b9(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[LogtailConfigProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__997427b30c5163225c21712ca6967753c2240e9b45aec519ef99002bd95d1ebd(
*,
logstore_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
logtail_config_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
project_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
clone_from: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union[RosLogtailConfig.CloneFromProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
raw_config_data: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__b22aba27590c9ba9fcef78ece9af9628932bed672c0ab16db139b31d1392669e(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Optional[typing.Union[MachineGroupProps, typing.Dict[builtins.str, typing.Any]]] = None,
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__45ed99b8d188d732f608210e6fa1bc867af7e5ee0e1bab8d04237b6137de3303(
*,
group_attribute: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
group_name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
group_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
machine_identify_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
machine_list: typing.Optional[typing.Union[typing.Sequence[typing.Any], _ros_cdk_core_7adfd82f.IResolvable]] = None,
project_name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__4663a674839438b2c47edf7b54c23c2beedb0d1ce18df1282b31edadf5d78587(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[MetricStoreProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__b34e84ca87f2fe6236aeb3933401db5149795129f06227666f5ad165a9ae952e(
*,
logstore_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
project_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
preserve_storage: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
shard_count: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
ttl: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__43e5ccce68dcd7589fe7a912c535fededac7de18ffe6efb56ce3a0e02ca34050(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[ProjectProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__e8200cc4deccd66b4f1d77b8d6692341d01973dca3ef46fe9678865407d439cb(
*,
name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
description: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
tags: typing.Optional[typing.Sequence[typing.Union[RosProject.TagsProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__d81c9e3194e6b74ce23c4c5e1d279882e3252bf091e874c82783f7ac748f7177(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[RosAlertProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__d4d410b4f4685a4baf0479d010a853ff24bfbd0f3059de40d98068a808e88a7b(
props: typing.Mapping[builtins.str, typing.Any],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__916f1f24d97236db3a911f4c9e173175fefd41025b668e4820e1d7d21c45adc6(
value: typing.Union[_ros_cdk_core_7adfd82f.IResolvable, RosAlert.DetailProperty],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__41eac6e8840febf9281354bd51a1d0951f6fbff1e70327787d45e0481fd96b11(
value: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__2ceefc40fd026b604c27ac8617a5f924b8bed63bdd4be5315c6519368d5fb177(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__d177d30c91b26129266385e50775754752a8632d3f8c4221bd5d6c21c5b479cd(
*,
key: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__c40c5940d9d97be9c83588103df6b0efbb235317d46fe5b6ac39a04a0f362866(
*,
dashboard: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
query_list: typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union[RosAlert.QueryListProperty, typing.Dict[builtins.str, typing.Any]]]]],
annotations: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union[RosAlert.AnnotationsProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
auto_annotation: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
condition: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
group_configuration: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union[RosAlert.GroupConfigurationProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
join_configurations: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union[RosAlert.JoinConfigurationsProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
labels: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union[RosAlert.LabelsProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
mute_until: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
no_data_fire: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
no_data_severity: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
notification_list: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union[RosAlert.NotificationListProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
notify_threshold: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
policy_configuration: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union[RosAlert.PolicyConfigurationProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
send_resolved: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
severity_configurations: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union[RosAlert.SeverityConfigurationsProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
threshold: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
throttling: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
version: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__a1b980fb01df01e7cca013f9fc86e5c17aad18f9d87e2e9ca54b93c028f419d2(
*,
configuration: typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union[RosAlert.ConfigurationProperty, typing.Dict[builtins.str, typing.Any]]],
display_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
schedule: typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union[RosAlert.ScheduleProperty, typing.Dict[builtins.str, typing.Any]]],
description: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
state: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__9baca7159b8bd19387ed97626c68cdfd774f1dcc1af7da6401a45e579625eb5a(
*,
condition: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
count_condition: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__8335fbd7beb94c51b7a74abf2a0515bdf8c2144e3face1e0111afd38cc5a617d(
*,
type: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
fields: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__bb37763eb7980adc3f4162a2b98986b2371ec6bc9b4ec74553a9d5d56b84b542(
*,
type: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
condition: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__330c80b091e838652d1dcd3174153eabe55351c1bf74e4246a6dd874081b732b(
*,
key: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__0dadac77daffa12d08cfcd4cc632a75631f1d14dbf49037a5890a74c08721c3a(
*,
type: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
content: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
email_list: typing.Optional[typing.Union[typing.Sequence[typing.Any], _ros_cdk_core_7adfd82f.IResolvable]] = None,
headers: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]] = None,
method: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
mobile_list: typing.Optional[typing.Union[typing.Sequence[typing.Any], _ros_cdk_core_7adfd82f.IResolvable]] = None,
service_uri: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__cea1347ca092dea0f8a2d7a1806f9c9f6eb5df8ef4f23212cc08f852fedee5df(
*,
action_policy_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
alert_policy_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
repeat_interval: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
use_default: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__86fafbbbc10fca3015f28a29fa7dc2f5489989dc36e8bf3ed1fd392f86183ea6(
*,
end: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
query: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
start: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
time_span_type: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
chart_title: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
dashboard_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
log_store: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
power_sql_mode: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
project: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
region: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
role_arn: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
store: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
store_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__c34ed5f1de3c4967fda894df32f3f1b97edb2df72eb5c71d737b6cd739f64af7(
*,
type: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
cron_expression: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
day_of_week: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
delay: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
hour: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
interval: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
run_immediately: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__7e55c1d8adc9c7e907a04150d234949970efec6488cf020183afce9f2050ff11(
*,
severity: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
eval_condition: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union[RosAlert.EvalConditionProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__e604851b523ce98d9c9ba9fcf69e0fe38558dfd63c154b23e62b9e4fd4d6fc93(
*,
detail: typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union[RosAlert.DetailProperty, typing.Dict[builtins.str, typing.Any]]],
project: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__be2133a7cf1f199681a7fe74dd560b109406022dad7bea3042489e0034a35dc8(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[RosApplyConfigToMachineGroupProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__fe251e09b0fc2e85f6e790399a06cf82d60cc1f9a3e09a263a2a11e5110738a4(
props: typing.Mapping[builtins.str, typing.Any],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__ad4e141f0c62780e02a6d37240cae998eb287add36782d84871573b0ae969c58(
value: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__30b716a11fc60ae769f44c954c8efdfae53cf934597adcbcb98a24e8d0602f7b(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__d9f8a87a2f0f569408590ffc26efaef5982dce3f5eebb9ab6d6ba0dbd50a5135(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__6c777153b3ae0ff5ffb51374409be2ab6448452d10758f417c5329807b05ee59(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__192cc019a9c4b40b582b57524bf78829b5f94fc33f62ab700eb3a8624aae6ef5(
*,
config_name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
group_name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
project_name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__890a1962056ff122d07ae419445879d7b2f5faea95741af30a499a3ff32f8a4e(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[RosAuditProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__b7ca55328c22e0103dc0a42399f0d4567e9ac1fcab9df4f14765320fec062de9(
props: typing.Mapping[builtins.str, typing.Any],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__bf33293395b9373c6ef70b59b742a68b6ac28cf041f036cc99ae2ed229816e75(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__faa37e69e70f953f7646bf82e0ce6ca88468f7b105492d9208b709aac0572e0d(
value: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__e569cc2500a074f550f2f545e5f8f1d51ac4f94cf82972b5600a446a45a65dcc(
value: typing.Union[_ros_cdk_core_7adfd82f.IResolvable, RosAudit.VariableMapProperty],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__3f94fdcbe12723d6ae915c332b0c83101ceb1891bfa990a8d85b7f04d119445d(
value: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__4e86dadc77abd9f0591b0907ef25e31e7aad62ae1ae0ba4279815f3fb59a7e2d(
*,
actiontrail_enabled: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
actiontrail_openapi_collection_policy: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
actiontrail_openapi_policy_setting: typing.Optional[typing.Union[typing.Sequence[typing.Any], _ros_cdk_core_7adfd82f.IResolvable]] = None,
actiontrail_ti_enabled: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
actiontrail_ttl: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
apigateway_access_collection_policy: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
apigateway_access_policy_setting: typing.Optional[typing.Union[typing.Sequence[typing.Any], _ros_cdk_core_7adfd82f.IResolvable]] = None,
apigateway_enabled: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
apigateway_ti_enabled: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
apigateway_ttl: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
appconnect_enabled: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
appconnect_op_collection_policy: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
appconnect_op_policy_setting: typing.Optional[typing.Union[typing.Sequence[typing.Any], _ros_cdk_core_7adfd82f.IResolvable]] = None,
appconnect_ti_enabled: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
appconnect_ttl: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
bastion_audit_collection_policy: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
bastion_audit_policy_setting: typing.Optional[typing.Union[typing.Sequence[typing.Any], _ros_cdk_core_7adfd82f.IResolvable]] = None,
bastion_enabled: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
bastion_ti_enabled: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
bastion_ttl: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
cloudfirewall_access_collection_policy: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
cloudfirewall_access_policy_setting: typing.Optional[typing.Union[typing.Sequence[typing.Any], _ros_cdk_core_7adfd82f.IResolvable]] = None,
cloudfirewall_enabled: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
cloudfirewall_ti_enabled: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
cloudfirewall_ttl: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
cps_callback_collection_policy: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
cps_callback_policy_setting: typing.Optional[typing.Union[typing.Sequence[typing.Any], _ros_cdk_core_7adfd82f.IResolvable]] = None,
cps_enabled: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
cps_ti_enabled: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
cps_ttl: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
ddos_coo_access_collection_policy: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
ddos_coo_access_enabled: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
ddos_coo_access_policy_setting: typing.Optional[typing.Union[typing.Sequence[typing.Any], _ros_cdk_core_7adfd82f.IResolvable]] = None,
ddos_coo_access_ti_enabled: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
ddos_coo_access_ttl: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
drds_audit_collection_policy: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
drds_audit_enabled: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
drds_audit_policy_setting: typing.Optional[typing.Union[typing.Sequence[typing.Any], _ros_cdk_core_7adfd82f.IResolvable]] = None,
drds_audit_ti_enabled: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
drds_audit_ttl: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
drds_sync_enabled: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
drds_sync_ttl: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
k8_s_audit_collection_policy: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
k8_s_audit_enabled: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
k8_s_audit_policy_setting: typing.Optional[typing.Union[typing.Sequence[typing.Any], _ros_cdk_core_7adfd82f.IResolvable]] = None,
k8_s_audit_ti_enabled: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
k8_s_audit_ttl: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
k8_s_event_collection_policy: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
k8_s_event_enabled: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
k8_s_event_policy_setting: typing.Optional[typing.Union[typing.Sequence[typing.Any], _ros_cdk_core_7adfd82f.IResolvable]] = None,
k8_s_event_ti_enabled: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
k8_s_event_ttl: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
k8_s_ingress_collection_policy: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
k8_s_ingress_enabled: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
k8_s_ingress_policy_setting: typing.Optional[typing.Union[typing.Sequence[typing.Any], _ros_cdk_core_7adfd82f.IResolvable]] = None,
k8_s_ingress_ti_enabled: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
k8_s_ingress_ttl: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
nas_audit_collection_policy: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
nas_audit_policy_setting: typing.Optional[typing.Union[typing.Sequence[typing.Any], _ros_cdk_core_7adfd82f.IResolvable]] = None,
nas_enabled: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
nas_ti_enabled: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
nas_ttl: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
oss_access_collection_policy: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
oss_access_enabled: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
oss_access_policy_setting: typing.Optional[typing.Union[typing.Sequence[typing.Any], _ros_cdk_core_7adfd82f.IResolvable]] = None,
oss_access_ti_enabled: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
oss_access_ttl: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
oss_metering_collection_policy: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
oss_metering_enabled: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
oss_metering_policy_setting: typing.Optional[typing.Union[typing.Sequence[typing.Any], _ros_cdk_core_7adfd82f.IResolvable]] = None,
oss_metering_ti_enabled: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
oss_metering_ttl: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
oss_sync_enabled: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
oss_sync_ttl: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
polardb_audit_collection_policy: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
polardb_audit_policy_setting: typing.Optional[typing.Union[typing.Sequence[typing.Any], _ros_cdk_core_7adfd82f.IResolvable]] = None,
polardb_enabled: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
polardb_perf_collection_policy: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
polardb_perf_enabled: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
polardb_perf_policy_setting: typing.Optional[typing.Union[typing.Sequence[typing.Any], _ros_cdk_core_7adfd82f.IResolvable]] = None,
polardb_perf_ti_enabled: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
polardb_perf_ttl: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
polardb_slow_collection_policy: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
polardb_slow_enabled: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
polardb_slow_policy_setting: typing.Optional[typing.Union[typing.Sequence[typing.Any], _ros_cdk_core_7adfd82f.IResolvable]] = None,
polardb_slow_ti_enabled: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
polardb_slow_ttl: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
polardb_ti_enabled: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
polardb_ttl: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
rds_audit_collection_policy: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
rds_audit_policy_setting: typing.Optional[typing.Union[typing.Sequence[typing.Any], _ros_cdk_core_7adfd82f.IResolvable]] = None,
rds_enabled: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
rds_perf_collection_policy: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
rds_perf_enabled: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
rds_perf_policy_setting: typing.Optional[typing.Union[typing.Sequence[typing.Any], _ros_cdk_core_7adfd82f.IResolvable]] = None,
rds_perf_ti_enabled: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
rds_perf_ttl: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
rds_slow_collection_policy: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
rds_slow_enabled: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
rds_slow_policy_setting: typing.Optional[typing.Union[typing.Sequence[typing.Any], _ros_cdk_core_7adfd82f.IResolvable]] = None,
rds_slow_ti_enabled: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
rds_slow_ttl: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
rds_ti_enabled: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
rds_ttl: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
redis_audit_collection_policy: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
redis_audit_enabled: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
redis_audit_policy_setting: typing.Optional[typing.Union[typing.Sequence[typing.Any], _ros_cdk_core_7adfd82f.IResolvable]] = None,
redis_audit_ti_enabled: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
redis_audit_ttl: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
redis_sync_enabled: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
redis_sync_ttl: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
sas_crack_enabled: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
sas_dns_enabled: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
sas_http_enabled: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
sas_local_dns_enabled: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
sas_login_enabled: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
sas_network_enabled: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
sas_process_enabled: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
sas_security_alert_enabled: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
sas_security_hc_enabled: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
sas_security_vul_enabled: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
sas_session_enabled: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
sas_snapshot_account_enabled: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
sas_snapshot_port_enabled: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
sas_snapshot_process_enabled: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
sas_ti_enabled: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
sas_ttl: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
slb_access_collection_policy: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
slb_access_enabled: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
slb_access_policy_setting: typing.Optional[typing.Union[typing.Sequence[typing.Any], _ros_cdk_core_7adfd82f.IResolvable]] = None,
slb_access_ti_enabled: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
slb_access_ttl: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
slb_sync_enabled: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
slb_sync_ttl: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
waf_access_collection_policy: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
waf_access_policy_setting: typing.Optional[typing.Union[typing.Sequence[typing.Any], _ros_cdk_core_7adfd82f.IResolvable]] = None,
waf_enabled: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
waf_ti_enabled: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
waf_ttl: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__1d2861046ac4d48cde619a94d8919ee5e9c24ee45791046b89dfc9fb8d1d8e42(
*,
display_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
variable_map: typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union[RosAudit.VariableMapProperty, typing.Dict[builtins.str, typing.Any]]],
multi_account: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__fd50f65d29bc70c859f0193198038e1f8bb1d06f1d48b13646eaa5811c34cb78(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[RosDashboardProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__b10123e297b0bd87f1531d795fd616db36165eb2a822dde28d1600151f9de981(
props: typing.Mapping[builtins.str, typing.Any],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__cb09229de9b13f454f82a24993cb6f24401ab5ff300dea9120fd22c4c1b1f00f(
value: typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Mapping[builtins.str, typing.Any]]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__a8fb543f50a85a4b565866c57626719892e7d61e88ec6377a6c4af0202933f36(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__439bbc6870978e93eed81f405e3a75c5b7326485ec7a80dd8cc17c0baa2f9958(
value: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__c9bc5d0198c94fb52870bd05f1791ac5581591fdafa04b4bb0dc7eb818a3352c(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__cddded3fddc15c08b72183294f32f51b7a0e7b61f692adeb6a21c0a0218bcb95(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__fe911883fffd2344bcc81368339aa13d9893f1deb704301f8c77ff1eee5bd1fb(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__cc97c1c3bf010a5ce2fbb4b8c6229fafd53acb09a877429a7944c70bfacb1d6b(
*,
charts: typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Mapping[builtins.str, typing.Any]]],
dashboard_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
project_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
description: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
display_name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__cee91076e193c92146eb93c8756d807308a573c4dbb6f640f4b797dfb8d86278(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[RosEtlProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__e7a340b1b1e4c697934de0451aa1c7331e64e5611f505f966eca4918488b3faf(
props: typing.Mapping[builtins.str, typing.Any],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__92b196e0ce9e6d731e7b057fb07e10c8d062fc90c9811e8171730711a8519252(
value: typing.Union[_ros_cdk_core_7adfd82f.IResolvable, RosEtl.ConfigurationProperty],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__986a3f1614fc9039f94c6acfc7cc2e274d14a302f44b81e5d712c83e7a11fa97(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__f49a3ca5092a23e35b5970fa51b5c37c42a2b2ad56a93a3e8840ca9794b119dc(
value: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__4e52fe6ab379e81e2db7402e819733676b20a0117dabc665ac6cdfd4e5743a38(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__229bf768ee665446a15e05cf25e084765eda239e0a64f9a08bf09bc458142561(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__be98996241ebe2d3e1a5ba2f9e4142cd1d6144eed0260bf66ee0a87290a8e876(
value: typing.Union[_ros_cdk_core_7adfd82f.IResolvable, RosEtl.ScheduleProperty],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__0d3b541beec74566db83233cc704409d70bd0c0bcfa2433c7495d8ef9d8a8d4a(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__bf246d0e31ea2a23bbf398a5a71e102a739d43371572c597135c8dcda16be38e(
*,
logstore: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
script: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
sinks: typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union[RosEtl.SinksProperty, typing.Dict[builtins.str, typing.Any]]]]],
from_time: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
parameters: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]] = None,
role_arn: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
to_time: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
version: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__4f64a84148b18d95ef18365a2ad3a1752c45ce6b9a05fd9e1b973a8e1408a8b0(
*,
type: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__632876a1e42214bb020ccdf46163e7d34055ebb30c52a08d926414bf4286d93e(
*,
logstore: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
project: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
endpoint: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
role_arn: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__cd5c0c77487f9a99e8a5949ee53700c39bb2b387d8d7e298f528d5e470c58217(
*,
configuration: typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union[RosEtl.ConfigurationProperty, typing.Dict[builtins.str, typing.Any]]],
display_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
project_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
schedule: typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union[RosEtl.ScheduleProperty, typing.Dict[builtins.str, typing.Any]]],
description: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__37f495e2bfa9abf956c9392aa2f8709463c449c5ffe8d1de60b88201775d05b2(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[RosIndexProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__1efa356708c9f6976afd733ef3e2533a8e4020bc02341fe33b8bd384d056d5e2(
props: typing.Mapping[builtins.str, typing.Any],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__c2e15e2874891bfbfad283076b534ecb7c53ce77135f5d3994b67571fcdd79dd(
value: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__5a8297738a61654c125b945e7df17d6cad7f9cd343e54f113699bbe43ccbb991(
value: typing.Union[_ros_cdk_core_7adfd82f.IResolvable, RosIndex.FullTextIndexProperty],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__8d63092da3741744d0b1ebed6e91eb3c4fd0593ea747e0819d73ebf13535c1f0(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__14a0325c6a3c22d152d3d73a42f1a710e7e61a24165f79c4253c762286834e9f(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__68bbf95f114dcf8be54931485e82ed1b47dff468ee5621f09d278bd53637fa9a(
value: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, RosIndex.KeyIndicesProperty]]]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__f2f49703976a6c4004246fcd06b4f1f6163ab03e8268d04cc94c3b84bcf57894(
value: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__de2ec08454981a62199bef98eb856a556b723526f9b8cbd3effd3b1434903aee(
*,
enable: typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable],
case_sensitive: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
delimiter: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
include_chinese: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__16dc17dd234ed1b812f66947478d6c879cb3bcd68450b5807a20ada37bdbd3af(
*,
name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
type: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
alias: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
enable_analytics: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__bfe03b0f2c5fecef23eff4c706134418d426969d7b16ca2278a2ce16a185e5f5(
*,
name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
type: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
alias: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
case_sensitive: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
delimiter: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
enable_analytics: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
include_chinese: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
json_key_indices: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union[RosIndex.JsonKeyIndicesProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__61e9320e6265a141ad3fb19c272fe7dbcee64aea49c5aa2626e4a841feaf24a8(
*,
full_text_index: typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union[RosIndex.FullTextIndexProperty, typing.Dict[builtins.str, typing.Any]]],
logstore_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
project_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
key_indices: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union[RosIndex.KeyIndicesProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
log_reduce: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__e99911c25ef1771030dc1aff0f4622acd22c72d91b62967fa50502445e9e1daa(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[RosLogstoreProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__ca09612fbd1dfb6ce94c68f4b31b1bded3e41747535c836851bef796f56df9c4(
props: typing.Mapping[builtins.str, typing.Any],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__14be6e6178234d789a03b622398e2e0eaf87d9efe1f02684dac49283119aab2d(
value: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__f3205ff0bf4813b85ce8caf586d88d9b95deaa5732d8977ac73d8dad4b9e5c28(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__c24dca99c400b487486acc38e61d30ae7ec5214830dbb65bd3337f17503c5018(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__6b10d2e874bbb32709b515f8358a31b727241714cdd02fa054b1e442a14a39bb(
value: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__dc147794358c6c51ac6aa1d7c1074f4c04d3262317196ea5d5dde593d82dedd3(
value: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__5e1de55c3c6af4f5945029917237529f54392d50bbe587726e3ca6840d885861(
value: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__047500645b3f2e3bd6f3df19b1e2d99c848f6e0ddeaaec1485ea51d26d0ae32b(
value: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, RosLogstore.EncryptConfProperty]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__d9f1f593938163ac49aa924abe5ce358144fb41168fcbce43ecb941981086b44(
value: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__e01696a95b514f403c6b21a31c83062a1b24103a25b8c2b71af35ab88cfedf69(
value: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__d3c5cd42a790ab0c0dac531af4c4a4d54f2cc88ce3f45b01e342a6aa26ebd1bf(
value: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__929b5c2fd95bd3f831fb38f2913dabd6bd5c794c02f0fc118e338374b4781987(
value: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__ae51c1b1297fbcd609b31020090e99e91eedd6d795bdd27e4c53cc18e344dbca(
*,
enable: typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable],
encrypt_type: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
user_cmk_info: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union[RosLogstore.UserCmkInfoProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__89cfea88e93938bdb7c0d2d2d439b7b999aa37d643de878d5be444b97822a2d6(
*,
arn: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
cmk_key_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
region_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__fc4a4748fe1c43946564ba15ce1137dc87e445eaf58614d72a09430b459eaa25(
*,
logstore_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
project_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
append_meta: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
auto_split: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
enable_tracking: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
encrypt_conf: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union[RosLogstore.EncryptConfProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
max_split_shard: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
preserve_storage: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
shard_count: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
ttl: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__575fec4ea1be80faa42157f7d7b3093633a76abde41983322c5b96de52d32d2e(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[RosLogtailConfigProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__cd20e01bfc8fafd3d9ef0862e32ea2b942dfc68850bf99f291266b9c1ddf3b73(
props: typing.Mapping[builtins.str, typing.Any],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__ffdd50dd56ad6630720b6e1e78b901edf9fd66a198cd451aa191c330de151f27(
value: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__9e0d43703eba35b9974f8ba13a49fcab9ac3ae87f9fcd64eace9d2bb1ead7308(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__7ffaa0a6a0821b6dc58b230f81bb91e403e31dfff4f523a402e6badf6f91a84d(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__590d9229743075c4733038a888fe2fa8e51d03916378e60a3ba509cec4905c7b(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__5ec9f6e431392df03d37d1080860050758a7a6a1ad0bf9c990d5eced75808a06(
value: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, RosLogtailConfig.CloneFromProperty]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__e92dd84454d18182ce5e90a291f1a400193d965f8abe0aed4ae8b6bbc6c3147c(
value: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__bd4c3d39edca26d97f75583f415b7fd36790ab2630c2fd89da5aa92326dfb58a(
*,
logtail_config_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
project_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__25087996a9532cdffeaa27214286e1df397df759a1757848ad254cac7bf2da39(
*,
logstore_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
logtail_config_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
project_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
clone_from: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union[RosLogtailConfig.CloneFromProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
raw_config_data: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Mapping[builtins.str, typing.Any]]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__6a42b2eab7a43080f80c9908f46208e45e112912f1f3385791472173f57e8dbb(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[RosMachineGroupProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__7f9451afe70285e91b7c4676ad7a92580ee42afd3fa5d1c377d5d1cf5d5e5695(
props: typing.Mapping[builtins.str, typing.Any],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__191cdef9c79284db9e62826a25fe4229f5db0b87ccb1ec4b8a599c475e350130(
value: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__dbcd9d6c08c05685f10ba2c33faa1fad8d60203f4158289a2dcd092af2455688(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__a20e5e4f569064875d96d43eb1bdcc7d0f5c53d0260467eff1d7d1518a9450d0(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__097cf54e1bfa9aa585ca89c8278c59b7713d7fac9c54e4f6dc91ca5c88e2c1b0(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__f2d2ada03e20b922d7af0991c424ec372a87aa9f3a32cab6b08e1171c0a86e07(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__34bc65b21c8bbb7d82df291218b293f229090fab039191b5cab300b966323345(
value: typing.Optional[typing.Union[typing.List[typing.Any], _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__8bda85b8de49bb54c758eac251b9c0988d269fc90fa73de41eed1a53638f410a(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__885aeb7c14b65270b96554da6f93ec97bace9e50aa88e9e316d540661d983a65(
*,
group_attribute: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
group_name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
group_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
machine_identify_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
machine_list: typing.Optional[typing.Union[typing.Sequence[typing.Any], _ros_cdk_core_7adfd82f.IResolvable]] = None,
project_name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__1fddef050da68afb68b22771ca25cd858e8927bacb6fc4c39a3d3d078db07a8f(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[RosMetricStoreProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__a9e91cdc2567a239becec870c41e56bbc6918cebaa2832385d1871e60f60aa4e(
props: typing.Mapping[builtins.str, typing.Any],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__db4efdbe966d4dc5e514607d183d9a0c3d5caede43ce41faab4c9263bc9b2483(
value: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__c528355f24501c7d849ddc151f2aea435743eb479f1bc73959f42913238e00e2(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__79d73d74a7f726d08fdb3e14b3779123666ba8c822da3886de5906b78c44053a(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__4489138315151e5ccc92958a670d850b5e0cff5b3d34ba6212f6321b747ef1b3(
value: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__fa964e589700e8f21cacf38ca48de0dc419be0996952e7a6a3f616753ccbe56f(
value: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__f8e94b098142b0de758fb4a71f509b9dda865ccdfc467aa64f9a3fa729379371(
value: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__3e37eb04ea66385b49a63e0c05eff511770563a72306240e160632f2f28ef914(
*,
logstore_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
project_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
preserve_storage: typing.Optional[typing.Union[builtins.bool, _ros_cdk_core_7adfd82f.IResolvable]] = None,
shard_count: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
ttl: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__38a7af9ea5b5e764f37121b3cf403526a1b4c66420c7ffe80556610eb94b0a84(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[RosProjectProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__1641ef3b0f008269d7cb1f8ccf79d180e6e1852ace6ec26ff20ecedb3f9211e6(
props: typing.Mapping[builtins.str, typing.Any],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__6c029aa59f998b498df772c9774bc3430dc84a3a13158252d7ad7148b90b03ce(
value: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__fb8e142c132b888d5c4654d9eb94dc54768a0e63c44f4e76c074cbc180e5b4b9(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__26f055a2c2f4717089f86145879345e33573886f27696c8af3de79916d58bef4(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__d6a59f8bd6ba8a6d93d290f3c4b11c612773d74d83efba92159a8e4a30881df7(
value: typing.Optional[typing.List[RosProject.TagsProperty]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__a72e6dcd789c2dcaa2d07ca250a132f64d678c64115e8f4b55c76eb1514f9857(
*,
key: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__3784af050a0cb65f900ea3b984feccd3c0a8f0f3db206be5c1e9d19d884b8593(
*,
name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
description: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
tags: typing.Optional[typing.Sequence[typing.Union[RosProject.TagsProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__63cdff2941d2aaa0d3b23c7fabd077a489003541fce47432b25840ad2a14d8d4(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[RosSavedsearchProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__077eb76bb7d0d0917657a66a47111e98ce71cc38cd7e5d6307fed8a926aaa871(
props: typing.Mapping[builtins.str, typing.Any],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__c6510412b2082ebfacd12a3b3700d095cef8fce737dc28b19dbf3b2f4a8336f5(
value: typing.Union[_ros_cdk_core_7adfd82f.IResolvable, RosSavedsearch.DetailProperty],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__a2eec3d6125611bdd1f3ca67b4e0c7fc7e60c9843679896b1471e59893a5bd7c(
value: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__667d871155eff750a2e1b7608da42b671b6a20219fb7a87d4e9cb785f21c3b73(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__59ae1b270bae267d4f788fad936d5b73b37f3acc3c0df7c1dac27b6a8a4336f2(
*,
logstore: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
savedsearch_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
search_query: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
topic: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
display_name: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__f47599eb1ddc82dff23faeca78a8ccd7dc22cd8c98219b7f48612be6ae539736(
*,
detail: typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union[RosSavedsearch.DetailProperty, typing.Dict[builtins.str, typing.Any]]],
project: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__458a07583ab8bee446484154b86ec9ad5f79b3e3be831442878c01ff66e71e74(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[SavedsearchProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__a6972516e071b7a7b27a7772549622bc99bef356a2b30bc2d18d026172e6ed28(
*,
detail: typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union[RosSavedsearch.DetailProperty, typing.Dict[builtins.str, typing.Any]]],
project: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass | /ros-cdk-sls-1.0.17.tar.gz/ros-cdk-sls-1.0.17/src/ros_cdk_sls/__init__.py | 0.657978 | 0.162613 | __init__.py | pypi |
import abc
import builtins
import datetime
import enum
import typing
import jsii
import publication
import typing_extensions
from typeguard import check_type
from .._jsii import *
import ros_cdk_core as _ros_cdk_core_7adfd82f
class AntiBruteForceRules(
_ros_cdk_core_7adfd82f.Resource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-threatdetection.datasource.AntiBruteForceRules",
):
'''A ROS resource type: ``DATASOURCE::ThreatDetection::AntiBruteForceRules``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Optional[typing.Union["AntiBruteForceRulesProps", typing.Dict[builtins.str, typing.Any]]] = None,
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
'''Create a new ``DATASOURCE::ThreatDetection::AntiBruteForceRules``.
Param scope - scope in which this resource is defined
Param id - scoped id of the resource
Param props - resource properties
:param scope: -
:param id: -
:param props: -
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__4d1ca3b47ff95113a043d01c7aa76bfef68e765c2d1f3abaf45ce2f15494e790)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@builtins.property
@jsii.member(jsii_name="attrAntiBruteForceRuleIds")
def attr_anti_brute_force_rule_ids(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute AntiBruteForceRuleIds: The list of anti brute force rule IDs.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrAntiBruteForceRuleIds"))
@builtins.property
@jsii.member(jsii_name="attrAntiBruteForceRules")
def attr_anti_brute_force_rules(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute AntiBruteForceRules: The list of anti brute force rules.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrAntiBruteForceRules"))
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-threatdetection.datasource.AntiBruteForceRulesProps",
jsii_struct_bases=[],
name_mapping={},
)
class AntiBruteForceRulesProps:
def __init__(self) -> None:
'''Properties for defining a ``DATASOURCE::ThreatDetection::AntiBruteForceRules``.'''
self._values: typing.Dict[builtins.str, typing.Any] = {}
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "AntiBruteForceRulesProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class RosAntiBruteForceRules(
_ros_cdk_core_7adfd82f.RosResource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-threatdetection.datasource.RosAntiBruteForceRules",
):
'''A ROS template type: ``DATASOURCE::ThreatDetection::AntiBruteForceRules``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["RosAntiBruteForceRulesProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
'''Create a new ``DATASOURCE::ThreatDetection::AntiBruteForceRules``.
:param scope: - scope in which this resource is defined.
:param id: - scoped id of the resource.
:param props: - resource properties.
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__f64f587448ff839fa8bc048be4d30edcf94105d208fc64f2644df879de967ef2)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@jsii.member(jsii_name="renderProperties")
def _render_properties(
self,
props: typing.Mapping[builtins.str, typing.Any],
) -> typing.Mapping[builtins.str, typing.Any]:
'''
:param props: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__af852c024ab9ef0c19eaa6c90cddcb1733a590b39f4cea798badb7e112b71995)
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))
@jsii.python.classproperty
@jsii.member(jsii_name="ROS_RESOURCE_TYPE_NAME")
def ROS_RESOURCE_TYPE_NAME(cls) -> builtins.str:
'''The resource type name for this resource class.'''
return typing.cast(builtins.str, jsii.sget(cls, "ROS_RESOURCE_TYPE_NAME"))
@builtins.property
@jsii.member(jsii_name="attrAntiBruteForceRuleIds")
def attr_anti_brute_force_rule_ids(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: AntiBruteForceRuleIds: The list of anti brute force rule IDs.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrAntiBruteForceRuleIds"))
@builtins.property
@jsii.member(jsii_name="attrAntiBruteForceRules")
def attr_anti_brute_force_rules(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: AntiBruteForceRules: The list of anti brute force rules.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrAntiBruteForceRules"))
@builtins.property
@jsii.member(jsii_name="rosProperties")
def _ros_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "rosProperties"))
@builtins.property
@jsii.member(jsii_name="enableResourcePropertyConstraint")
def enable_resource_property_constraint(self) -> builtins.bool:
return typing.cast(builtins.bool, jsii.get(self, "enableResourcePropertyConstraint"))
@enable_resource_property_constraint.setter
def enable_resource_property_constraint(self, value: builtins.bool) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__867314675178a12098dcf86b14940fae4b97b9af32c16a157eb256c5eae1d84a)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "enableResourcePropertyConstraint", value)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-threatdetection.datasource.RosAntiBruteForceRulesProps",
jsii_struct_bases=[],
name_mapping={},
)
class RosAntiBruteForceRulesProps:
def __init__(self) -> None:
'''Properties for defining a ``DATASOURCE::ThreatDetection::AntiBruteForceRules``.'''
self._values: typing.Dict[builtins.str, typing.Any] = {}
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "RosAntiBruteForceRulesProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
__all__ = [
"AntiBruteForceRules",
"AntiBruteForceRulesProps",
"RosAntiBruteForceRules",
"RosAntiBruteForceRulesProps",
]
publication.publish()
def _typecheckingstub__4d1ca3b47ff95113a043d01c7aa76bfef68e765c2d1f3abaf45ce2f15494e790(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Optional[typing.Union[AntiBruteForceRulesProps, typing.Dict[builtins.str, typing.Any]]] = None,
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__f64f587448ff839fa8bc048be4d30edcf94105d208fc64f2644df879de967ef2(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[RosAntiBruteForceRulesProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__af852c024ab9ef0c19eaa6c90cddcb1733a590b39f4cea798badb7e112b71995(
props: typing.Mapping[builtins.str, typing.Any],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__867314675178a12098dcf86b14940fae4b97b9af32c16a157eb256c5eae1d84a(
value: builtins.bool,
) -> None:
"""Type checking stubs"""
pass | /ros-cdk-threatdetection-1.0.17.tar.gz/ros-cdk-threatdetection-1.0.17/src/ros_cdk_threatdetection/datasource/__init__.py | 0.63375 | 0.170923 | __init__.py | pypi |
import abc
import builtins
import datetime
import enum
import typing
import jsii
import publication
import typing_extensions
from typeguard import check_type
from ._jsii import *
import ros_cdk_core as _ros_cdk_core_7adfd82f
class AclRule(
_ros_cdk_core_7adfd82f.Resource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-waf.AclRule",
):
'''A ROS resource type: ``ALIYUN::WAF::AclRule``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["AclRuleProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
'''Create a new ``ALIYUN::WAF::AclRule``.
Param scope - scope in which this resource is defined
Param id - scoped id of the resource
Param props - resource properties
:param scope: -
:param id: -
:param props: -
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__2de49924f3fbceb453f45b2ff3f5ad38218a7ddeccf95d8f93ddeb13767ae3e3)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-waf.AclRuleProps",
jsii_struct_bases=[],
name_mapping={
"domain": "domain",
"instance_id": "instanceId",
"rules": "rules",
"region": "region",
"rule_id": "ruleId",
},
)
class AclRuleProps:
def __init__(
self,
*,
domain: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
instance_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
rules: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
region: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
rule_id: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::WAF::AclRule``.
:param domain: Property domain: Domain name.
:param instance_id: Property instanceId: WAF instance ID. Description Interface You can view your current WAF instance ID by calling DescribePayInfo.
:param rules: Property rules: Detailed information of precise access control rules, expressed in JSON format strings.
:param region: Property region: Examples of areas where the WAF. Value: cn: China mainland (default) cn-hongkong: China HongKong and other overseas
:param rule_id: Property ruleId: Precise access control rule ID.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__a66b9776a33469dcd97701d934b24da04888c6236fe4dc76b6d920c32aeede2e)
check_type(argname="argument domain", value=domain, expected_type=type_hints["domain"])
check_type(argname="argument instance_id", value=instance_id, expected_type=type_hints["instance_id"])
check_type(argname="argument rules", value=rules, expected_type=type_hints["rules"])
check_type(argname="argument region", value=region, expected_type=type_hints["region"])
check_type(argname="argument rule_id", value=rule_id, expected_type=type_hints["rule_id"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"domain": domain,
"instance_id": instance_id,
"rules": rules,
}
if region is not None:
self._values["region"] = region
if rule_id is not None:
self._values["rule_id"] = rule_id
@builtins.property
def domain(self) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property domain: Domain name.'''
result = self._values.get("domain")
assert result is not None, "Required property 'domain' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def instance_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property instanceId: WAF instance ID.
Description Interface You can view your current WAF instance ID by calling DescribePayInfo.
'''
result = self._values.get("instance_id")
assert result is not None, "Required property 'instance_id' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def rules(self) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property rules: Detailed information of precise access control rules, expressed in JSON format strings.'''
result = self._values.get("rules")
assert result is not None, "Required property 'rules' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def region(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property region: Examples of areas where the WAF.
Value:
cn: China mainland (default)
cn-hongkong: China HongKong and other overseas
'''
result = self._values.get("region")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def rule_id(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property ruleId: Precise access control rule ID.'''
result = self._values.get("rule_id")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "AclRuleProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class Domain(
_ros_cdk_core_7adfd82f.Resource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-waf.Domain",
):
'''A ROS resource type: ``ALIYUN::WAF::Domain``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["DomainProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
'''Create a new ``ALIYUN::WAF::Domain``.
Param scope - scope in which this resource is defined
Param id - scoped id of the resource
Param props - resource properties
:param scope: -
:param id: -
:param props: -
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__464df36b8e6d427565e80f096b9ca427e6e2ad4bd4ad73191a1b91fd305696b3)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@builtins.property
@jsii.member(jsii_name="attrClusterType")
def attr_cluster_type(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute ClusterType: Cluster type.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrClusterType"))
@builtins.property
@jsii.member(jsii_name="attrCname")
def attr_cname(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute Cname: CNAME assigned by WAF instance.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrCname"))
@builtins.property
@jsii.member(jsii_name="attrDomainName")
def attr_domain_name(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute DomainName: Domain name.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrDomainName"))
@builtins.property
@jsii.member(jsii_name="attrHttp2Port")
def attr_http2_port(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute Http2Port: Http2 port configuration.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrHttp2Port"))
@builtins.property
@jsii.member(jsii_name="attrHttpPort")
def attr_http_port(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute HttpPort: Http port configuration.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrHttpPort"))
@builtins.property
@jsii.member(jsii_name="attrHttpsPort")
def attr_https_port(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute HttpsPort: Https port configuration.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrHttpsPort"))
@builtins.property
@jsii.member(jsii_name="attrHttpsRedirect")
def attr_https_redirect(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute HttpsRedirect: Https forced redirect configuration.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrHttpsRedirect"))
@builtins.property
@jsii.member(jsii_name="attrHttpToUserIp")
def attr_http_to_user_ip(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute HttpToUserIp: Http back to source.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrHttpToUserIp"))
@builtins.property
@jsii.member(jsii_name="attrInstanceId")
def attr_instance_id(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute InstanceId: Instance id.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrInstanceId"))
@builtins.property
@jsii.member(jsii_name="attrIsAccessProduct")
def attr_is_access_product(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute IsAccessProduct: Is there a seven-layer agency before WAF.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrIsAccessProduct"))
@builtins.property
@jsii.member(jsii_name="attrLoadBalancing")
def attr_load_balancing(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute LoadBalancing: Load balancing configuration.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrLoadBalancing"))
@builtins.property
@jsii.member(jsii_name="attrLogHeaders")
def attr_log_headers(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute LogHeaders: Domain traffic tagging.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrLogHeaders"))
@builtins.property
@jsii.member(jsii_name="attrResourceGroupId")
def attr_resource_group_id(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute ResourceGroupId: Resource group Id.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrResourceGroupId"))
@builtins.property
@jsii.member(jsii_name="attrSourceIps")
def attr_source_ips(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute SourceIps: Back to source IP configuration.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrSourceIps"))
@builtins.property
@jsii.member(jsii_name="attrVersion")
def attr_version(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute Version: Optimistic lock version.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrVersion"))
class DomainConfig(
_ros_cdk_core_7adfd82f.Resource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-waf.DomainConfig",
):
'''A ROS resource type: ``ALIYUN::WAF::DomainConfig``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["DomainConfigProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
'''Create a new ``ALIYUN::WAF::DomainConfig``.
Param scope - scope in which this resource is defined
Param id - scoped id of the resource
Param props - resource properties
:param scope: -
:param id: -
:param props: -
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__5d3b0679966e32e3587b3ffedda67491d53c3c5b3aca714482dcb86fb7aa5c39)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@builtins.property
@jsii.member(jsii_name="attrCname")
def attr_cname(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute Cname: CNAME assigned by WAF instance.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrCname"))
@builtins.property
@jsii.member(jsii_name="attrProtocolType")
def attr_protocol_type(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute ProtocolType: agreement type:0: indicates that the HTTP protocol is supported.1: indicates that the HTTPS protocol is supported.2: indicates that both HTTP and HTTPS protocols are supported.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrProtocolType"))
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-waf.DomainConfigProps",
jsii_struct_bases=[],
name_mapping={
"domain": "domain",
"instance_id": "instanceId",
"is_access_product": "isAccessProduct",
"protocols": "protocols",
"http_port": "httpPort",
"https_port": "httpsPort",
"https_redirect": "httpsRedirect",
"http_to_user_ip": "httpToUserIp",
"load_balancing": "loadBalancing",
"region": "region",
"rs_type": "rsType",
"source_ips": "sourceIps",
},
)
class DomainConfigProps:
def __init__(
self,
*,
domain: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
instance_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
is_access_product: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
protocols: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
http_port: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
https_port: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
https_redirect: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
http_to_user_ip: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
load_balancing: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
region: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
rs_type: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
source_ips: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::WAF::DomainConfig``.
:param domain: Property domain: Domain name.
:param instance_id: Property instanceId: WAF instance ID. Description Interface You can view your current WAF instance ID by calling DescribePayInfo.
:param is_access_product: Property isAccessProduct: The domain before WAF is configured with seven agents (eg, high defense, CDN, etc.), the value of: 0: none. 1: expressed.
:param protocols: Property protocols: The domain supports access protocols, values: http: expressed support for the HTTP protocol. https: support for HTTPS protocol. http, https: supports HTTP, HTTPS protocol.
:param http_port: Property httpPort: HTTP protocol configuration port. When specifying a plurality of HTTP port "," separated. Example values: [80]. Configure the HTTP protocol, this parameter is required. The default value is 80. HttpPort HttpsPort with at least two parameters need to fill a request.
:param https_port: Property httpsPort: HTTPS protocol configuration port. When specifying a plurality HTTPS port, using the "," separated. Example values: [443]. Configure the protocol is HTTPS, this parameter is required. The default value is 443. HttpPort HttpsPort with at least two parameters need to fill a request.
:param https_redirect: Property httpsRedirect: HTTPS is turned forcefully jump the argument: 0: off (default) 1: Turn Description required to complete the request parameters using only HTTPS access protocol. After opening force will show a jump HTTP request is HTTPS, a default jump to 443.
:param http_to_user_ip: Property httpToUserIp: Whether to open HTTPS access request is forwarded back to the source station via the HTTP protocol, the value of: 0: off (default) 1: Turn Note If your site does not support HTTPS back to the source, open source HTTP return (default back to the source port is port 80) function key, can be realized by WAF HTTPS access.
:param load_balancing: Property loadBalancing: Back to the source load balancing policy values: 0: IP Hash way. 1: represents a polling mode.
:param region: Property region: Examples of areas where the WAF. Value: cn: China mainland (default) cn-hongkong: China HongKong and other overseas
:param rs_type: Property rsType: Back to the source address type the domain name values: 0: back to the source to IP. 1: Indicates the domain name back to the source.
:param source_ips: Property sourceIps: Source station IP, supports a plurality of specified IP. Example values: [ "1.1.1.1"].
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__70bdf7bb9a6ebd5d1855e05758f57d06913e6d4d48eb859f131a128f1bd7a407)
check_type(argname="argument domain", value=domain, expected_type=type_hints["domain"])
check_type(argname="argument instance_id", value=instance_id, expected_type=type_hints["instance_id"])
check_type(argname="argument is_access_product", value=is_access_product, expected_type=type_hints["is_access_product"])
check_type(argname="argument protocols", value=protocols, expected_type=type_hints["protocols"])
check_type(argname="argument http_port", value=http_port, expected_type=type_hints["http_port"])
check_type(argname="argument https_port", value=https_port, expected_type=type_hints["https_port"])
check_type(argname="argument https_redirect", value=https_redirect, expected_type=type_hints["https_redirect"])
check_type(argname="argument http_to_user_ip", value=http_to_user_ip, expected_type=type_hints["http_to_user_ip"])
check_type(argname="argument load_balancing", value=load_balancing, expected_type=type_hints["load_balancing"])
check_type(argname="argument region", value=region, expected_type=type_hints["region"])
check_type(argname="argument rs_type", value=rs_type, expected_type=type_hints["rs_type"])
check_type(argname="argument source_ips", value=source_ips, expected_type=type_hints["source_ips"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"domain": domain,
"instance_id": instance_id,
"is_access_product": is_access_product,
"protocols": protocols,
}
if http_port is not None:
self._values["http_port"] = http_port
if https_port is not None:
self._values["https_port"] = https_port
if https_redirect is not None:
self._values["https_redirect"] = https_redirect
if http_to_user_ip is not None:
self._values["http_to_user_ip"] = http_to_user_ip
if load_balancing is not None:
self._values["load_balancing"] = load_balancing
if region is not None:
self._values["region"] = region
if rs_type is not None:
self._values["rs_type"] = rs_type
if source_ips is not None:
self._values["source_ips"] = source_ips
@builtins.property
def domain(self) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property domain: Domain name.'''
result = self._values.get("domain")
assert result is not None, "Required property 'domain' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def instance_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property instanceId: WAF instance ID.
Description Interface You can view your current WAF instance ID by calling DescribePayInfo.
'''
result = self._values.get("instance_id")
assert result is not None, "Required property 'instance_id' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def is_access_product(
self,
) -> typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property isAccessProduct: The domain before WAF is configured with seven agents (eg, high defense, CDN, etc.), the value of: 0: none. 1: expressed.'''
result = self._values.get("is_access_product")
assert result is not None, "Required property 'is_access_product' is missing"
return typing.cast(typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def protocols(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property protocols: The domain supports access protocols, values: http: expressed support for the HTTP protocol.
https: support for HTTPS protocol.
http, https: supports HTTP, HTTPS protocol.
'''
result = self._values.get("protocols")
assert result is not None, "Required property 'protocols' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def http_port(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property httpPort: HTTP protocol configuration port.
When specifying a plurality of HTTP port "," separated. Example values: [80].
Configure the HTTP protocol, this parameter is required. The default value is 80. HttpPort HttpsPort with at least two parameters need to fill a request.
'''
result = self._values.get("http_port")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def https_port(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property httpsPort: HTTPS protocol configuration port.
When specifying a plurality HTTPS port, using the "," separated. Example values: [443].
Configure the protocol is HTTPS, this parameter is required. The default value is 443. HttpPort HttpsPort with at least two parameters need to fill a request.
'''
result = self._values.get("https_port")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def https_redirect(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property httpsRedirect: HTTPS is turned forcefully jump the argument: 0: off (default) 1: Turn Description required to complete the request parameters using only HTTPS access protocol.
After opening force will show a jump HTTP request is HTTPS, a default jump to 443.
'''
result = self._values.get("https_redirect")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def http_to_user_ip(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property httpToUserIp: Whether to open HTTPS access request is forwarded back to the source station via the HTTP protocol, the value of: 0: off (default) 1: Turn Note If your site does not support HTTPS back to the source, open source HTTP return (default back to the source port is port 80) function key, can be realized by WAF HTTPS access.'''
result = self._values.get("http_to_user_ip")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def load_balancing(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property loadBalancing: Back to the source load balancing policy values: 0: IP Hash way.
1: represents a polling mode.
'''
result = self._values.get("load_balancing")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def region(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property region: Examples of areas where the WAF.
Value:
cn: China mainland (default)
cn-hongkong: China HongKong and other overseas
'''
result = self._values.get("region")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def rs_type(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property rsType: Back to the source address type the domain name values: 0: back to the source to IP.
1: Indicates the domain name back to the source.
'''
result = self._values.get("rs_type")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def source_ips(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property sourceIps: Source station IP, supports a plurality of specified IP.
Example values: [ "1.1.1.1"].
'''
result = self._values.get("source_ips")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "DomainConfigProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-waf.DomainProps",
jsii_struct_bases=[],
name_mapping={
"domain_name": "domainName",
"instance_id": "instanceId",
"is_access_product": "isAccessProduct",
"source_ips": "sourceIps",
"cluster_type": "clusterType",
"connection_time": "connectionTime",
"http2_port": "http2Port",
"http_port": "httpPort",
"https_port": "httpsPort",
"https_redirect": "httpsRedirect",
"http_to_user_ip": "httpToUserIp",
"load_balancing": "loadBalancing",
"log_headers": "logHeaders",
"read_time": "readTime",
"resource_group_id": "resourceGroupId",
"write_time": "writeTime",
},
)
class DomainProps:
def __init__(
self,
*,
domain_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
instance_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
is_access_product: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
source_ips: typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]],
cluster_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
connection_time: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
http2_port: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]] = None,
http_port: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]] = None,
https_port: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]] = None,
https_redirect: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
http_to_user_ip: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
load_balancing: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
log_headers: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union["RosDomain.LogHeadersProperty", typing.Dict[builtins.str, typing.Any]]]]]] = None,
read_time: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
resource_group_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
write_time: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::WAF::Domain``.
:param domain_name: Property domainName: Domain name.
:param instance_id: Property instanceId: Instance id.
:param is_access_product: Property isAccessProduct: Is there a seven-layer agency before WAF.
:param source_ips: Property sourceIps: Back to source IP configuration.
:param cluster_type: Property clusterType: Cluster type.
:param connection_time: Property connectionTime: Connection timeout.
:param http2_port: Property http2Port: Http2 port configuration.
:param http_port: Property httpPort: Http port configuration.
:param https_port: Property httpsPort: Https port configuration.
:param https_redirect: Property httpsRedirect: Https forced redirect configuration.
:param http_to_user_ip: Property httpToUserIp: Http back to source.
:param load_balancing: Property loadBalancing: Load balancing configuration.
:param log_headers: Property logHeaders: Domain traffic tagging.
:param read_time: Property readTime: Read connection timeout period.
:param resource_group_id: Property resourceGroupId: Resource group Id.
:param write_time: Property writeTime: Write connection timeout period.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__eb3b68012c4c48777067cebfa980d3385e395a3b8b8851bf1750081507a0a5d9)
check_type(argname="argument domain_name", value=domain_name, expected_type=type_hints["domain_name"])
check_type(argname="argument instance_id", value=instance_id, expected_type=type_hints["instance_id"])
check_type(argname="argument is_access_product", value=is_access_product, expected_type=type_hints["is_access_product"])
check_type(argname="argument source_ips", value=source_ips, expected_type=type_hints["source_ips"])
check_type(argname="argument cluster_type", value=cluster_type, expected_type=type_hints["cluster_type"])
check_type(argname="argument connection_time", value=connection_time, expected_type=type_hints["connection_time"])
check_type(argname="argument http2_port", value=http2_port, expected_type=type_hints["http2_port"])
check_type(argname="argument http_port", value=http_port, expected_type=type_hints["http_port"])
check_type(argname="argument https_port", value=https_port, expected_type=type_hints["https_port"])
check_type(argname="argument https_redirect", value=https_redirect, expected_type=type_hints["https_redirect"])
check_type(argname="argument http_to_user_ip", value=http_to_user_ip, expected_type=type_hints["http_to_user_ip"])
check_type(argname="argument load_balancing", value=load_balancing, expected_type=type_hints["load_balancing"])
check_type(argname="argument log_headers", value=log_headers, expected_type=type_hints["log_headers"])
check_type(argname="argument read_time", value=read_time, expected_type=type_hints["read_time"])
check_type(argname="argument resource_group_id", value=resource_group_id, expected_type=type_hints["resource_group_id"])
check_type(argname="argument write_time", value=write_time, expected_type=type_hints["write_time"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"domain_name": domain_name,
"instance_id": instance_id,
"is_access_product": is_access_product,
"source_ips": source_ips,
}
if cluster_type is not None:
self._values["cluster_type"] = cluster_type
if connection_time is not None:
self._values["connection_time"] = connection_time
if http2_port is not None:
self._values["http2_port"] = http2_port
if http_port is not None:
self._values["http_port"] = http_port
if https_port is not None:
self._values["https_port"] = https_port
if https_redirect is not None:
self._values["https_redirect"] = https_redirect
if http_to_user_ip is not None:
self._values["http_to_user_ip"] = http_to_user_ip
if load_balancing is not None:
self._values["load_balancing"] = load_balancing
if log_headers is not None:
self._values["log_headers"] = log_headers
if read_time is not None:
self._values["read_time"] = read_time
if resource_group_id is not None:
self._values["resource_group_id"] = resource_group_id
if write_time is not None:
self._values["write_time"] = write_time
@builtins.property
def domain_name(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property domainName: Domain name.'''
result = self._values.get("domain_name")
assert result is not None, "Required property 'domain_name' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def instance_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property instanceId: Instance id.'''
result = self._values.get("instance_id")
assert result is not None, "Required property 'instance_id' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def is_access_product(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property isAccessProduct: Is there a seven-layer agency before WAF.'''
result = self._values.get("is_access_product")
assert result is not None, "Required property 'is_access_product' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def source_ips(
self,
) -> typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]:
'''Property sourceIps: Back to source IP configuration.'''
result = self._values.get("source_ips")
assert result is not None, "Required property 'source_ips' is missing"
return typing.cast(typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]], result)
@builtins.property
def cluster_type(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property clusterType: Cluster type.'''
result = self._values.get("cluster_type")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def connection_time(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property connectionTime: Connection timeout.'''
result = self._values.get("connection_time")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def http2_port(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]]:
'''Property http2Port: Http2 port configuration.'''
result = self._values.get("http2_port")
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]], result)
@builtins.property
def http_port(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]]:
'''Property httpPort: Http port configuration.'''
result = self._values.get("http_port")
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]], result)
@builtins.property
def https_port(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]]:
'''Property httpsPort: Https port configuration.'''
result = self._values.get("https_port")
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]], result)
@builtins.property
def https_redirect(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property httpsRedirect: Https forced redirect configuration.'''
result = self._values.get("https_redirect")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def http_to_user_ip(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property httpToUserIp: Http back to source.'''
result = self._values.get("http_to_user_ip")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def load_balancing(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property loadBalancing: Load balancing configuration.'''
result = self._values.get("load_balancing")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def log_headers(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosDomain.LogHeadersProperty"]]]]:
'''Property logHeaders: Domain traffic tagging.'''
result = self._values.get("log_headers")
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosDomain.LogHeadersProperty"]]]], result)
@builtins.property
def read_time(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property readTime: Read connection timeout period.'''
result = self._values.get("read_time")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def resource_group_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property resourceGroupId: Resource group Id.'''
result = self._values.get("resource_group_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def write_time(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property writeTime: Write connection timeout period.'''
result = self._values.get("write_time")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "DomainProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class Instance(
_ros_cdk_core_7adfd82f.Resource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-waf.Instance",
):
'''A ROS resource type: ``ALIYUN::WAF::Instance``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["InstanceProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
'''Create a new ``ALIYUN::WAF::Instance``.
Param scope - scope in which this resource is defined
Param id - scoped id of the resource
Param props - resource properties
:param scope: -
:param id: -
:param props: -
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__865684754cd3828eaf27fdafeeb9db069d768face8c5a95e3ec2c3c98b0c5ef3)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@builtins.property
@jsii.member(jsii_name="attrEndDate")
def attr_end_date(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute EndDate: Due date of the instance.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrEndDate"))
@builtins.property
@jsii.member(jsii_name="attrInDebt")
def attr_in_debt(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute InDebt: Instance is overdue.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrInDebt"))
@builtins.property
@jsii.member(jsii_name="attrInstanceId")
def attr_instance_id(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute InstanceId: Instance ID.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrInstanceId"))
@builtins.property
@jsii.member(jsii_name="attrRemainDay")
def attr_remain_day(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute RemainDay: Number of available days for WAF Trial version.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrRemainDay"))
@builtins.property
@jsii.member(jsii_name="attrSubscriptionType")
def attr_subscription_type(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute SubscriptionType: Subscription type of the instance.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrSubscriptionType"))
@builtins.property
@jsii.member(jsii_name="attrTrial")
def attr_trial(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute Trial: Trial version.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrTrial"))
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-waf.InstanceProps",
jsii_struct_bases=[],
name_mapping={
"big_screen": "bigScreen",
"exclusive_ip_package": "exclusiveIpPackage",
"ext_bandwidth": "extBandwidth",
"ext_domain_package": "extDomainPackage",
"log_storage": "logStorage",
"log_time": "logTime",
"package_code": "packageCode",
"prefessional_service": "prefessionalService",
"subscription_type": "subscriptionType",
"waf_log": "wafLog",
"period": "period",
"renewal_status": "renewalStatus",
"renew_period": "renewPeriod",
},
)
class InstanceProps:
def __init__(
self,
*,
big_screen: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
exclusive_ip_package: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
ext_bandwidth: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
ext_domain_package: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
log_storage: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
log_time: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
package_code: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
prefessional_service: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
subscription_type: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
waf_log: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
period: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
renewal_status: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
renew_period: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::WAF::Instance``.
:param big_screen: Property bigScreen:.
:param exclusive_ip_package: Property exclusiveIpPackage:.
:param ext_bandwidth: Property extBandwidth:.
:param ext_domain_package: Property extDomainPackage:.
:param log_storage: Property logStorage:.
:param log_time: Property logTime:.
:param package_code: Property packageCode:.
:param prefessional_service: Property prefessionalService:.
:param subscription_type: Property subscriptionType: Subscription type of the instance.
:param waf_log: Property wafLog:.
:param period: Property period:.
:param renewal_status: Property renewalStatus:.
:param renew_period: Property renewPeriod:.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__43a17fa5ea24779c202068b99acdc06cba416ef7cc3ddf08640349b6c982dba8)
check_type(argname="argument big_screen", value=big_screen, expected_type=type_hints["big_screen"])
check_type(argname="argument exclusive_ip_package", value=exclusive_ip_package, expected_type=type_hints["exclusive_ip_package"])
check_type(argname="argument ext_bandwidth", value=ext_bandwidth, expected_type=type_hints["ext_bandwidth"])
check_type(argname="argument ext_domain_package", value=ext_domain_package, expected_type=type_hints["ext_domain_package"])
check_type(argname="argument log_storage", value=log_storage, expected_type=type_hints["log_storage"])
check_type(argname="argument log_time", value=log_time, expected_type=type_hints["log_time"])
check_type(argname="argument package_code", value=package_code, expected_type=type_hints["package_code"])
check_type(argname="argument prefessional_service", value=prefessional_service, expected_type=type_hints["prefessional_service"])
check_type(argname="argument subscription_type", value=subscription_type, expected_type=type_hints["subscription_type"])
check_type(argname="argument waf_log", value=waf_log, expected_type=type_hints["waf_log"])
check_type(argname="argument period", value=period, expected_type=type_hints["period"])
check_type(argname="argument renewal_status", value=renewal_status, expected_type=type_hints["renewal_status"])
check_type(argname="argument renew_period", value=renew_period, expected_type=type_hints["renew_period"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"big_screen": big_screen,
"exclusive_ip_package": exclusive_ip_package,
"ext_bandwidth": ext_bandwidth,
"ext_domain_package": ext_domain_package,
"log_storage": log_storage,
"log_time": log_time,
"package_code": package_code,
"prefessional_service": prefessional_service,
"subscription_type": subscription_type,
"waf_log": waf_log,
}
if period is not None:
self._values["period"] = period
if renewal_status is not None:
self._values["renewal_status"] = renewal_status
if renew_period is not None:
self._values["renew_period"] = renew_period
@builtins.property
def big_screen(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property bigScreen:.'''
result = self._values.get("big_screen")
assert result is not None, "Required property 'big_screen' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def exclusive_ip_package(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property exclusiveIpPackage:.'''
result = self._values.get("exclusive_ip_package")
assert result is not None, "Required property 'exclusive_ip_package' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def ext_bandwidth(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property extBandwidth:.'''
result = self._values.get("ext_bandwidth")
assert result is not None, "Required property 'ext_bandwidth' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def ext_domain_package(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property extDomainPackage:.'''
result = self._values.get("ext_domain_package")
assert result is not None, "Required property 'ext_domain_package' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def log_storage(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property logStorage:.'''
result = self._values.get("log_storage")
assert result is not None, "Required property 'log_storage' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def log_time(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property logTime:.'''
result = self._values.get("log_time")
assert result is not None, "Required property 'log_time' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def package_code(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property packageCode:.'''
result = self._values.get("package_code")
assert result is not None, "Required property 'package_code' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def prefessional_service(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property prefessionalService:.'''
result = self._values.get("prefessional_service")
assert result is not None, "Required property 'prefessional_service' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def subscription_type(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property subscriptionType: Subscription type of the instance.'''
result = self._values.get("subscription_type")
assert result is not None, "Required property 'subscription_type' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def waf_log(self) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property wafLog:.'''
result = self._values.get("waf_log")
assert result is not None, "Required property 'waf_log' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def period(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property period:.'''
result = self._values.get("period")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def renewal_status(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property renewalStatus:.'''
result = self._values.get("renewal_status")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def renew_period(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property renewPeriod:.'''
result = self._values.get("renew_period")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "InstanceProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class LogServiceEnable(
_ros_cdk_core_7adfd82f.Resource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-waf.LogServiceEnable",
):
'''A ROS resource type: ``ALIYUN::WAF::LogServiceEnable``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["LogServiceEnableProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
'''Create a new ``ALIYUN::WAF::LogServiceEnable``.
Param scope - scope in which this resource is defined
Param id - scoped id of the resource
Param props - resource properties
:param scope: -
:param id: -
:param props: -
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__f695b59c454d396613800620218c0b44354bb4d0fdad8ad7501a734bb0ee47c1)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@builtins.property
@jsii.member(jsii_name="attrDomain")
def attr_domain(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute Domain: The domain name that is added to WAF.'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrDomain"))
@builtins.property
@jsii.member(jsii_name="attrInstanceId")
def attr_instance_id(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''Attribute InstanceId: The ID of the WAF instance.
You can call the DescribeInstanceInfo operation to query the ID of the WAF instance.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrInstanceId"))
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-waf.LogServiceEnableProps",
jsii_struct_bases=[],
name_mapping={"domain": "domain", "instance_id": "instanceId"},
)
class LogServiceEnableProps:
def __init__(
self,
*,
domain: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
instance_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
'''Properties for defining a ``ALIYUN::WAF::LogServiceEnable``.
:param domain: Property domain: The domain name that is added to WAF.
:param instance_id: Property instanceId: The ID of the WAF instance. You can call the DescribeInstanceInfo operation to query the ID of the WAF instance.
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__992cd75383e2b392161ee3fa6243de9ee05983185934c552a6b18182ae5bbb8c)
check_type(argname="argument domain", value=domain, expected_type=type_hints["domain"])
check_type(argname="argument instance_id", value=instance_id, expected_type=type_hints["instance_id"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"domain": domain,
"instance_id": instance_id,
}
@builtins.property
def domain(self) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property domain: The domain name that is added to WAF.'''
result = self._values.get("domain")
assert result is not None, "Required property 'domain' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def instance_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property instanceId: The ID of the WAF instance.
You can call the DescribeInstanceInfo operation to query the ID of the WAF instance.
'''
result = self._values.get("instance_id")
assert result is not None, "Required property 'instance_id' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "LogServiceEnableProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class RosAclRule(
_ros_cdk_core_7adfd82f.RosResource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-waf.RosAclRule",
):
'''A ROS template type: ``ALIYUN::WAF::AclRule``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["RosAclRuleProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
'''Create a new ``ALIYUN::WAF::AclRule``.
:param scope: - scope in which this resource is defined.
:param id: - scoped id of the resource.
:param props: - resource properties.
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__91366ac47dd17fe495e6197496f5cbfe29ff7ef18db69ef51195bc7ec187b475)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@jsii.member(jsii_name="renderProperties")
def _render_properties(
self,
props: typing.Mapping[builtins.str, typing.Any],
) -> typing.Mapping[builtins.str, typing.Any]:
'''
:param props: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__63c8efc8f61a16747489d1a4a2365b710bea515a56ee9627907a97b12b835aaf)
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))
@jsii.python.classproperty
@jsii.member(jsii_name="ROS_RESOURCE_TYPE_NAME")
def ROS_RESOURCE_TYPE_NAME(cls) -> builtins.str:
'''The resource type name for this resource class.'''
return typing.cast(builtins.str, jsii.sget(cls, "ROS_RESOURCE_TYPE_NAME"))
@builtins.property
@jsii.member(jsii_name="rosProperties")
def _ros_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "rosProperties"))
@builtins.property
@jsii.member(jsii_name="domain")
def domain(self) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: domain: Domain name.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "domain"))
@domain.setter
def domain(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__cd74c4fdd6076b3f11dce7870ad0a92dea4a866b5b0872112668fb7ec90560f1)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "domain", value)
@builtins.property
@jsii.member(jsii_name="enableResourcePropertyConstraint")
def enable_resource_property_constraint(self) -> builtins.bool:
'''A factory method that creates a new instance of this class from an object containing the properties of this ROS resource.'''
return typing.cast(builtins.bool, jsii.get(self, "enableResourcePropertyConstraint"))
@enable_resource_property_constraint.setter
def enable_resource_property_constraint(self, value: builtins.bool) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__55913d9b9ae6cb7abb7f5005e84e60701b4356d9343a95f52b3c3c61394e10a6)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "enableResourcePropertyConstraint", value)
@builtins.property
@jsii.member(jsii_name="instanceId")
def instance_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
instanceId: WAF instance ID.
Description Interface You can view your current WAF instance ID by calling DescribePayInfo.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "instanceId"))
@instance_id.setter
def instance_id(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__ab28e35f904b2d2de860fc995c2c71352412a6356c74e3cd653850f32897d613)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "instanceId", value)
@builtins.property
@jsii.member(jsii_name="rules")
def rules(self) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: rules: Detailed information of precise access control rules, expressed in JSON format strings.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "rules"))
@rules.setter
def rules(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__64c5fb4547d952a7eefdf0fa49c3fe5d8539a5d76249ddee92c68f4116775dc5)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "rules", value)
@builtins.property
@jsii.member(jsii_name="region")
def region(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
region: Examples of areas where the WAF. Value:
cn: China mainland (default)
cn-hongkong: China HongKong and other overseas
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "region"))
@region.setter
def region(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__b68ad4595d6331b5668ec69a50cf200857a327f083559deed7d26d3ea1191d7d)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "region", value)
@builtins.property
@jsii.member(jsii_name="ruleId")
def rule_id(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: ruleId: Precise access control rule ID
'''
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "ruleId"))
@rule_id.setter
def rule_id(
self,
value: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__6f185055da1831e37b7e0c7a7a19ee7c92f6616b086ffc5735cf6eb031d4ba1c)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "ruleId", value)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-waf.RosAclRuleProps",
jsii_struct_bases=[],
name_mapping={
"domain": "domain",
"instance_id": "instanceId",
"rules": "rules",
"region": "region",
"rule_id": "ruleId",
},
)
class RosAclRuleProps:
def __init__(
self,
*,
domain: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
instance_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
rules: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
region: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
rule_id: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::WAF::AclRule``.
:param domain:
:param instance_id:
:param rules:
:param region:
:param rule_id:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__3128f81577aa6f6d0dcf831565d98804f88591ce039bfbac2bfe2d53db7e1f11)
check_type(argname="argument domain", value=domain, expected_type=type_hints["domain"])
check_type(argname="argument instance_id", value=instance_id, expected_type=type_hints["instance_id"])
check_type(argname="argument rules", value=rules, expected_type=type_hints["rules"])
check_type(argname="argument region", value=region, expected_type=type_hints["region"])
check_type(argname="argument rule_id", value=rule_id, expected_type=type_hints["rule_id"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"domain": domain,
"instance_id": instance_id,
"rules": rules,
}
if region is not None:
self._values["region"] = region
if rule_id is not None:
self._values["rule_id"] = rule_id
@builtins.property
def domain(self) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: domain: Domain name.
'''
result = self._values.get("domain")
assert result is not None, "Required property 'domain' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def instance_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
instanceId: WAF instance ID.
Description Interface You can view your current WAF instance ID by calling DescribePayInfo.
'''
result = self._values.get("instance_id")
assert result is not None, "Required property 'instance_id' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def rules(self) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: rules: Detailed information of precise access control rules, expressed in JSON format strings.
'''
result = self._values.get("rules")
assert result is not None, "Required property 'rules' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def region(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
region: Examples of areas where the WAF. Value:
cn: China mainland (default)
cn-hongkong: China HongKong and other overseas
'''
result = self._values.get("region")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def rule_id(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: ruleId: Precise access control rule ID
'''
result = self._values.get("rule_id")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "RosAclRuleProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class RosDomain(
_ros_cdk_core_7adfd82f.RosResource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-waf.RosDomain",
):
'''A ROS template type: ``ALIYUN::WAF::Domain``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["RosDomainProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
'''Create a new ``ALIYUN::WAF::Domain``.
:param scope: - scope in which this resource is defined.
:param id: - scoped id of the resource.
:param props: - resource properties.
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__10adf4d36dc029495a749e9d3e9fc03f8aa9b481cbb61a9d730fec43a4f3c696)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@jsii.member(jsii_name="renderProperties")
def _render_properties(
self,
props: typing.Mapping[builtins.str, typing.Any],
) -> typing.Mapping[builtins.str, typing.Any]:
'''
:param props: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__f8c44991fabe9afe9de7e257f2e3f1929ea02ae7229052a2444138a9b1ac98f2)
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))
@jsii.python.classproperty
@jsii.member(jsii_name="ROS_RESOURCE_TYPE_NAME")
def ROS_RESOURCE_TYPE_NAME(cls) -> builtins.str:
'''The resource type name for this resource class.'''
return typing.cast(builtins.str, jsii.sget(cls, "ROS_RESOURCE_TYPE_NAME"))
@builtins.property
@jsii.member(jsii_name="attrClusterType")
def attr_cluster_type(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: ClusterType: Cluster type
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrClusterType"))
@builtins.property
@jsii.member(jsii_name="attrCname")
def attr_cname(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: Cname: CNAME assigned by WAF instance
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrCname"))
@builtins.property
@jsii.member(jsii_name="attrDomainName")
def attr_domain_name(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: DomainName: Domain name
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrDomainName"))
@builtins.property
@jsii.member(jsii_name="attrHttp2Port")
def attr_http2_port(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: Http2Port: Http2 port configuration
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrHttp2Port"))
@builtins.property
@jsii.member(jsii_name="attrHttpPort")
def attr_http_port(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: HttpPort: Http port configuration
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrHttpPort"))
@builtins.property
@jsii.member(jsii_name="attrHttpsPort")
def attr_https_port(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: HttpsPort: Https port configuration
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrHttpsPort"))
@builtins.property
@jsii.member(jsii_name="attrHttpsRedirect")
def attr_https_redirect(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: HttpsRedirect: Https forced redirect configuration
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrHttpsRedirect"))
@builtins.property
@jsii.member(jsii_name="attrHttpToUserIp")
def attr_http_to_user_ip(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: HttpToUserIp: Http back to source
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrHttpToUserIp"))
@builtins.property
@jsii.member(jsii_name="attrInstanceId")
def attr_instance_id(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: InstanceId: Instance id
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrInstanceId"))
@builtins.property
@jsii.member(jsii_name="attrIsAccessProduct")
def attr_is_access_product(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: IsAccessProduct: Is there a seven-layer agency before WAF
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrIsAccessProduct"))
@builtins.property
@jsii.member(jsii_name="attrLoadBalancing")
def attr_load_balancing(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: LoadBalancing: Load balancing configuration
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrLoadBalancing"))
@builtins.property
@jsii.member(jsii_name="attrLogHeaders")
def attr_log_headers(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: LogHeaders: Domain traffic tagging
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrLogHeaders"))
@builtins.property
@jsii.member(jsii_name="attrResourceGroupId")
def attr_resource_group_id(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: ResourceGroupId: Resource group Id
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrResourceGroupId"))
@builtins.property
@jsii.member(jsii_name="attrSourceIps")
def attr_source_ips(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: SourceIps: Back to source IP configuration
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrSourceIps"))
@builtins.property
@jsii.member(jsii_name="attrVersion")
def attr_version(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: Version: Optimistic lock version
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrVersion"))
@builtins.property
@jsii.member(jsii_name="rosProperties")
def _ros_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "rosProperties"))
@builtins.property
@jsii.member(jsii_name="domainName")
def domain_name(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: domainName: Domain name
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "domainName"))
@domain_name.setter
def domain_name(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__86cbf180a8334b95c5c55a9d22f8dd5628ff114051c6e988572ddb32e861c558)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "domainName", value)
@builtins.property
@jsii.member(jsii_name="enableResourcePropertyConstraint")
def enable_resource_property_constraint(self) -> builtins.bool:
return typing.cast(builtins.bool, jsii.get(self, "enableResourcePropertyConstraint"))
@enable_resource_property_constraint.setter
def enable_resource_property_constraint(self, value: builtins.bool) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__ecadc7980502a4b81787de4173b6612cf8913540ef5926f4dcb2b20ee4e8f63c)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "enableResourcePropertyConstraint", value)
@builtins.property
@jsii.member(jsii_name="instanceId")
def instance_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: instanceId: Instance id
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "instanceId"))
@instance_id.setter
def instance_id(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__ef37d9a68bb14afc25f01a6473da8bb344a3a0a10091d77e5d040d7d6d8e1e21)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "instanceId", value)
@builtins.property
@jsii.member(jsii_name="isAccessProduct")
def is_access_product(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: isAccessProduct: Is there a seven-layer agency before WAF
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "isAccessProduct"))
@is_access_product.setter
def is_access_product(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__cd03066e0bf4ed8f79c6ce9a25574c7abde110bb35b7f62c574a4ba43538fdac)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "isAccessProduct", value)
@builtins.property
@jsii.member(jsii_name="sourceIps")
def source_ips(
self,
) -> typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]:
'''
:Property: sourceIps: Back to source IP configuration
'''
return typing.cast(typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]], jsii.get(self, "sourceIps"))
@source_ips.setter
def source_ips(
self,
value: typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__3b55868db5d8bce373663a8d7df3b604fb32a22beaf61d30b4786dec8d1f46ac)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "sourceIps", value)
@builtins.property
@jsii.member(jsii_name="clusterType")
def cluster_type(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: clusterType: Cluster type
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "clusterType"))
@cluster_type.setter
def cluster_type(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__d0692085a7e0272a407a66cf9dd9ef971c84d975b1fc836887898820853e0130)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "clusterType", value)
@builtins.property
@jsii.member(jsii_name="connectionTime")
def connection_time(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: connectionTime: Connection timeout
'''
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "connectionTime"))
@connection_time.setter
def connection_time(
self,
value: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__548a0c9666038823c5b553f5f976da708e9619f8bdf99007bc3b52be6d55a8e7)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "connectionTime", value)
@builtins.property
@jsii.member(jsii_name="http2Port")
def http2_port(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]]:
'''
:Property: http2Port: Http2 port configuration
'''
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]], jsii.get(self, "http2Port"))
@http2_port.setter
def http2_port(
self,
value: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__d5edb493193e73a297ad5109964cf26399718e02f9637cd1c83e310921b67756)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "http2Port", value)
@builtins.property
@jsii.member(jsii_name="httpPort")
def http_port(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]]:
'''
:Property: httpPort: Http port configuration
'''
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]], jsii.get(self, "httpPort"))
@http_port.setter
def http_port(
self,
value: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__bf4a2e0135d01b001b7042eafa16281524cf505ebc4f6a2eb9a915e19e314a1a)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "httpPort", value)
@builtins.property
@jsii.member(jsii_name="httpsPort")
def https_port(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]]:
'''
:Property: httpsPort: Https port configuration
'''
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]], jsii.get(self, "httpsPort"))
@https_port.setter
def https_port(
self,
value: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__e0730cdc94e23794b1b308b8e23ffde48b735dd3f321ae7406555b2bd14fea43)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "httpsPort", value)
@builtins.property
@jsii.member(jsii_name="httpsRedirect")
def https_redirect(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: httpsRedirect: Https forced redirect configuration
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "httpsRedirect"))
@https_redirect.setter
def https_redirect(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__b3a7a831ca7b855a903a8d5b2613ae7156caf55a19e706e1bcd398b5d2c805eb)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "httpsRedirect", value)
@builtins.property
@jsii.member(jsii_name="httpToUserIp")
def http_to_user_ip(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: httpToUserIp: Http back to source
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "httpToUserIp"))
@http_to_user_ip.setter
def http_to_user_ip(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__42595eb12037b41b9aeec203baf98dfc53f04f56d4c96da61d2fe1142bc74ef8)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "httpToUserIp", value)
@builtins.property
@jsii.member(jsii_name="loadBalancing")
def load_balancing(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: loadBalancing: Load balancing configuration
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "loadBalancing"))
@load_balancing.setter
def load_balancing(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__005e8accaf5e87d2b33f8564facc56ed438e1341b02922a73f879d76fd2fad08)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "loadBalancing", value)
@builtins.property
@jsii.member(jsii_name="logHeaders")
def log_headers(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosDomain.LogHeadersProperty"]]]]:
'''
:Property: logHeaders: Domain traffic tagging
'''
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosDomain.LogHeadersProperty"]]]], jsii.get(self, "logHeaders"))
@log_headers.setter
def log_headers(
self,
value: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, "RosDomain.LogHeadersProperty"]]]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__e3ac6af32a7dc4060f4b5716354d9bc1342c9cf26f23cdf42ba2b4e043993a67)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "logHeaders", value)
@builtins.property
@jsii.member(jsii_name="readTime")
def read_time(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: readTime: Read connection timeout period
'''
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "readTime"))
@read_time.setter
def read_time(
self,
value: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__77b776335991f62ba9ec9d0589f8ec80716d25099edeceede750e0ac20162894)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "readTime", value)
@builtins.property
@jsii.member(jsii_name="resourceGroupId")
def resource_group_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: resourceGroupId: Resource group Id
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "resourceGroupId"))
@resource_group_id.setter
def resource_group_id(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__4eead30a5fe9e6bb2e76b06d5ba98cee0c07c65b49422ba92d383a84a9020e19)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "resourceGroupId", value)
@builtins.property
@jsii.member(jsii_name="writeTime")
def write_time(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: writeTime: Write connection timeout period
'''
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "writeTime"))
@write_time.setter
def write_time(
self,
value: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__99c819a85ccb270aeb591fb04e38ab9b25b06f135c875212faa670807db7071c)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "writeTime", value)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-waf.RosDomain.LogHeadersProperty",
jsii_struct_bases=[],
name_mapping={"k": "k", "v": "v"},
)
class LogHeadersProperty:
def __init__(
self,
*,
k: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
v: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''
:param k:
:param v:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__bc5f90d1ffc8d2907accd645f261be39b072254b1897eb9fbb90b28b6ff8c425)
check_type(argname="argument k", value=k, expected_type=type_hints["k"])
check_type(argname="argument v", value=v, expected_type=type_hints["v"])
self._values: typing.Dict[builtins.str, typing.Any] = {}
if k is not None:
self._values["k"] = k
if v is not None:
self._values["v"] = v
@builtins.property
def k(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: k: The field name of the traffic tag of the domain name
'''
result = self._values.get("k")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def v(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: v: The value of the traffic tag of the domain name
'''
result = self._values.get("v")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "LogHeadersProperty(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class RosDomainConfig(
_ros_cdk_core_7adfd82f.RosResource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-waf.RosDomainConfig",
):
'''A ROS template type: ``ALIYUN::WAF::DomainConfig``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["RosDomainConfigProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
'''Create a new ``ALIYUN::WAF::DomainConfig``.
:param scope: - scope in which this resource is defined.
:param id: - scoped id of the resource.
:param props: - resource properties.
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__c6289f4fc8bf8cedf98fcf6525fbe9c560402f441ba8d18bf095b4e5e9c287a2)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@jsii.member(jsii_name="renderProperties")
def _render_properties(
self,
props: typing.Mapping[builtins.str, typing.Any],
) -> typing.Mapping[builtins.str, typing.Any]:
'''
:param props: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__98879b403e84ee9b10fdc3f01a0cda4b2a37d9fc45922c05532f64ed2da2fc28)
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))
@jsii.python.classproperty
@jsii.member(jsii_name="ROS_RESOURCE_TYPE_NAME")
def ROS_RESOURCE_TYPE_NAME(cls) -> builtins.str:
'''The resource type name for this resource class.'''
return typing.cast(builtins.str, jsii.sget(cls, "ROS_RESOURCE_TYPE_NAME"))
@builtins.property
@jsii.member(jsii_name="attrCname")
def attr_cname(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: Cname: CNAME assigned by WAF instance.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrCname"))
@builtins.property
@jsii.member(jsii_name="attrProtocolType")
def attr_protocol_type(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: ProtocolType: agreement type:0: indicates that the HTTP protocol is supported.1: indicates that the HTTPS protocol is supported.2: indicates that both HTTP and HTTPS protocols are supported.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrProtocolType"))
@builtins.property
@jsii.member(jsii_name="rosProperties")
def _ros_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "rosProperties"))
@builtins.property
@jsii.member(jsii_name="domain")
def domain(self) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: domain: Domain name.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "domain"))
@domain.setter
def domain(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__3fc82664e5cd41b6920194d7423ee1b38413fd1a043db8bf1c06d07d2b373c8e)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "domain", value)
@builtins.property
@jsii.member(jsii_name="enableResourcePropertyConstraint")
def enable_resource_property_constraint(self) -> builtins.bool:
return typing.cast(builtins.bool, jsii.get(self, "enableResourcePropertyConstraint"))
@enable_resource_property_constraint.setter
def enable_resource_property_constraint(self, value: builtins.bool) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__d3e3a4244a534c58fb4ca3aa60dac7aebb671d101a41680a8883c0b15dfcafd7)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "enableResourcePropertyConstraint", value)
@builtins.property
@jsii.member(jsii_name="instanceId")
def instance_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
instanceId: WAF instance ID.
Description Interface You can view your current WAF instance ID by calling DescribePayInfo.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "instanceId"))
@instance_id.setter
def instance_id(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__0e87f3bdf60c17c39897f5f545f0762737dbe91a31b824c3ab35b3361bd7e024)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "instanceId", value)
@builtins.property
@jsii.member(jsii_name="isAccessProduct")
def is_access_product(
self,
) -> typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
isAccessProduct: The domain before WAF is configured with seven agents (eg, high defense, CDN, etc.), the value of:
0: none.
1: expressed.
'''
return typing.cast(typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "isAccessProduct"))
@is_access_product.setter
def is_access_product(
self,
value: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__90eb5aa2147a1a7825c95f2fa33c6600805f487a6fffde30148ec7d37afbe1ce)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "isAccessProduct", value)
@builtins.property
@jsii.member(jsii_name="protocols")
def protocols(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
protocols: The domain supports access protocols, values:
http: expressed support for the HTTP protocol.
https: support for HTTPS protocol.
http, https: supports HTTP, HTTPS protocol.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "protocols"))
@protocols.setter
def protocols(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__c5160059c642e250e992acd6a74f6adabed23fa635b28e301ff407039cb77b10)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "protocols", value)
@builtins.property
@jsii.member(jsii_name="httpPort")
def http_port(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
httpPort: HTTP protocol configuration port. When specifying a plurality of HTTP port "," separated. Example values: [80].
Configure the HTTP protocol, this parameter is required. The default value is 80. HttpPort HttpsPort with at least two parameters need to fill a request.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "httpPort"))
@http_port.setter
def http_port(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__41ea5f9ca978f013545b38f6f408a794c41613f5cc69124259deacef663aa768)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "httpPort", value)
@builtins.property
@jsii.member(jsii_name="httpsPort")
def https_port(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
httpsPort: HTTPS protocol configuration port. When specifying a plurality HTTPS port, using the "," separated. Example values: [443].
Configure the protocol is HTTPS, this parameter is required. The default value is 443. HttpPort HttpsPort with at least two parameters need to fill a request.
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "httpsPort"))
@https_port.setter
def https_port(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__b7b9f66428771732bb87acac7fe6f5b3c2dc51427d39d57d0b22e1d72d418aed)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "httpsPort", value)
@builtins.property
@jsii.member(jsii_name="httpsRedirect")
def https_redirect(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
httpsRedirect: HTTPS is turned forcefully jump the argument:
0: off (default)
1: Turn
Description required to complete the request parameters using only HTTPS access protocol. After opening force will show a jump HTTP request is HTTPS, a default jump to 443.
'''
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "httpsRedirect"))
@https_redirect.setter
def https_redirect(
self,
value: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__813b227de561b965b832c419879aa304d2e6e64c44f083a3252ba5865ba465f4)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "httpsRedirect", value)
@builtins.property
@jsii.member(jsii_name="httpToUserIp")
def http_to_user_ip(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
httpToUserIp: Whether to open HTTPS access request is forwarded back to the source station via the HTTP protocol, the value of:
0: off (default)
1: Turn
Note If your site does not support HTTPS back to the source, open source HTTP return (default back to the source port is port 80) function key, can be realized by WAF HTTPS access.
'''
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "httpToUserIp"))
@http_to_user_ip.setter
def http_to_user_ip(
self,
value: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__473df7fbd85dc88c7f11c0a56f87d0d36f8e18060987b4bc2f9a660a3c9fc6bf)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "httpToUserIp", value)
@builtins.property
@jsii.member(jsii_name="loadBalancing")
def load_balancing(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
loadBalancing: Back to the source load balancing policy values:
0: IP Hash way.
1: represents a polling mode.
'''
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "loadBalancing"))
@load_balancing.setter
def load_balancing(
self,
value: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__b13f90f394d0125047e32bbe9f828f505e4ceec3e3781582cb1e0f592989d84f)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "loadBalancing", value)
@builtins.property
@jsii.member(jsii_name="region")
def region(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
region: Examples of areas where the WAF. Value:
cn: China mainland (default)
cn-hongkong: China HongKong and other overseas
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "region"))
@region.setter
def region(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__4eec33a70c8a03154668b9041305747b6b651cd798fe9da026906c1be1ecb323)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "region", value)
@builtins.property
@jsii.member(jsii_name="rsType")
def rs_type(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
rsType: Back to the source address type the domain name values:
0: back to the source to IP.
1: Indicates the domain name back to the source.
'''
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "rsType"))
@rs_type.setter
def rs_type(
self,
value: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__c806af04413f537181dbe8f4dfa460e8f56447552fc42a492bee1bb98206fc1b)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "rsType", value)
@builtins.property
@jsii.member(jsii_name="sourceIps")
def source_ips(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: sourceIps: Source station IP, supports a plurality of specified IP. Example values: [ "1.1.1.1"].
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "sourceIps"))
@source_ips.setter
def source_ips(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__c4c3642d61fd77eba1713487303884b8768a3a9dadfb6023f8f7cf4a20ef214a)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "sourceIps", value)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-waf.RosDomainConfigProps",
jsii_struct_bases=[],
name_mapping={
"domain": "domain",
"instance_id": "instanceId",
"is_access_product": "isAccessProduct",
"protocols": "protocols",
"http_port": "httpPort",
"https_port": "httpsPort",
"https_redirect": "httpsRedirect",
"http_to_user_ip": "httpToUserIp",
"load_balancing": "loadBalancing",
"region": "region",
"rs_type": "rsType",
"source_ips": "sourceIps",
},
)
class RosDomainConfigProps:
def __init__(
self,
*,
domain: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
instance_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
is_access_product: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
protocols: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
http_port: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
https_port: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
https_redirect: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
http_to_user_ip: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
load_balancing: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
region: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
rs_type: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
source_ips: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::WAF::DomainConfig``.
:param domain:
:param instance_id:
:param is_access_product:
:param protocols:
:param http_port:
:param https_port:
:param https_redirect:
:param http_to_user_ip:
:param load_balancing:
:param region:
:param rs_type:
:param source_ips:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__b7a5082d5e5df1a74c16947ff2f21dcf219ac28649544b7a28b89d4891e1ddfa)
check_type(argname="argument domain", value=domain, expected_type=type_hints["domain"])
check_type(argname="argument instance_id", value=instance_id, expected_type=type_hints["instance_id"])
check_type(argname="argument is_access_product", value=is_access_product, expected_type=type_hints["is_access_product"])
check_type(argname="argument protocols", value=protocols, expected_type=type_hints["protocols"])
check_type(argname="argument http_port", value=http_port, expected_type=type_hints["http_port"])
check_type(argname="argument https_port", value=https_port, expected_type=type_hints["https_port"])
check_type(argname="argument https_redirect", value=https_redirect, expected_type=type_hints["https_redirect"])
check_type(argname="argument http_to_user_ip", value=http_to_user_ip, expected_type=type_hints["http_to_user_ip"])
check_type(argname="argument load_balancing", value=load_balancing, expected_type=type_hints["load_balancing"])
check_type(argname="argument region", value=region, expected_type=type_hints["region"])
check_type(argname="argument rs_type", value=rs_type, expected_type=type_hints["rs_type"])
check_type(argname="argument source_ips", value=source_ips, expected_type=type_hints["source_ips"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"domain": domain,
"instance_id": instance_id,
"is_access_product": is_access_product,
"protocols": protocols,
}
if http_port is not None:
self._values["http_port"] = http_port
if https_port is not None:
self._values["https_port"] = https_port
if https_redirect is not None:
self._values["https_redirect"] = https_redirect
if http_to_user_ip is not None:
self._values["http_to_user_ip"] = http_to_user_ip
if load_balancing is not None:
self._values["load_balancing"] = load_balancing
if region is not None:
self._values["region"] = region
if rs_type is not None:
self._values["rs_type"] = rs_type
if source_ips is not None:
self._values["source_ips"] = source_ips
@builtins.property
def domain(self) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: domain: Domain name.
'''
result = self._values.get("domain")
assert result is not None, "Required property 'domain' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def instance_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
instanceId: WAF instance ID.
Description Interface You can view your current WAF instance ID by calling DescribePayInfo.
'''
result = self._values.get("instance_id")
assert result is not None, "Required property 'instance_id' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def is_access_product(
self,
) -> typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
isAccessProduct: The domain before WAF is configured with seven agents (eg, high defense, CDN, etc.), the value of:
0: none.
1: expressed.
'''
result = self._values.get("is_access_product")
assert result is not None, "Required property 'is_access_product' is missing"
return typing.cast(typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def protocols(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
protocols: The domain supports access protocols, values:
http: expressed support for the HTTP protocol.
https: support for HTTPS protocol.
http, https: supports HTTP, HTTPS protocol.
'''
result = self._values.get("protocols")
assert result is not None, "Required property 'protocols' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def http_port(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
httpPort: HTTP protocol configuration port. When specifying a plurality of HTTP port "," separated. Example values: [80].
Configure the HTTP protocol, this parameter is required. The default value is 80. HttpPort HttpsPort with at least two parameters need to fill a request.
'''
result = self._values.get("http_port")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def https_port(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
httpsPort: HTTPS protocol configuration port. When specifying a plurality HTTPS port, using the "," separated. Example values: [443].
Configure the protocol is HTTPS, this parameter is required. The default value is 443. HttpPort HttpsPort with at least two parameters need to fill a request.
'''
result = self._values.get("https_port")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def https_redirect(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
httpsRedirect: HTTPS is turned forcefully jump the argument:
0: off (default)
1: Turn
Description required to complete the request parameters using only HTTPS access protocol. After opening force will show a jump HTTP request is HTTPS, a default jump to 443.
'''
result = self._values.get("https_redirect")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def http_to_user_ip(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
httpToUserIp: Whether to open HTTPS access request is forwarded back to the source station via the HTTP protocol, the value of:
0: off (default)
1: Turn
Note If your site does not support HTTPS back to the source, open source HTTP return (default back to the source port is port 80) function key, can be realized by WAF HTTPS access.
'''
result = self._values.get("http_to_user_ip")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def load_balancing(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
loadBalancing: Back to the source load balancing policy values:
0: IP Hash way.
1: represents a polling mode.
'''
result = self._values.get("load_balancing")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def region(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
region: Examples of areas where the WAF. Value:
cn: China mainland (default)
cn-hongkong: China HongKong and other overseas
'''
result = self._values.get("region")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def rs_type(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
rsType: Back to the source address type the domain name values:
0: back to the source to IP.
1: Indicates the domain name back to the source.
'''
result = self._values.get("rs_type")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def source_ips(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: sourceIps: Source station IP, supports a plurality of specified IP. Example values: [ "1.1.1.1"].
'''
result = self._values.get("source_ips")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "RosDomainConfigProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-waf.RosDomainProps",
jsii_struct_bases=[],
name_mapping={
"domain_name": "domainName",
"instance_id": "instanceId",
"is_access_product": "isAccessProduct",
"source_ips": "sourceIps",
"cluster_type": "clusterType",
"connection_time": "connectionTime",
"http2_port": "http2Port",
"http_port": "httpPort",
"https_port": "httpsPort",
"https_redirect": "httpsRedirect",
"http_to_user_ip": "httpToUserIp",
"load_balancing": "loadBalancing",
"log_headers": "logHeaders",
"read_time": "readTime",
"resource_group_id": "resourceGroupId",
"write_time": "writeTime",
},
)
class RosDomainProps:
def __init__(
self,
*,
domain_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
instance_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
is_access_product: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
source_ips: typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]],
cluster_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
connection_time: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
http2_port: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]] = None,
http_port: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]] = None,
https_port: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]] = None,
https_redirect: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
http_to_user_ip: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
load_balancing: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
log_headers: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union[RosDomain.LogHeadersProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
read_time: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
resource_group_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
write_time: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::WAF::Domain``.
:param domain_name:
:param instance_id:
:param is_access_product:
:param source_ips:
:param cluster_type:
:param connection_time:
:param http2_port:
:param http_port:
:param https_port:
:param https_redirect:
:param http_to_user_ip:
:param load_balancing:
:param log_headers:
:param read_time:
:param resource_group_id:
:param write_time:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__68c91c57615624a06949950f06fac16c94cb1360a324a03b16f7a0f87de564df)
check_type(argname="argument domain_name", value=domain_name, expected_type=type_hints["domain_name"])
check_type(argname="argument instance_id", value=instance_id, expected_type=type_hints["instance_id"])
check_type(argname="argument is_access_product", value=is_access_product, expected_type=type_hints["is_access_product"])
check_type(argname="argument source_ips", value=source_ips, expected_type=type_hints["source_ips"])
check_type(argname="argument cluster_type", value=cluster_type, expected_type=type_hints["cluster_type"])
check_type(argname="argument connection_time", value=connection_time, expected_type=type_hints["connection_time"])
check_type(argname="argument http2_port", value=http2_port, expected_type=type_hints["http2_port"])
check_type(argname="argument http_port", value=http_port, expected_type=type_hints["http_port"])
check_type(argname="argument https_port", value=https_port, expected_type=type_hints["https_port"])
check_type(argname="argument https_redirect", value=https_redirect, expected_type=type_hints["https_redirect"])
check_type(argname="argument http_to_user_ip", value=http_to_user_ip, expected_type=type_hints["http_to_user_ip"])
check_type(argname="argument load_balancing", value=load_balancing, expected_type=type_hints["load_balancing"])
check_type(argname="argument log_headers", value=log_headers, expected_type=type_hints["log_headers"])
check_type(argname="argument read_time", value=read_time, expected_type=type_hints["read_time"])
check_type(argname="argument resource_group_id", value=resource_group_id, expected_type=type_hints["resource_group_id"])
check_type(argname="argument write_time", value=write_time, expected_type=type_hints["write_time"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"domain_name": domain_name,
"instance_id": instance_id,
"is_access_product": is_access_product,
"source_ips": source_ips,
}
if cluster_type is not None:
self._values["cluster_type"] = cluster_type
if connection_time is not None:
self._values["connection_time"] = connection_time
if http2_port is not None:
self._values["http2_port"] = http2_port
if http_port is not None:
self._values["http_port"] = http_port
if https_port is not None:
self._values["https_port"] = https_port
if https_redirect is not None:
self._values["https_redirect"] = https_redirect
if http_to_user_ip is not None:
self._values["http_to_user_ip"] = http_to_user_ip
if load_balancing is not None:
self._values["load_balancing"] = load_balancing
if log_headers is not None:
self._values["log_headers"] = log_headers
if read_time is not None:
self._values["read_time"] = read_time
if resource_group_id is not None:
self._values["resource_group_id"] = resource_group_id
if write_time is not None:
self._values["write_time"] = write_time
@builtins.property
def domain_name(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: domainName: Domain name
'''
result = self._values.get("domain_name")
assert result is not None, "Required property 'domain_name' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def instance_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: instanceId: Instance id
'''
result = self._values.get("instance_id")
assert result is not None, "Required property 'instance_id' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def is_access_product(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: isAccessProduct: Is there a seven-layer agency before WAF
'''
result = self._values.get("is_access_product")
assert result is not None, "Required property 'is_access_product' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def source_ips(
self,
) -> typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]:
'''
:Property: sourceIps: Back to source IP configuration
'''
result = self._values.get("source_ips")
assert result is not None, "Required property 'source_ips' is missing"
return typing.cast(typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]], result)
@builtins.property
def cluster_type(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: clusterType: Cluster type
'''
result = self._values.get("cluster_type")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def connection_time(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: connectionTime: Connection timeout
'''
result = self._values.get("connection_time")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def http2_port(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]]:
'''
:Property: http2Port: Http2 port configuration
'''
result = self._values.get("http2_port")
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]], result)
@builtins.property
def http_port(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]]:
'''
:Property: httpPort: Http port configuration
'''
result = self._values.get("http_port")
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]], result)
@builtins.property
def https_port(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]]:
'''
:Property: httpsPort: Https port configuration
'''
result = self._values.get("https_port")
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]], result)
@builtins.property
def https_redirect(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: httpsRedirect: Https forced redirect configuration
'''
result = self._values.get("https_redirect")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def http_to_user_ip(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: httpToUserIp: Http back to source
'''
result = self._values.get("http_to_user_ip")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def load_balancing(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: loadBalancing: Load balancing configuration
'''
result = self._values.get("load_balancing")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def log_headers(
self,
) -> typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, RosDomain.LogHeadersProperty]]]]:
'''
:Property: logHeaders: Domain traffic tagging
'''
result = self._values.get("log_headers")
return typing.cast(typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, RosDomain.LogHeadersProperty]]]], result)
@builtins.property
def read_time(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: readTime: Read connection timeout period
'''
result = self._values.get("read_time")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def resource_group_id(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: resourceGroupId: Resource group Id
'''
result = self._values.get("resource_group_id")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def write_time(
self,
) -> typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: writeTime: Write connection timeout period
'''
result = self._values.get("write_time")
return typing.cast(typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "RosDomainProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class RosInstance(
_ros_cdk_core_7adfd82f.RosResource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-waf.RosInstance",
):
'''A ROS template type: ``ALIYUN::WAF::Instance``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["RosInstanceProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
'''Create a new ``ALIYUN::WAF::Instance``.
:param scope: - scope in which this resource is defined.
:param id: - scoped id of the resource.
:param props: - resource properties.
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__bbe9e06aa98a717da5ea4fc6f12f23bd83611c6d62bcfd832750d702d7779d87)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@jsii.member(jsii_name="renderProperties")
def _render_properties(
self,
props: typing.Mapping[builtins.str, typing.Any],
) -> typing.Mapping[builtins.str, typing.Any]:
'''
:param props: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__750255829958bc68177feb026d35708064635a93f96ce6ddea2c097449a9c78b)
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))
@jsii.python.classproperty
@jsii.member(jsii_name="ROS_RESOURCE_TYPE_NAME")
def ROS_RESOURCE_TYPE_NAME(cls) -> builtins.str:
'''The resource type name for this resource class.'''
return typing.cast(builtins.str, jsii.sget(cls, "ROS_RESOURCE_TYPE_NAME"))
@builtins.property
@jsii.member(jsii_name="attrEndDate")
def attr_end_date(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: EndDate: Due date of the instance
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrEndDate"))
@builtins.property
@jsii.member(jsii_name="attrInDebt")
def attr_in_debt(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: InDebt: Instance is overdue
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrInDebt"))
@builtins.property
@jsii.member(jsii_name="attrInstanceId")
def attr_instance_id(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: InstanceId: Instance ID
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrInstanceId"))
@builtins.property
@jsii.member(jsii_name="attrRemainDay")
def attr_remain_day(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: RemainDay: Number of available days for WAF Trial version
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrRemainDay"))
@builtins.property
@jsii.member(jsii_name="attrSubscriptionType")
def attr_subscription_type(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: SubscriptionType: Subscription type of the instance
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrSubscriptionType"))
@builtins.property
@jsii.member(jsii_name="attrTrial")
def attr_trial(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: Trial: Trial version
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrTrial"))
@builtins.property
@jsii.member(jsii_name="rosProperties")
def _ros_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "rosProperties"))
@builtins.property
@jsii.member(jsii_name="bigScreen")
def big_screen(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: bigScreen:
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "bigScreen"))
@big_screen.setter
def big_screen(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__f80b76f8aa0b04aa5b0d056d662a65d9661ba6a4dabe7ce4876877d08aff5d53)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "bigScreen", value)
@builtins.property
@jsii.member(jsii_name="enableResourcePropertyConstraint")
def enable_resource_property_constraint(self) -> builtins.bool:
return typing.cast(builtins.bool, jsii.get(self, "enableResourcePropertyConstraint"))
@enable_resource_property_constraint.setter
def enable_resource_property_constraint(self, value: builtins.bool) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__76d49a943648747f27b4fe334bb5543f703dd5043df2d33a4589d8babbe58258)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "enableResourcePropertyConstraint", value)
@builtins.property
@jsii.member(jsii_name="exclusiveIpPackage")
def exclusive_ip_package(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: exclusiveIpPackage:
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "exclusiveIpPackage"))
@exclusive_ip_package.setter
def exclusive_ip_package(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__86d99c603a42a079486b0245c5e376e6399eebc8f2217cacd40f00976d76af4c)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "exclusiveIpPackage", value)
@builtins.property
@jsii.member(jsii_name="extBandwidth")
def ext_bandwidth(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: extBandwidth:
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "extBandwidth"))
@ext_bandwidth.setter
def ext_bandwidth(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__c5dc701fa9a2bc956137032392cba975bc540d0e1a38aedfb364ba6bb505454b)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "extBandwidth", value)
@builtins.property
@jsii.member(jsii_name="extDomainPackage")
def ext_domain_package(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: extDomainPackage:
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "extDomainPackage"))
@ext_domain_package.setter
def ext_domain_package(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__c40817c0a17a4ba6bce4e0f30a24f2c1ffae027d69fcecf985a74b13882ca1b6)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "extDomainPackage", value)
@builtins.property
@jsii.member(jsii_name="logStorage")
def log_storage(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: logStorage:
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "logStorage"))
@log_storage.setter
def log_storage(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__0deb9b513c91689eedd926b766be637bdbd148ed6f4e18d0a16ee8855d955024)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "logStorage", value)
@builtins.property
@jsii.member(jsii_name="logTime")
def log_time(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: logTime:
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "logTime"))
@log_time.setter
def log_time(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__54249b07746a8910145bda7b2480f18d721a8df78eea951948760f3cad1c74ce)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "logTime", value)
@builtins.property
@jsii.member(jsii_name="packageCode")
def package_code(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: packageCode:
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "packageCode"))
@package_code.setter
def package_code(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__d1baebe2c041e9df7ada724ad042a9005315d2467a596a7abcc1429fde4b280a)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "packageCode", value)
@builtins.property
@jsii.member(jsii_name="prefessionalService")
def prefessional_service(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: prefessionalService:
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "prefessionalService"))
@prefessional_service.setter
def prefessional_service(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__e9d782dbf7d506d008dbe68116eda43f3b9b9b89f431234433300ed86d3fd301)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "prefessionalService", value)
@builtins.property
@jsii.member(jsii_name="subscriptionType")
def subscription_type(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: subscriptionType: Subscription type of the instance
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "subscriptionType"))
@subscription_type.setter
def subscription_type(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__ada77fa43944b0095ba2e8a1f47d0cc5e46c08ea74d61cff58b7424cd2a61898)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "subscriptionType", value)
@builtins.property
@jsii.member(jsii_name="wafLog")
def waf_log(self) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: wafLog:
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "wafLog"))
@waf_log.setter
def waf_log(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__32cbd35766dcd69beaec3fda4bafd15936e62e6a351222267f81f756a5e182b9)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "wafLog", value)
@builtins.property
@jsii.member(jsii_name="period")
def period(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: period:
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "period"))
@period.setter
def period(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__5eb9ff91f2c19190910f19fff2bbbc90c2d29254d7ed2c73acf7a272038055b8)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "period", value)
@builtins.property
@jsii.member(jsii_name="renewalStatus")
def renewal_status(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: renewalStatus:
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "renewalStatus"))
@renewal_status.setter
def renewal_status(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__f9d8e62c779c5696a54890b6716586c83285098ef2c79e328626085eb0223fc8)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "renewalStatus", value)
@builtins.property
@jsii.member(jsii_name="renewPeriod")
def renew_period(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: renewPeriod:
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "renewPeriod"))
@renew_period.setter
def renew_period(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__0d79c2ceff54527c54517cb1947265f3a860f09ed99fb2bc681cc5ec6e1f5561)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "renewPeriod", value)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-waf.RosInstanceProps",
jsii_struct_bases=[],
name_mapping={
"big_screen": "bigScreen",
"exclusive_ip_package": "exclusiveIpPackage",
"ext_bandwidth": "extBandwidth",
"ext_domain_package": "extDomainPackage",
"log_storage": "logStorage",
"log_time": "logTime",
"package_code": "packageCode",
"prefessional_service": "prefessionalService",
"subscription_type": "subscriptionType",
"waf_log": "wafLog",
"period": "period",
"renewal_status": "renewalStatus",
"renew_period": "renewPeriod",
},
)
class RosInstanceProps:
def __init__(
self,
*,
big_screen: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
exclusive_ip_package: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
ext_bandwidth: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
ext_domain_package: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
log_storage: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
log_time: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
package_code: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
prefessional_service: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
subscription_type: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
waf_log: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
period: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
renewal_status: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
renew_period: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::WAF::Instance``.
:param big_screen:
:param exclusive_ip_package:
:param ext_bandwidth:
:param ext_domain_package:
:param log_storage:
:param log_time:
:param package_code:
:param prefessional_service:
:param subscription_type:
:param waf_log:
:param period:
:param renewal_status:
:param renew_period:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__0ea514c1c10f42ff555fae81609b07178ce6b70189002bc1b7110bfef661e9d7)
check_type(argname="argument big_screen", value=big_screen, expected_type=type_hints["big_screen"])
check_type(argname="argument exclusive_ip_package", value=exclusive_ip_package, expected_type=type_hints["exclusive_ip_package"])
check_type(argname="argument ext_bandwidth", value=ext_bandwidth, expected_type=type_hints["ext_bandwidth"])
check_type(argname="argument ext_domain_package", value=ext_domain_package, expected_type=type_hints["ext_domain_package"])
check_type(argname="argument log_storage", value=log_storage, expected_type=type_hints["log_storage"])
check_type(argname="argument log_time", value=log_time, expected_type=type_hints["log_time"])
check_type(argname="argument package_code", value=package_code, expected_type=type_hints["package_code"])
check_type(argname="argument prefessional_service", value=prefessional_service, expected_type=type_hints["prefessional_service"])
check_type(argname="argument subscription_type", value=subscription_type, expected_type=type_hints["subscription_type"])
check_type(argname="argument waf_log", value=waf_log, expected_type=type_hints["waf_log"])
check_type(argname="argument period", value=period, expected_type=type_hints["period"])
check_type(argname="argument renewal_status", value=renewal_status, expected_type=type_hints["renewal_status"])
check_type(argname="argument renew_period", value=renew_period, expected_type=type_hints["renew_period"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"big_screen": big_screen,
"exclusive_ip_package": exclusive_ip_package,
"ext_bandwidth": ext_bandwidth,
"ext_domain_package": ext_domain_package,
"log_storage": log_storage,
"log_time": log_time,
"package_code": package_code,
"prefessional_service": prefessional_service,
"subscription_type": subscription_type,
"waf_log": waf_log,
}
if period is not None:
self._values["period"] = period
if renewal_status is not None:
self._values["renewal_status"] = renewal_status
if renew_period is not None:
self._values["renew_period"] = renew_period
@builtins.property
def big_screen(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: bigScreen:
'''
result = self._values.get("big_screen")
assert result is not None, "Required property 'big_screen' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def exclusive_ip_package(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: exclusiveIpPackage:
'''
result = self._values.get("exclusive_ip_package")
assert result is not None, "Required property 'exclusive_ip_package' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def ext_bandwidth(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: extBandwidth:
'''
result = self._values.get("ext_bandwidth")
assert result is not None, "Required property 'ext_bandwidth' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def ext_domain_package(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: extDomainPackage:
'''
result = self._values.get("ext_domain_package")
assert result is not None, "Required property 'ext_domain_package' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def log_storage(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: logStorage:
'''
result = self._values.get("log_storage")
assert result is not None, "Required property 'log_storage' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def log_time(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: logTime:
'''
result = self._values.get("log_time")
assert result is not None, "Required property 'log_time' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def package_code(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: packageCode:
'''
result = self._values.get("package_code")
assert result is not None, "Required property 'package_code' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def prefessional_service(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: prefessionalService:
'''
result = self._values.get("prefessional_service")
assert result is not None, "Required property 'prefessional_service' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def subscription_type(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: subscriptionType: Subscription type of the instance
'''
result = self._values.get("subscription_type")
assert result is not None, "Required property 'subscription_type' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def waf_log(self) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: wafLog:
'''
result = self._values.get("waf_log")
assert result is not None, "Required property 'waf_log' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def period(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: period:
'''
result = self._values.get("period")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def renewal_status(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: renewalStatus:
'''
result = self._values.get("renewal_status")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
@builtins.property
def renew_period(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property: renewPeriod:
'''
result = self._values.get("renew_period")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "RosInstanceProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class RosLogServiceEnable(
_ros_cdk_core_7adfd82f.RosResource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-waf.RosLogServiceEnable",
):
'''A ROS template type: ``ALIYUN::WAF::LogServiceEnable``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["RosLogServiceEnableProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
'''Create a new ``ALIYUN::WAF::LogServiceEnable``.
:param scope: - scope in which this resource is defined.
:param id: - scoped id of the resource.
:param props: - resource properties.
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__f3a40b8d5cd7e8af2c47c243ba9951eaa37d2ccc415e27c667af9089ccc2d02c)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@jsii.member(jsii_name="renderProperties")
def _render_properties(
self,
props: typing.Mapping[builtins.str, typing.Any],
) -> typing.Mapping[builtins.str, typing.Any]:
'''
:param props: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__043e59ca2ff1777b9d730049410e0a95951c44198cf92fcd77879cdd5ba0e158)
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))
@jsii.python.classproperty
@jsii.member(jsii_name="ROS_RESOURCE_TYPE_NAME")
def ROS_RESOURCE_TYPE_NAME(cls) -> builtins.str:
'''The resource type name for this resource class.'''
return typing.cast(builtins.str, jsii.sget(cls, "ROS_RESOURCE_TYPE_NAME"))
@builtins.property
@jsii.member(jsii_name="attrDomain")
def attr_domain(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute: Domain: The domain name that is added to WAF.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrDomain"))
@builtins.property
@jsii.member(jsii_name="attrInstanceId")
def attr_instance_id(self) -> _ros_cdk_core_7adfd82f.IResolvable:
'''
:Attribute:
InstanceId: The ID of the WAF instance.
You can call the DescribeInstanceInfo operation to query the ID of the WAF instance.
'''
return typing.cast(_ros_cdk_core_7adfd82f.IResolvable, jsii.get(self, "attrInstanceId"))
@builtins.property
@jsii.member(jsii_name="rosProperties")
def _ros_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "rosProperties"))
@builtins.property
@jsii.member(jsii_name="domain")
def domain(self) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: domain: The domain name that is added to WAF.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "domain"))
@domain.setter
def domain(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__963746e54b4e8ce7a3e779c862cd54ea36fe4e365e2edeeaf3750d04d497608e)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "domain", value)
@builtins.property
@jsii.member(jsii_name="enableResourcePropertyConstraint")
def enable_resource_property_constraint(self) -> builtins.bool:
return typing.cast(builtins.bool, jsii.get(self, "enableResourcePropertyConstraint"))
@enable_resource_property_constraint.setter
def enable_resource_property_constraint(self, value: builtins.bool) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__b50c5384f0c738e028bf799c2a8dc3db467cab2b4ae2a05ae76a2fef7387506d)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "enableResourcePropertyConstraint", value)
@builtins.property
@jsii.member(jsii_name="instanceId")
def instance_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
instanceId: The ID of the WAF instance.
You can call the DescribeInstanceInfo operation to query the ID of the WAF instance.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "instanceId"))
@instance_id.setter
def instance_id(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__4ca622aa6377a5cb1d1657159ea92eea4da131080da04ee59294197da99ca303)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "instanceId", value)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-waf.RosLogServiceEnableProps",
jsii_struct_bases=[],
name_mapping={"domain": "domain", "instance_id": "instanceId"},
)
class RosLogServiceEnableProps:
def __init__(
self,
*,
domain: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
instance_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
'''Properties for defining a ``ALIYUN::WAF::LogServiceEnable``.
:param domain:
:param instance_id:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__5f85d391c6d9a399f73a3019db0a489ba05ed91153649e739b39688b5b1d8109)
check_type(argname="argument domain", value=domain, expected_type=type_hints["domain"])
check_type(argname="argument instance_id", value=instance_id, expected_type=type_hints["instance_id"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"domain": domain,
"instance_id": instance_id,
}
@builtins.property
def domain(self) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: domain: The domain name that is added to WAF.
'''
result = self._values.get("domain")
assert result is not None, "Required property 'domain' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def instance_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
instanceId: The ID of the WAF instance.
You can call the DescribeInstanceInfo operation to query the ID of the WAF instance.
'''
result = self._values.get("instance_id")
assert result is not None, "Required property 'instance_id' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "RosLogServiceEnableProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class RosWafSwitch(
_ros_cdk_core_7adfd82f.RosResource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-waf.RosWafSwitch",
):
'''A ROS template type: ``ALIYUN::WAF::WafSwitch``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["RosWafSwitchProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
'''Create a new ``ALIYUN::WAF::WafSwitch``.
:param scope: - scope in which this resource is defined.
:param id: - scoped id of the resource.
:param props: - resource properties.
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__3a73e007f1e7c539884b516a6851015b4237d8dfe2ad5f4259db609397821179)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@jsii.member(jsii_name="renderProperties")
def _render_properties(
self,
props: typing.Mapping[builtins.str, typing.Any],
) -> typing.Mapping[builtins.str, typing.Any]:
'''
:param props: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__2fc6aa082370df4637d886f5d861e0b3c47f450a97f84dd914e404a70e66f963)
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))
@jsii.python.classproperty
@jsii.member(jsii_name="ROS_RESOURCE_TYPE_NAME")
def ROS_RESOURCE_TYPE_NAME(cls) -> builtins.str:
'''The resource type name for this resource class.'''
return typing.cast(builtins.str, jsii.sget(cls, "ROS_RESOURCE_TYPE_NAME"))
@builtins.property
@jsii.member(jsii_name="rosProperties")
def _ros_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "rosProperties"))
@builtins.property
@jsii.member(jsii_name="domain")
def domain(self) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: domain: Domain name.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "domain"))
@domain.setter
def domain(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__9709d6f4fd50fac629d6ae0f2116e7ec7a0b00e13ef1b103ae7b0c0e1290264d)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "domain", value)
@builtins.property
@jsii.member(jsii_name="enableResourcePropertyConstraint")
def enable_resource_property_constraint(self) -> builtins.bool:
'''A factory method that creates a new instance of this class from an object containing the properties of this ROS resource.'''
return typing.cast(builtins.bool, jsii.get(self, "enableResourcePropertyConstraint"))
@enable_resource_property_constraint.setter
def enable_resource_property_constraint(self, value: builtins.bool) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__dc62479620742e57b98fc9847411c7b682ced327f8cd0271f530c804cbe49ea8)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "enableResourcePropertyConstraint", value)
@builtins.property
@jsii.member(jsii_name="instanceId")
def instance_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
instanceId: WAF instance ID.
Description Interface You can view your current WAF instance ID by calling DescribePayInfo.
'''
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "instanceId"))
@instance_id.setter
def instance_id(
self,
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__341d1d6c9078107225726cc76f222db1398199305b54567dc305a604fd6f39a7)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "instanceId", value)
@builtins.property
@jsii.member(jsii_name="serviceOn")
def service_on(
self,
) -> typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
serviceOn: Web attack protection switch, the value of:
0: closed.
1: indicate on.
'''
return typing.cast(typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable], jsii.get(self, "serviceOn"))
@service_on.setter
def service_on(
self,
value: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__1091453b8988170f46580b884757797273b64d0008b7d3cc6304195152d55d16)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "serviceOn", value)
@builtins.property
@jsii.member(jsii_name="region")
def region(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
region: Examples of areas where the WAF. Value:
cn: China mainland (default)
cn-hongkong: China HongKong and other overseas
'''
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], jsii.get(self, "region"))
@region.setter
def region(
self,
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__67d193f3148fd8afaa5766f13b7260e8268765365ed25ebe7106a7500340e215)
check_type(argname="argument value", value=value, expected_type=type_hints["value"])
jsii.set(self, "region", value)
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-waf.RosWafSwitchProps",
jsii_struct_bases=[],
name_mapping={
"domain": "domain",
"instance_id": "instanceId",
"service_on": "serviceOn",
"region": "region",
},
)
class RosWafSwitchProps:
def __init__(
self,
*,
domain: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
instance_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
service_on: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
region: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::WAF::WafSwitch``.
:param domain:
:param instance_id:
:param service_on:
:param region:
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__c78fa3a45b1503315eb84e8620543a367537589c487f620cc01d5d5ee812fc75)
check_type(argname="argument domain", value=domain, expected_type=type_hints["domain"])
check_type(argname="argument instance_id", value=instance_id, expected_type=type_hints["instance_id"])
check_type(argname="argument service_on", value=service_on, expected_type=type_hints["service_on"])
check_type(argname="argument region", value=region, expected_type=type_hints["region"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"domain": domain,
"instance_id": instance_id,
"service_on": service_on,
}
if region is not None:
self._values["region"] = region
@builtins.property
def domain(self) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property: domain: Domain name.
'''
result = self._values.get("domain")
assert result is not None, "Required property 'domain' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def instance_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
instanceId: WAF instance ID.
Description Interface You can view your current WAF instance ID by calling DescribePayInfo.
'''
result = self._values.get("instance_id")
assert result is not None, "Required property 'instance_id' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def service_on(
self,
) -> typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]:
'''
:Property:
serviceOn: Web attack protection switch, the value of:
0: closed.
1: indicate on.
'''
result = self._values.get("service_on")
assert result is not None, "Required property 'service_on' is missing"
return typing.cast(typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def region(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''
:Property:
region: Examples of areas where the WAF. Value:
cn: China mainland (default)
cn-hongkong: China HongKong and other overseas
'''
result = self._values.get("region")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "RosWafSwitchProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
class WafSwitch(
_ros_cdk_core_7adfd82f.Resource,
metaclass=jsii.JSIIMeta,
jsii_type="@alicloud/ros-cdk-waf.WafSwitch",
):
'''A ROS resource type: ``ALIYUN::WAF::WafSwitch``.'''
def __init__(
self,
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union["WafSwitchProps", typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
'''Create a new ``ALIYUN::WAF::WafSwitch``.
Param scope - scope in which this resource is defined
Param id - scoped id of the resource
Param props - resource properties
:param scope: -
:param id: -
:param props: -
:param enable_resource_property_constraint: -
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__aacd8d89f4ffdff022fcde97385769e8163ab50f3cca60397f5575c14dc45433)
check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
check_type(argname="argument id", value=id, expected_type=type_hints["id"])
check_type(argname="argument props", value=props, expected_type=type_hints["props"])
check_type(argname="argument enable_resource_property_constraint", value=enable_resource_property_constraint, expected_type=type_hints["enable_resource_property_constraint"])
jsii.create(self.__class__, self, [scope, id, props, enable_resource_property_constraint])
@jsii.data_type(
jsii_type="@alicloud/ros-cdk-waf.WafSwitchProps",
jsii_struct_bases=[],
name_mapping={
"domain": "domain",
"instance_id": "instanceId",
"service_on": "serviceOn",
"region": "region",
},
)
class WafSwitchProps:
def __init__(
self,
*,
domain: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
instance_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
service_on: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
region: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
'''Properties for defining a ``ALIYUN::WAF::WafSwitch``.
:param domain: Property domain: Domain name.
:param instance_id: Property instanceId: WAF instance ID. Description Interface You can view your current WAF instance ID by calling DescribePayInfo.
:param service_on: Property serviceOn: Web attack protection switch, the value of: 0: closed. 1: indicate on.
:param region: Property region: Examples of areas where the WAF. Value: cn: China mainland (default) cn-hongkong: China HongKong and other overseas
'''
if __debug__:
type_hints = typing.get_type_hints(_typecheckingstub__d7ac3158ea62c608345ef60c179e8c755f1b4e32f59403290909a2c580ece25e)
check_type(argname="argument domain", value=domain, expected_type=type_hints["domain"])
check_type(argname="argument instance_id", value=instance_id, expected_type=type_hints["instance_id"])
check_type(argname="argument service_on", value=service_on, expected_type=type_hints["service_on"])
check_type(argname="argument region", value=region, expected_type=type_hints["region"])
self._values: typing.Dict[builtins.str, typing.Any] = {
"domain": domain,
"instance_id": instance_id,
"service_on": service_on,
}
if region is not None:
self._values["region"] = region
@builtins.property
def domain(self) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property domain: Domain name.'''
result = self._values.get("domain")
assert result is not None, "Required property 'domain' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def instance_id(
self,
) -> typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property instanceId: WAF instance ID.
Description Interface You can view your current WAF instance ID by calling DescribePayInfo.
'''
result = self._values.get("instance_id")
assert result is not None, "Required property 'instance_id' is missing"
return typing.cast(typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def service_on(
self,
) -> typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]:
'''Property serviceOn: Web attack protection switch, the value of: 0: closed.
1: indicate on.
'''
result = self._values.get("service_on")
assert result is not None, "Required property 'service_on' is missing"
return typing.cast(typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable], result)
@builtins.property
def region(
self,
) -> typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]:
'''Property region: Examples of areas where the WAF.
Value:
cn: China mainland (default)
cn-hongkong: China HongKong and other overseas
'''
result = self._values.get("region")
return typing.cast(typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]], result)
def __eq__(self, rhs: typing.Any) -> builtins.bool:
return isinstance(rhs, self.__class__) and rhs._values == self._values
def __ne__(self, rhs: typing.Any) -> builtins.bool:
return not (rhs == self)
def __repr__(self) -> str:
return "WafSwitchProps(%s)" % ", ".join(
k + "=" + repr(v) for k, v in self._values.items()
)
__all__ = [
"AclRule",
"AclRuleProps",
"Domain",
"DomainConfig",
"DomainConfigProps",
"DomainProps",
"Instance",
"InstanceProps",
"LogServiceEnable",
"LogServiceEnableProps",
"RosAclRule",
"RosAclRuleProps",
"RosDomain",
"RosDomainConfig",
"RosDomainConfigProps",
"RosDomainProps",
"RosInstance",
"RosInstanceProps",
"RosLogServiceEnable",
"RosLogServiceEnableProps",
"RosWafSwitch",
"RosWafSwitchProps",
"WafSwitch",
"WafSwitchProps",
]
publication.publish()
def _typecheckingstub__2de49924f3fbceb453f45b2ff3f5ad38218a7ddeccf95d8f93ddeb13767ae3e3(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[AclRuleProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__a66b9776a33469dcd97701d934b24da04888c6236fe4dc76b6d920c32aeede2e(
*,
domain: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
instance_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
rules: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
region: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
rule_id: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__464df36b8e6d427565e80f096b9ca427e6e2ad4bd4ad73191a1b91fd305696b3(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[DomainProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__5d3b0679966e32e3587b3ffedda67491d53c3c5b3aca714482dcb86fb7aa5c39(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[DomainConfigProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__70bdf7bb9a6ebd5d1855e05758f57d06913e6d4d48eb859f131a128f1bd7a407(
*,
domain: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
instance_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
is_access_product: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
protocols: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
http_port: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
https_port: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
https_redirect: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
http_to_user_ip: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
load_balancing: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
region: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
rs_type: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
source_ips: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__eb3b68012c4c48777067cebfa980d3385e395a3b8b8851bf1750081507a0a5d9(
*,
domain_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
instance_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
is_access_product: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
source_ips: typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]],
cluster_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
connection_time: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
http2_port: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]] = None,
http_port: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]] = None,
https_port: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]] = None,
https_redirect: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
http_to_user_ip: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
load_balancing: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
log_headers: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union[RosDomain.LogHeadersProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
read_time: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
resource_group_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
write_time: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__865684754cd3828eaf27fdafeeb9db069d768face8c5a95e3ec2c3c98b0c5ef3(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[InstanceProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__43a17fa5ea24779c202068b99acdc06cba416ef7cc3ddf08640349b6c982dba8(
*,
big_screen: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
exclusive_ip_package: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
ext_bandwidth: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
ext_domain_package: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
log_storage: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
log_time: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
package_code: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
prefessional_service: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
subscription_type: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
waf_log: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
period: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
renewal_status: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
renew_period: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__f695b59c454d396613800620218c0b44354bb4d0fdad8ad7501a734bb0ee47c1(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[LogServiceEnableProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__992cd75383e2b392161ee3fa6243de9ee05983185934c552a6b18182ae5bbb8c(
*,
domain: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
instance_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__91366ac47dd17fe495e6197496f5cbfe29ff7ef18db69ef51195bc7ec187b475(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[RosAclRuleProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__63c8efc8f61a16747489d1a4a2365b710bea515a56ee9627907a97b12b835aaf(
props: typing.Mapping[builtins.str, typing.Any],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__cd74c4fdd6076b3f11dce7870ad0a92dea4a866b5b0872112668fb7ec90560f1(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__55913d9b9ae6cb7abb7f5005e84e60701b4356d9343a95f52b3c3c61394e10a6(
value: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__ab28e35f904b2d2de860fc995c2c71352412a6356c74e3cd653850f32897d613(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__64c5fb4547d952a7eefdf0fa49c3fe5d8539a5d76249ddee92c68f4116775dc5(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__b68ad4595d6331b5668ec69a50cf200857a327f083559deed7d26d3ea1191d7d(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__6f185055da1831e37b7e0c7a7a19ee7c92f6616b086ffc5735cf6eb031d4ba1c(
value: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__3128f81577aa6f6d0dcf831565d98804f88591ce039bfbac2bfe2d53db7e1f11(
*,
domain: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
instance_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
rules: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
region: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
rule_id: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__10adf4d36dc029495a749e9d3e9fc03f8aa9b481cbb61a9d730fec43a4f3c696(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[RosDomainProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__f8c44991fabe9afe9de7e257f2e3f1929ea02ae7229052a2444138a9b1ac98f2(
props: typing.Mapping[builtins.str, typing.Any],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__86cbf180a8334b95c5c55a9d22f8dd5628ff114051c6e988572ddb32e861c558(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__ecadc7980502a4b81787de4173b6612cf8913540ef5926f4dcb2b20ee4e8f63c(
value: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__ef37d9a68bb14afc25f01a6473da8bb344a3a0a10091d77e5d040d7d6d8e1e21(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__cd03066e0bf4ed8f79c6ce9a25574c7abde110bb35b7f62c574a4ba43538fdac(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__3b55868db5d8bce373663a8d7df3b604fb32a22beaf61d30b4786dec8d1f46ac(
value: typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__d0692085a7e0272a407a66cf9dd9ef971c84d975b1fc836887898820853e0130(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__548a0c9666038823c5b553f5f976da708e9619f8bdf99007bc3b52be6d55a8e7(
value: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__d5edb493193e73a297ad5109964cf26399718e02f9637cd1c83e310921b67756(
value: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__bf4a2e0135d01b001b7042eafa16281524cf505ebc4f6a2eb9a915e19e314a1a(
value: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__e0730cdc94e23794b1b308b8e23ffde48b735dd3f321ae7406555b2bd14fea43(
value: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__b3a7a831ca7b855a903a8d5b2613ae7156caf55a19e706e1bcd398b5d2c805eb(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__42595eb12037b41b9aeec203baf98dfc53f04f56d4c96da61d2fe1142bc74ef8(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__005e8accaf5e87d2b33f8564facc56ed438e1341b02922a73f879d76fd2fad08(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__e3ac6af32a7dc4060f4b5716354d9bc1342c9cf26f23cdf42ba2b4e043993a67(
value: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.List[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, RosDomain.LogHeadersProperty]]]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__77b776335991f62ba9ec9d0589f8ec80716d25099edeceede750e0ac20162894(
value: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__4eead30a5fe9e6bb2e76b06d5ba98cee0c07c65b49422ba92d383a84a9020e19(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__99c819a85ccb270aeb591fb04e38ab9b25b06f135c875212faa670807db7071c(
value: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__bc5f90d1ffc8d2907accd645f261be39b072254b1897eb9fbb90b28b6ff8c425(
*,
k: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
v: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__c6289f4fc8bf8cedf98fcf6525fbe9c560402f441ba8d18bf095b4e5e9c287a2(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[RosDomainConfigProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__98879b403e84ee9b10fdc3f01a0cda4b2a37d9fc45922c05532f64ed2da2fc28(
props: typing.Mapping[builtins.str, typing.Any],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__3fc82664e5cd41b6920194d7423ee1b38413fd1a043db8bf1c06d07d2b373c8e(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__d3e3a4244a534c58fb4ca3aa60dac7aebb671d101a41680a8883c0b15dfcafd7(
value: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__0e87f3bdf60c17c39897f5f545f0762737dbe91a31b824c3ab35b3361bd7e024(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__90eb5aa2147a1a7825c95f2fa33c6600805f487a6fffde30148ec7d37afbe1ce(
value: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__c5160059c642e250e992acd6a74f6adabed23fa635b28e301ff407039cb77b10(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__41ea5f9ca978f013545b38f6f408a794c41613f5cc69124259deacef663aa768(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__b7b9f66428771732bb87acac7fe6f5b3c2dc51427d39d57d0b22e1d72d418aed(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__813b227de561b965b832c419879aa304d2e6e64c44f083a3252ba5865ba465f4(
value: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__473df7fbd85dc88c7f11c0a56f87d0d36f8e18060987b4bc2f9a660a3c9fc6bf(
value: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__b13f90f394d0125047e32bbe9f828f505e4ceec3e3781582cb1e0f592989d84f(
value: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__4eec33a70c8a03154668b9041305747b6b651cd798fe9da026906c1be1ecb323(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__c806af04413f537181dbe8f4dfa460e8f56447552fc42a492bee1bb98206fc1b(
value: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__c4c3642d61fd77eba1713487303884b8768a3a9dadfb6023f8f7cf4a20ef214a(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__b7a5082d5e5df1a74c16947ff2f21dcf219ac28649544b7a28b89d4891e1ddfa(
*,
domain: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
instance_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
is_access_product: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
protocols: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
http_port: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
https_port: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
https_redirect: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
http_to_user_ip: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
load_balancing: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
region: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
rs_type: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
source_ips: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__68c91c57615624a06949950f06fac16c94cb1360a324a03b16f7a0f87de564df(
*,
domain_name: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
instance_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
is_access_product: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
source_ips: typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]],
cluster_type: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
connection_time: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
http2_port: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]] = None,
http_port: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]] = None,
https_port: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]]]] = None,
https_redirect: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
http_to_user_ip: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
load_balancing: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
log_headers: typing.Optional[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Sequence[typing.Union[_ros_cdk_core_7adfd82f.IResolvable, typing.Union[RosDomain.LogHeadersProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
read_time: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
resource_group_id: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
write_time: typing.Optional[typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__bbe9e06aa98a717da5ea4fc6f12f23bd83611c6d62bcfd832750d702d7779d87(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[RosInstanceProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__750255829958bc68177feb026d35708064635a93f96ce6ddea2c097449a9c78b(
props: typing.Mapping[builtins.str, typing.Any],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__f80b76f8aa0b04aa5b0d056d662a65d9661ba6a4dabe7ce4876877d08aff5d53(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__76d49a943648747f27b4fe334bb5543f703dd5043df2d33a4589d8babbe58258(
value: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__86d99c603a42a079486b0245c5e376e6399eebc8f2217cacd40f00976d76af4c(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__c5dc701fa9a2bc956137032392cba975bc540d0e1a38aedfb364ba6bb505454b(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__c40817c0a17a4ba6bce4e0f30a24f2c1ffae027d69fcecf985a74b13882ca1b6(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__0deb9b513c91689eedd926b766be637bdbd148ed6f4e18d0a16ee8855d955024(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__54249b07746a8910145bda7b2480f18d721a8df78eea951948760f3cad1c74ce(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__d1baebe2c041e9df7ada724ad042a9005315d2467a596a7abcc1429fde4b280a(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__e9d782dbf7d506d008dbe68116eda43f3b9b9b89f431234433300ed86d3fd301(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__ada77fa43944b0095ba2e8a1f47d0cc5e46c08ea74d61cff58b7424cd2a61898(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__32cbd35766dcd69beaec3fda4bafd15936e62e6a351222267f81f756a5e182b9(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__5eb9ff91f2c19190910f19fff2bbbc90c2d29254d7ed2c73acf7a272038055b8(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__f9d8e62c779c5696a54890b6716586c83285098ef2c79e328626085eb0223fc8(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__0d79c2ceff54527c54517cb1947265f3a860f09ed99fb2bc681cc5ec6e1f5561(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__0ea514c1c10f42ff555fae81609b07178ce6b70189002bc1b7110bfef661e9d7(
*,
big_screen: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
exclusive_ip_package: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
ext_bandwidth: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
ext_domain_package: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
log_storage: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
log_time: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
package_code: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
prefessional_service: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
subscription_type: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
waf_log: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
period: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
renewal_status: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
renew_period: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__f3a40b8d5cd7e8af2c47c243ba9951eaa37d2ccc415e27c667af9089ccc2d02c(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[RosLogServiceEnableProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__043e59ca2ff1777b9d730049410e0a95951c44198cf92fcd77879cdd5ba0e158(
props: typing.Mapping[builtins.str, typing.Any],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__963746e54b4e8ce7a3e779c862cd54ea36fe4e365e2edeeaf3750d04d497608e(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__b50c5384f0c738e028bf799c2a8dc3db467cab2b4ae2a05ae76a2fef7387506d(
value: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__4ca622aa6377a5cb1d1657159ea92eea4da131080da04ee59294197da99ca303(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__5f85d391c6d9a399f73a3019db0a489ba05ed91153649e739b39688b5b1d8109(
*,
domain: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
instance_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__3a73e007f1e7c539884b516a6851015b4237d8dfe2ad5f4259db609397821179(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[RosWafSwitchProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__2fc6aa082370df4637d886f5d861e0b3c47f450a97f84dd914e404a70e66f963(
props: typing.Mapping[builtins.str, typing.Any],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__9709d6f4fd50fac629d6ae0f2116e7ec7a0b00e13ef1b103ae7b0c0e1290264d(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__dc62479620742e57b98fc9847411c7b682ced327f8cd0271f530c804cbe49ea8(
value: builtins.bool,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__341d1d6c9078107225726cc76f222db1398199305b54567dc305a604fd6f39a7(
value: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__1091453b8988170f46580b884757797273b64d0008b7d3cc6304195152d55d16(
value: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__67d193f3148fd8afaa5766f13b7260e8268765365ed25ebe7106a7500340e215(
value: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]],
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__c78fa3a45b1503315eb84e8620543a367537589c487f620cc01d5d5ee812fc75(
*,
domain: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
instance_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
service_on: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
region: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__aacd8d89f4ffdff022fcde97385769e8163ab50f3cca60397f5575c14dc45433(
scope: _ros_cdk_core_7adfd82f.Construct,
id: builtins.str,
props: typing.Union[WafSwitchProps, typing.Dict[builtins.str, typing.Any]],
enable_resource_property_constraint: typing.Optional[builtins.bool] = None,
) -> None:
"""Type checking stubs"""
pass
def _typecheckingstub__d7ac3158ea62c608345ef60c179e8c755f1b4e32f59403290909a2c580ece25e(
*,
domain: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
instance_id: typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable],
service_on: typing.Union[jsii.Number, _ros_cdk_core_7adfd82f.IResolvable],
region: typing.Optional[typing.Union[builtins.str, _ros_cdk_core_7adfd82f.IResolvable]] = None,
) -> None:
"""Type checking stubs"""
pass | /ros-cdk-waf-1.0.17.tar.gz/ros-cdk-waf-1.0.17/src/ros_cdk_waf/__init__.py | 0.631935 | 0.165728 | __init__.py | pypi |
import logging
import os
from pathlib import Path
from typing import List
from typing import Optional
from ros_cross_compile.data_collector import DataCollector
from ros_cross_compile.docker_client import DockerClient
from ros_cross_compile.pipeline_stages import PipelineStage
from ros_cross_compile.pipeline_stages import PipelineStageOptions
from ros_cross_compile.platform import Platform
from ros_cross_compile.sysroot_creator import build_internals_dir
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger('Rosdep Gatherer')
CUSTOM_SETUP = '/usercustom/rosdep_setup'
CUSTOM_DATA = '/usercustom/custom-data'
_IMG_NAME = 'ros_cross_compile:rosdep'
def rosdep_install_script(platform: Platform) -> Path:
"""Construct relative path of the script that installs rosdeps into the sysroot image."""
return build_internals_dir(platform) / 'install_rosdeps.sh'
def gather_rosdeps(
docker_client: DockerClient,
platform: Platform,
workspace: Path,
skip_rosdep_keys: List[str] = [],
custom_script: Optional[Path] = None,
custom_data_dir: Optional[Path] = None,
) -> None:
"""
Run the rosdep Docker image, which outputs a script for dependency installation.
:param docker_client: Will be used to run the container
:param platform: The name of the image produced by `build_rosdep_image`
:param workspace: Absolute path to the colcon source workspace.
:param custom_script: Optional absolute path of a script that does custom setup for rosdep
:param custom_data_dir: Optional absolute path of a directory containing custom data for setup
:return None
"""
out_path = rosdep_install_script(platform)
logger.info('Building rosdep collector image: %s', _IMG_NAME)
if platform.ros_distro == 'melodic':
docker_client.build_image(
dockerfile_name='rosdep.Dockerfile',
tag=_IMG_NAME,
)
else:
docker_client.build_image(
dockerfile_name='rosdep_focal.Dockerfile',
tag=_IMG_NAME,
)
logger.info('Running rosdep collector image on workspace {}'.format(workspace))
volumes = {
workspace: '/ws',
}
if custom_script:
volumes[custom_script] = CUSTOM_SETUP
if custom_data_dir:
volumes[custom_data_dir] = CUSTOM_DATA
docker_client.run_container(
image_name=_IMG_NAME,
environment={
'CUSTOM_SETUP': CUSTOM_SETUP,
'OUT_PATH': str(out_path),
'OWNER_USER': str(os.getuid()),
'ROSDISTRO': platform.ros_distro,
'SKIP_ROSDEP_KEYS': ' '.join(skip_rosdep_keys),
'COLCON_DEFAULTS_FILE': 'defaults.yaml',
'TARGET_OS': '{}:{}'.format(platform.os_name, platform.os_distro),
},
volumes=volumes,
)
def assert_install_rosdep_script_exists(
ros_workspace_dir: Path,
platform: Platform
) -> bool:
install_rosdep_script_path = ros_workspace_dir / rosdep_install_script(platform)
if not install_rosdep_script_path.is_file():
raise RuntimeError(
'Rosdep installation script has never been created, you need to run this without '
'skipping rosdep collection at least once.')
return True
class CollectDependencyListStage(PipelineStage):
"""
This stage determines what external dependencies are needed for building.
It outputs a script into the internals directory that will install those
dependencies for the target platform.
"""
def __init__(self):
super().__init__('gather_rosdeps')
def __call__(
self,
platform: Platform,
docker_client: DockerClient,
ros_workspace_dir: Path,
options: PipelineStageOptions,
data_collector: DataCollector
):
"""
Run the inspection and output the dependency installation script.
Also recovers the size of the docker image generated.
:raises RuntimeError if the step was skipped when no dependency script has been
previously generated
"""
gather_rosdeps(
docker_client=docker_client,
platform=platform,
workspace=ros_workspace_dir,
skip_rosdep_keys=options.skip_rosdep_keys,
custom_script=options.custom_script,
custom_data_dir=options.custom_data_dir)
assert_install_rosdep_script_exists(ros_workspace_dir, platform)
img_size = docker_client.get_image_size(_IMG_NAME)
data_collector.add_size(self.name, img_size) | /ros_cross_compile-0.10.0-py3-none-any.whl/ros_cross_compile/dependencies.py | 0.777173 | 0.178204 | dependencies.py | pypi |
import getpass
from typing import NamedTuple
from typing import Optional
ArchNameMapping = NamedTuple('ArchNameMapping', [('docker', str), ('qemu', str)])
# NOTE: when changing any following values, update README.md Supported Targets section
ARCHITECTURE_NAME_MAP = {
'armhf': ArchNameMapping(docker='arm32v7', qemu='arm'),
'aarch64': ArchNameMapping(docker='arm64v8', qemu='aarch64'),
'x86_64': ArchNameMapping(docker='', qemu='x86_64'),
}
SUPPORTED_ARCHITECTURES = tuple(ARCHITECTURE_NAME_MAP.keys())
SUPPORTED_ROS2_DISTROS = ('foxy', 'galactic', 'humble', 'rolling')
SUPPORTED_ROS_DISTROS = ('melodic', 'noetic')
ROSDISTRO_OS_MAP = {
'melodic': {
'ubuntu': 'bionic',
'debian': 'stretch',
},
'noetic': {
'ubuntu': 'focal',
'debian': 'buster',
},
'foxy': {
'ubuntu': 'focal',
'debian': 'buster',
},
'galactic': {
'ubuntu': 'focal',
'debian': 'buster',
},
'humble': {
'ubuntu': 'jammy',
'debian': 'bullseye',
},
'rolling': {
'ubuntu': 'jammy',
'debian': 'bullseye',
},
}
# NOTE: when changing any preceding values, update README.md Supported Targets section
class Platform:
"""
Represents the target platform for cross compiling.
Includes:
* Target architecture
* Target operating system
* Target ROS distribution
"""
def __init__(
self, arch: str, os_name: str, ros_distro: str, override_base_image: Optional[str] = None,
):
"""Initialize platform parameters."""
self._arch = arch
self._ros_distro = ros_distro
self._os_name = os_name
try:
docker_org = ARCHITECTURE_NAME_MAP[arch].docker
except KeyError:
raise ValueError('Unknown target architecture "{}" specified'.format(arch))
if self.ros_distro in SUPPORTED_ROS2_DISTROS:
self._ros_version = 'ros2'
elif self.ros_distro in SUPPORTED_ROS_DISTROS:
self._ros_version = 'ros'
else:
raise ValueError('Unknown ROS distribution "{}" specified'.format(ros_distro))
os_map = ROSDISTRO_OS_MAP[self.ros_distro]
if self.os_name not in os_map:
raise ValueError(
'OS "{}" not supported for ROS distro "{}". Supported values: {} '
'(note that these are case sensitive)'.format(
os_name, ros_distro, list(os_map.keys())))
if override_base_image:
self._docker_target_base = override_base_image
else:
self._os_distro = ROSDISTRO_OS_MAP[self.ros_distro][self.os_name]
native_base = '{}:{}'.format(self.os_name, self.os_distro)
if docker_org:
self._docker_target_base = '{}/{}'.format(docker_org, native_base)
else:
self._docker_target_base = native_base
@property
def arch(self):
return self._arch
@property
def qemu_arch(self):
return ARCHITECTURE_NAME_MAP[self.arch].qemu
@property
def ros_distro(self):
return self._ros_distro
@property
def os_name(self):
return self._os_name
@property
def os_distro(self):
return self._os_distro
@property
def ros_version(self):
return self._ros_version
def __str__(self):
"""Return string representation of platform parameters."""
return '-'.join((self.arch, self.os_name, self.ros_distro))
@property
def sysroot_image_tag(self) -> str:
"""Generate docker image name and tag."""
return getpass.getuser() + '/' + str(self) + ':latest'
@property
def target_base_image(self) -> str:
"""Name of the base OS Docker image for the target architecture."""
return self._docker_target_base | /ros_cross_compile-0.10.0-py3-none-any.whl/ros_cross_compile/platform.py | 0.738575 | 0.159807 | platform.py | pypi |
from contextlib import contextmanager
from datetime import datetime
from enum import Enum
import json
from pathlib import Path
import time
from typing import Dict, List, NamedTuple, Union
from ros_cross_compile.platform import Platform
INTERNALS_DIR = 'cc_internals'
Datum = NamedTuple('Datum', [('name', str),
('value', Union[int, float]),
('unit', str),
('timestamp', float),
('complete', bool)])
class Units(Enum):
Seconds = 'Seconds'
Bytes = 'Bytes'
class DataCollector:
"""Provides an interface to collect time series data."""
def __init__(self):
self._data = []
@property
def data(self):
return self._data
def add_datum(self, new_datum: Datum):
self._data.append(new_datum)
@contextmanager
def timer(self, name: str):
"""Provide an interface to time a statement's duration with a 'with'."""
start = time.monotonic()
complete = False
try:
yield
complete = True
finally:
elapsed = time.monotonic() - start
time_metric = Datum('{}-time'.format(name), elapsed,
Units.Seconds.value, time.time(), complete)
self.add_datum(time_metric)
def add_size(self, name: str, size: int):
"""Provide an interface to add collected Docker image sizes."""
size_metric = Datum('{}-size'.format(name), size,
Units.Bytes.value, time.time(), True)
self.add_datum(size_metric)
class DataWriter:
"""Provides an interface to write collected data to a file."""
def __init__(self, ros_workspace_dir: Path,
output_file):
"""Configure path for writing data."""
self._write_path = Path(str(ros_workspace_dir)) / Path(INTERNALS_DIR) / Path('metrics')
self._write_path.mkdir(parents=True, exist_ok=True)
self.write_file = self._write_path / output_file
def print_helper(self, data_to_print: List[Datum]):
print('--------------------------------- Collected Data ---------------------------------')
print('=================================================================================')
for datum in data_to_print:
# readable_time = time.strftime('%Y-%m-%d %H:%M:%S', time.gmtime(datum['timestamp']))
readable_time = datetime.utcfromtimestamp(datum.timestamp).isoformat()
if datum.unit == Units.Seconds.value:
print('{:>12} | {:>35}: {:.2f} {}'.format(readable_time, datum.name,
datum.value, datum.unit),
end='')
else:
print('{:>12} | {:>35}: {} {}'.format(readable_time, datum.name,
datum.value, datum.unit),
end='')
if datum.complete:
print('\n')
else:
print(' {}'.format('incomplete'))
def serialize_to_cloudwatch(self, data: List[Datum], platform: Platform) -> List[Dict]:
"""
Serialize collected datums to fit the AWS Cloudwatch publishing format.
To get an idea of what the Cloudwatch formatting is like, refer to
https://awscli.amazonaws.com/v2/documentation/api/latest/reference/
cloudwatch/put-metric-data.html.
"""
def serialize_helper(datum: Datum) -> Dict:
return {
'MetricName': datum.name,
'Value': datum.value,
'Unit': datum.unit,
'Timestamp': datum.timestamp,
'Dimensions': [{'Name': 'Complete', 'Value': str(datum.complete)},
{'Name': 'Architecture', 'Value': platform.arch},
{'Name': 'OS', 'Value': platform.os_name},
{'Name': 'ROS Distro', 'Value': platform.ros_distro}]
}
return [serialize_helper(d) for d in data]
def write(self, data_collector: DataCollector, platform: Platform, print_data: bool):
"""
Write collected datums to a file.
Before writing, however, we convert each datum to a dictionary,
so that they are conveniently 'dumpable' into a JSON file.
"""
if print_data:
self.print_helper(data_collector.data)
with self.write_file.open('w') as f:
data_to_dump = self.serialize_to_cloudwatch(data_collector.data, platform)
json.dump(list(data_to_dump), f, sort_keys=True, indent=4) | /ros_cross_compile-0.10.0-py3-none-any.whl/ros_cross_compile/data_collector.py | 0.852445 | 0.299156 | data_collector.py | pypi |
from distutils.dir_util import copy_tree
import logging
from pathlib import Path
import platform as py_platform
import shutil
from typing import Optional
from ros_cross_compile.data_collector import DataCollector
from ros_cross_compile.data_collector import INTERNALS_DIR
from ros_cross_compile.docker_client import DockerClient
from ros_cross_compile.pipeline_stages import PipelineStage
from ros_cross_compile.pipeline_stages import PipelineStageOptions
from ros_cross_compile.platform import Platform
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)
def build_internals_dir(platform: Platform) -> Path:
"""Construct a relative path for this build, for storing intermediate artifacts."""
return Path(INTERNALS_DIR) / str(platform)
def _copytree(src: Path, dest: Path) -> None:
"""Copy contents of directory 'src' into 'dest'."""
copy_tree(str(src), str(dest))
def _copyfile(src: Path, dest: Path) -> None:
"""Copy a single file to a destination location."""
shutil.copy(str(src), str(dest))
def _copy_or_touch(src: Optional[Path], dest: Path) -> None:
"""
Copy a single file, if specified, to a destination.
If the file src is not provided, create an empty file at dest.
"""
if src:
_copyfile(src, dest)
else:
dest.touch()
def setup_emulator(arch: str, output_dir: Path) -> None:
"""Copy the appropriate emulator binary to the output location."""
emulator_name = 'qemu-{}-static'.format(arch)
bin_dir = output_dir / 'bin'
bin_dir.mkdir(parents=True, exist_ok=True)
needs_emulator = (py_platform.system() != 'Darwin') and (py_platform.machine() != arch)
if needs_emulator:
"""
Using the same qemu binaries as the ones provided in
https://github.com/osrf/multiarch-docker-image-generation in order to
work around https://bugs.launchpad.net/qemu/+bug/1805913 and so qemu
supports renameat2() syscall.
"""
emulator_path = Path(__file__).parent / 'qemu' / emulator_name
if not emulator_path.is_file():
raise RuntimeError('Could not find the expected QEmu emulator binary "{}"'.format(
emulator_path))
_copyfile(emulator_path, bin_dir)
else:
(bin_dir / emulator_name).touch()
def prepare_docker_build_environment(
platform: Platform,
ros_workspace: Path,
custom_setup_script: Optional[Path] = None,
custom_post_build_script: Optional[Path] = None,
colcon_defaults_file: Optional[Path] = None,
custom_data_dir: Optional[Path] = None,
) -> Path:
"""
Prepare the directory for the sysroot.Docker build context.
:param platform Information about the target platform
:param ros_workspace Location of the ROS source workspace
:param custom_setup_script Optional arbitrary script
:param colcon_defaults_file Optional colcon configuration file
:param custom_data_dir Optional arbitrary directory for use by custom_setup_script
:return The directory that was created.
"""
package_dir = Path(__file__).parent
docker_build_dir = ros_workspace / build_internals_dir(platform)
docker_build_dir.mkdir(parents=True, exist_ok=True)
_copytree(package_dir / 'docker', docker_build_dir)
_copytree(package_dir / 'mixins', docker_build_dir / 'mixins')
custom_data_dest = docker_build_dir / 'user-custom-data'
if custom_data_dir:
_copytree(custom_data_dir, custom_data_dest)
else:
custom_data_dest.mkdir(exist_ok=True)
_copy_or_touch(custom_setup_script, docker_build_dir / 'user-custom-setup')
_copy_or_touch(custom_post_build_script, docker_build_dir / 'user-custom-post-build')
if colcon_defaults_file:
_copyfile(colcon_defaults_file, docker_build_dir / 'defaults.yaml')
else:
(docker_build_dir / 'defaults.yaml').write_text("""
build:
event-handlers: ["console_cohesion+","console_package_list+"]
""")
setup_emulator(platform.qemu_arch, docker_build_dir)
return docker_build_dir
def create_workspace_sysroot_image(
docker_client: DockerClient,
platform: Platform,
) -> None:
"""
Create the target platform sysroot image.
:param docker_client Docker client to use for building
:param platform Information about the target platform
:param build_context Directory containing all assets needed by sysroot.Dockerfile
"""
image_tag = platform.sysroot_image_tag
logger.info('Building sysroot image: %s', image_tag)
docker_client.build_image(
dockerfile_name='sysroot.Dockerfile',
tag=image_tag,
buildargs={
'BASE_IMAGE': platform.target_base_image,
'ROS_VERSION': platform.ros_version,
}
)
logger.info('Successfully created sysroot docker image: %s', image_tag)
class CreateSysrootStage(PipelineStage):
"""
This stage creates the target platform Docker sysroot image.
It will output the sysroot image.
"""
def __init__(self):
super().__init__('sysroot')
def __call__(
self,
platform: Platform,
docker_client: DockerClient,
ros_workspace_dir: Path,
options: PipelineStageOptions,
data_collector: DataCollector
):
create_workspace_sysroot_image(docker_client, platform)
img_size = docker_client.get_image_size(platform.sysroot_image_tag)
data_collector.add_size(self.name, img_size) | /ros_cross_compile-0.10.0-py3-none-any.whl/ros_cross_compile/sysroot_creator.py | 0.82887 | 0.321074 | sysroot_creator.py | pypi |
from typing import List
from py_d2 import D2Connection, D2Diagram, D2Shape, D2Style, D2Text, Direction
from py_d2.shape import Shape
from ros_d2.helpers.get_ros_architecture import RosArchitecture
node_style = D2Style(
opacity=0.6,
three_d=True,
)
def concat_strings(strings: List[str]) -> str:
"""Concatenates a list of strings into a single string."""
return ", ".join(strings)
def convert(ros_architecture: RosArchitecture, verbose: bool = False) -> str:
"""Converts a list of NodeInfo objects to a d2 graph."""
diagram = D2Diagram()
for topic in ros_architecture.topics:
if verbose:
shape = D2Shape(
name=topic.name,
shape=Shape.classs,
topic=D2Text(text=concat_strings(topic.types), format=""),
)
else:
shape = D2Shape(name=topic.name, shape=Shape.classs)
diagram.add_shape(shape)
for node_info in ros_architecture.nodes:
shape = D2Shape(name=node_info.name, style=node_style)
diagram.add_shape(shape)
for sub in node_info.subs:
diagram.add_connection(
D2Connection(
# label=concat_strings(sub.types),
shape_1=node_info.name,
shape_2=sub.name,
direction=Direction.FROM,
)
)
for pub in node_info.pubs:
diagram.add_connection(
D2Connection(
# label=concat_strings(pub.types),
shape_1=node_info.name,
shape_2=pub.name,
direction=Direction.TO,
)
)
for client in node_info.clients:
diagram.add_connection(
D2Connection(
# label=concat_strings(pub.types),
shape_1=node_info.name,
shape_2=client.name,
direction=Direction.TO,
)
)
for service in node_info.services:
diagram.add_connection(
D2Connection(
# label=concat_strings(pub.types),
shape_1=node_info.name,
shape_2=service.name,
direction=Direction.FROM,
)
)
return str(diagram) | /ros_d2-1.0.5-py3-none-any.whl/ros_d2/helpers/convert.py | 0.860823 | 0.384421 | convert.py | pypi |
from dataclasses import dataclass
from typing import List, Tuple
from ros2cli.node.strategy import NodeStrategy
from ros2node.api import get_node_names
TOPICS_TO_IGNORE = [
"/parameter_events",
"/rosout",
]
TOPIC_TYPES_TO_IGNORE = [
"rcl_interfaces/srv/ListParameters",
"rcl_interfaces/srv/SetParameters",
"rcl_interfaces/srv/GetParameterTypes",
"rcl_interfaces/srv/GetParameters",
"rcl_interfaces/srv/SetParametersAtomically",
"rcl_interfaces/srv/DescribeParameters",
]
@dataclass
class TopicInfo:
# Topic name
name: str
# Topic types
types: List[str]
@dataclass
class NodeInfo:
# Node name
name: str
# Node publisher topics
subs: List[TopicInfo]
# Node subscriber topics
pubs: List[TopicInfo]
# Node services
services: List[TopicInfo]
# Node service clients
clients: List[TopicInfo]
@dataclass
class RosArchitecture:
nodes: List[NodeInfo]
topics: List[TopicInfo]
def filter_topics(topics: List[TopicInfo]) -> List[TopicInfo]:
return [
t
for t in topics
if t.name not in TOPICS_TO_IGNORE and t.types[0] not in TOPIC_TYPES_TO_IGNORE
]
def topic_tuple_to_info(topic_tuple: Tuple[str, List[str]]) -> TopicInfo:
return TopicInfo(name=topic_tuple[0], types=topic_tuple[1])
def get_ros_architecture() -> RosArchitecture:
# Get all the nodes and their oublisher and subscriber topics
nodes: List[NodeInfo] = []
with NodeStrategy([]) as node:
node_names = get_node_names(node=node)
for n in node_names:
node_name = n.full_name
subs_tuple = node.get_subscriber_names_and_types_by_node(
n.name, n.namespace
)
pubs_tuple = node.get_publisher_names_and_types_by_node(n.name, n.namespace)
subs = [topic_tuple_to_info(t) for t in subs_tuple]
pubs = [topic_tuple_to_info(t) for t in pubs_tuple]
services_tuple = node.get_service_names_and_types_by_node(
n.name, n.namespace
)
services = [topic_tuple_to_info(t) for t in services_tuple]
clients_tuple = node.get_client_names_and_types_by_node(n.name, n.namespace)
clients = [topic_tuple_to_info(t) for t in clients_tuple]
subs = filter_topics(subs)
pubs = filter_topics(pubs)
services = filter_topics(services)
clients = filter_topics(clients)
node_info = NodeInfo(
name=node_name, subs=subs, pubs=pubs, services=services, clients=clients
)
nodes.append(node_info)
# Get all the unique topics
topic_names = set()
topics: List[TopicInfo] = []
for node_info in nodes:
for sub in node_info.subs:
if sub.name not in topic_names:
topic_names.add(sub.name)
topics.append(sub)
for pub in node_info.pubs:
if pub.name not in topic_names:
topic_names.add(pub.name)
topics.append(pub)
for srv in node_info.services:
if srv.name not in topic_names:
topic_names.add(srv.name)
topics.append(srv)
# Order them alphabetically
topics.sort(key=lambda t: t.name)
nodes.sort(key=lambda n: n.name)
return RosArchitecture(
topics=topics,
nodes=nodes,
) | /ros_d2-1.0.5-py3-none-any.whl/ros_d2/helpers/get_ros_architecture.py | 0.745398 | 0.293727 | get_ros_architecture.py | pypi |
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
# http://www.apache.org/licenses/LICENSE-2.0
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""
This module contains the Repo class.
"""
import os
from typing import Any, Dict, Optional
import git
from scancode.api import get_licenses
from ros_license_toolkit.common import is_license_text_file
# how many folders up to search for a repo
REPO_SEARCH_DEPTH = 5
def is_git_repo(path: str) -> bool:
"""Check if a path is a git repo."""
return os.path.isdir(os.path.join(path, ".git"))
class NotARepoError(Exception):
"""Exception raised when we can't find a repo."""
class Repo:
"""Represents a git repository."""
def __init__(self, package_path: str):
"""Initialize a Repo object.
:param package_path: Absolute path to the package.
:type package_path: str
"""
# absolute path to the package
self.abs_package_path: str = package_path
# repo path relative to the package
relpath: Optional[str] = None
search_path = package_path
for _ in range(REPO_SEARCH_DEPTH + 1):
if is_git_repo(search_path):
relpath = os.path.relpath(
search_path, self.abs_package_path)
break
search_path = os.path.dirname(search_path)
if relpath is None:
raise NotARepoError("No git repo found for package.")
# absolute path to the repo
self.abs_path: str = os.path.normpath(os.path.join(
self.abs_package_path, relpath))
# (for logging purposes) the current git hash
repo = git.Repo(search_path)
self.git_hash: str = repo.head.object.hexsha
# scan files in the repo
self.license_text_files: Dict[str, Dict[str, Any]] = {}
for file in os.scandir(self.abs_path):
fpath = os.path.join(self.abs_path, file)
if not os.path.isfile(fpath):
continue
scan_results = get_licenses(fpath)
if is_license_text_file(scan_results):
self.license_text_files[fpath] = scan_results
def __eq__(self, __o) -> bool:
"""Check if two repos are the same."""
return os.path.samefile(self.abs_path, __o.abs_path)
def get_path(self) -> str:
"""Get the absolute path to the repo."""
return self.abs_path
def get_hash(self) -> str:
"""Get the current git hash."""
return self.git_hash | /ros_license_toolkit-1.1.5-py3-none-any.whl/ros_license_toolkit/repo.py | 0.899853 | 0.235317 | repo.py | pypi |
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
# http://www.apache.org/licenses/LICENSE-2.0
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""
Module containing the entry point for the ros_license_toolkit CLI.
"""
import argparse
import os
import sys
import timeit
from typing import Optional, Sequence
from ros_license_toolkit.checks import (LicensesInCodeCheck,
LicenseTagExistsCheck,
LicenseTagIsInSpdxListCheck,
LicenseTextExistsCheck)
from ros_license_toolkit.package import get_packages_in_path
from ros_license_toolkit.ui_elements import (FAILURE_STR, SUCCESS_STR,
Verbosity, green, major_sep,
minor_sep, red, rll_print_factory)
def main(args: Optional[Sequence[str]] = None) -> int:
"""Main entry point for the ros_license_toolkit CLI.
:param args: the command line arguments, defaults to sys.argv[1:]
:type args: Sequence[str], optional
:return: the exit code, `os.EX_OK` if all checks passed, `os.EX_USAGE` if
no packages were found, `os.EX_DATAERR` if any check failed
:rtype: int
"""
if not args:
args = sys.argv[1:]
parser = argparse.ArgumentParser(
description='Checks ROS packages for correct license declaration.')
parser.add_argument(
'path', default='.',
help='path to ROS2 package or repo containing packages')
parser.add_argument(
'-c', '--generate_copyright_file', action='store_true',
default=False, help='generate a copyright file')
parser.add_argument(
'-v', '--verbose', dest='verbose', action='store_true',
default=False, help='enable verbose output')
parser.add_argument(
'-q', '--quiet', dest='quiet', action='store_true',
default=False, help='disable most output')
parsed_args = parser.parse_args(args)
# Determine the verbosity level
if parsed_args.quiet:
verbosity = Verbosity.QUIET
elif parsed_args.verbose:
verbosity = Verbosity.VERBOSE
else:
verbosity = Verbosity.NORMAL
rll_print = rll_print_factory(verbosity)
# Sanity check the path
assert isinstance(parsed_args.path, str)
assert os.path.exists(
parsed_args.path), f'Path {parsed_args.path} does not exist.'
# Get the packages in the path
packages = get_packages_in_path(parsed_args.path)
if not packages:
rll_print(f'No packages found in {parsed_args.path}', Verbosity.QUIET)
return os.EX_USAGE
rll_print(
f'Found {len(packages)} packages in {parsed_args.path}',
Verbosity.QUIET)
rll_print(
f' Packages: {", ".join([p.name for p in packages])}',
Verbosity.VERBOSE)
rll_print(major_sep())
# lets time the execution
start = timeit.default_timer()
# Check the packages
results_per_package = {}
for package in packages:
rll_print(f'[{package.name}]')
assert package.repo is not None, 'Package must be in a git repo.'
rll_print(
f'git hash of ({package.repo.get_path()}):'
f' {package.repo.get_hash()}')
checks_to_perform = [
LicenseTagExistsCheck(),
LicenseTagIsInSpdxListCheck(),
LicenseTextExistsCheck(),
LicensesInCodeCheck()]
for check in checks_to_perform:
check.check(package)
rll_print(check)
rll_print(check.verbose(), Verbosity.VERBOSE)
if all(checks_to_perform):
rll_print(minor_sep())
rll_print(f"[{package.name}] Overall:" + green(
f"\n {SUCCESS_STR}"))
rll_print(major_sep())
results_per_package[package.abspath] = True
else:
rll_print(minor_sep())
rll_print(f"[{package.name}] Overall:" + red(
f"\n {FAILURE_STR}"))
rll_print(major_sep())
results_per_package[package.abspath] = False
if parsed_args.generate_copyright_file:
package.write_copyright_file()
stop = timeit.default_timer()
rll_print(f'Execution time: {stop - start:.2f} seconds', Verbosity.QUIET)
# Print the overall results
if all(results_per_package.values()):
rll_print("All packages:" + green(
f"\n {SUCCESS_STR}"), Verbosity.QUIET)
return os.EX_OK
rll_print("All packages:" + red(f"\n {FAILURE_STR}"), Verbosity.QUIET)
return os.EX_DATAERR | /ros_license_toolkit-1.1.5-py3-none-any.whl/ros_license_toolkit/main.py | 0.797636 | 0.257896 | main.py | pypi |
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
# http://www.apache.org/licenses/LICENSE-2.0
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Assemble copyright notices for a package."""
import os
import re
from typing import Any, Dict, List, Tuple, Union
from scancode.api import get_copyrights
def _get_copyright_strs_from_results(
scan_results: Dict[str, Any]) -> List[str]:
"""Get copyright strings from scan results."""
return [cpr['copyright'] for cpr in scan_results['copyrights']]
def _get_year_from_copyright_str(cpr_str: str) -> Union[int, Tuple[int, int]]:
"""Get the year from a copyright string."""
finds = re.findall(r"\d{4}", cpr_str)
if len(finds) == 1:
return int(finds[0])
elif len(finds) == 2:
return (int(finds[0]), int(finds[1]))
else:
raise ValueError("Unexpected number of digits in year")
class CopyrightPerFile:
"""A copyright notice for a single file."""
def __init__(self, file_path: str, copyright_text: str):
self.file_path = file_path
for prefix_to_remove in [
'copyright',
'Copyright (c) ',
'Copyright ',
'Copyright'
]:
if copyright_text.startswith(prefix_to_remove):
copyright_text = copyright_text[len(prefix_to_remove):]
break
self.copyright_text = copyright_text
def __str__(self):
return self.copyright_text
class CopyrightPerPkg:
def __init__(self, pkg):
self.pkg = pkg
# one section per license tag
# each section is a list of unique copyright lines
self.copyright_strings: Dict[str, List[str]] = {}
for key, license_tag in self.pkg.license_tags.items():
cprs = set()
for source_file in license_tag.source_files:
fpath = os.path.join(self.pkg.abspath, source_file)
res = get_copyrights(fpath)
if len(res) == 0:
continue
for cpr in _get_copyright_strs_from_results(res):
cprs.add(CopyrightPerFile(source_file, cpr))
self.copyright_strings[key] = sorted(
{cpr.copyright_text for cpr in cprs})
def __str__(self):
return " ".join(" ".join(copyrights)
for copyrights in self.copyright_strings.values()) | /ros_license_toolkit-1.1.5-py3-none-any.whl/ros_license_toolkit/copyright.py | 0.931455 | 0.245175 | copyright.py | pypi |
<img src="https://github.com/NCATS-Tangerine/ros/blob/master/media/ros.png" width="40%"></src>
## Overview
Ros executes graphs of queries to cooperatively compose knowledge networks.
While the language provides common constructs supporting variables, modularity, extensibility, templates, and a type system, it is targeted at the distinctive challenges of creating **highly detailed knowledge graphs enabling reasoning and inference**.
### Usage
Running a workflow locally from the command line produces output like this:
<img src="https://github.com/NCATS-Tangerine/ros/blob/master/media/run.png" width="100%"></src>
And builds this knowledge graph:
<img src="https://github.com/NCATS-Tangerine/ros/blob/master/media/wf1_output.png" width="100%"></src>
- [Overview](#overview)
* [Usage](#usage)
- [Language Reference](#language-reference)
* [Overview](#overview-1)
* [Variables](#variables)
* [Operators](#operators)
* [Graphs](#graphs)
* [Metadata](#metadata)
* [Templates](#templates)
* [Modules](#modules)
- [Putting it All Together](#putting-it-all-together)
* [1. Define A Template](#1-define-a-template)
* [2. Optionally Model Input and Output Types](#2-optionally-model-input-and-output-types)
* [3. Build the Workflow](#3-build-the-workflow)
- [Execution](#execution)
- [Getting Started](#getting-started)
* [Docker](#docker)
+ [Requirements](#requirements)
+ [Start](#start)
* [Usage - Command Line](#usage---command-line)
* [Usage - Programmatic](#usage---programmatic)
* [Install](#install)
* [NDEx](#ndex)
* [Help](#help)
## Language Reference
### Overview
A workflow is a series of steps.
Steps can reference the output of previous steps.
In general they have access to a shared graph.
They can also exchange sub-graphs.
Steps can have associated metadata describing their allowed input and output types.
Workflows compute a directed acyclic graph (DAG) modeling job dependencies which are then executed in the order indicated by a topological sort of the DAG.
### Variables
Variables passed to the workflow at the command line or via the API can be resolved dynamically. In this example, $disease_name refers to an argument provided by the execution context to this workflow. The provided value will be substituted at runtime.
In the example below, `disease_identifiers` is the job's name. It produces a graph. The JSON object representing that graph will be stored as the value of the job's name. The graph is also written to the shared graph database. Subsequent jobs can interact with either representation.
The `code` tag tells the engine which block of functionality to execute.
The `args` section lists inputs to this operator.
```
disease_identifiers:
doc: |
Resolve an English disease name to an ontology identifier.
code: bionames
args:
type: disease
input: $disease_name
```
### Operators
The workflow is organized around graph operators. Each has access to all facilities of the Ros framework including the shared graph.
In general, workflow jobs have the following fields:
* **doc**: A documentation string.
* **code**: The name of a component providing functionality.
* **args**: Arguments to the operator.
Ros currently provides the following core operators:
* **get**: Invokes an HTTP GET operation on a specified resource.
* **union**: Unions two or more results into one object.
It also includes certain Translator specific modules. In the future, these will be implemented as Ros plugins:
* **biothings**: BioThings modules. Currently modules 4 and 5 of workflow 1.
* **gamma**: Invokes the Gamma reasoner. The example below calls Gamma a few times with different machine questions. It will be updated to use the new Quick API for added flexibility.
* **xray**: XRay reasoner modules. Currently modules 1 and 2 of workflow 1.
### Graphs
Ros provides graphs in two basic modalities:
* **Results**: Results of previous workflow steps can be referenced as variables passed to subsequent steps. This graph can be queried using JSON Path query syntax. The following example uses the json select facility in the Ros framework to query a variable called *condition*:
```
diseases = event.select (
query = "$.[*].result_list.[*].[*].result_graph.node_list.[*]",
obj = event.conditions)
```
* **Shared**: A shared graph, accessible with the Cypher query language is available to all operators. This example uses the Ros framework's cypher query on the shared graph with biolink-model concepts.
```
diseases = event.context.graph.query ("match (a:disease) return a")
```
Each operator receives an event object provided by the Ros framework. The event provides framework services including the shared graph, graph manipulation tools, and arguments to the invocation of the operator.
These facilities allow the operator to query the graphs before executing their main logic and to update it as well.
### Metadata
The language supports a metadata capability to enable modules to specify their inputs and outputs.
Inputs support these tags:
* **doc**: Documentation
* **type**: Types are currently derived from a standard library but in the future will be extensible and composable.
* **required**: Whether or not the argument is required.
Outputs support these tags:
* **doc**: Documentation.
* **type**: Type of the returned object.
The use of metadata is optional.
### Templates
Templates allow extension of the language by specializing existing library functions into new capabilities through composition. Templates are defined in a template section separate from the workflow proper. They can also be defined in separate, reusable modules.
### Modules
External modules can be loaded via the `import` tag.
A library path like those featured in other high level programming languages governs where libraries are loaded from.
### Automated Validation
When a workflow has run, we'd like to run validations that test the integrity of the answer we got. In this first Ros version, we support a limited form of automated validation. The limitations are motivated by making Ros secure. Since we execute queries remotely, it's not realistic to run arbitrary graph queries posted from clients on the internet. Instead, we provide a limited query syntax that still allows us to do a lot of validation. The query syntax is called Syfur - a less capable query system reminiscent of Cypher.
The example below from workflow_one shows Syfur's usage.
```
automated_validation:
doc: |
Automated Validation
We can test the knowledge network with constraints including all, match, and none.
The depends arg ensures the validation runs only after the graph is built.
Each test has a name, documentation, a query, and an operator defining the constraint to enforce
Syfur
A principal virtue of Ros is the ability to remotely execute workflows.
To make this possible, it must be secured against remote code execution attacks
This includes cypher injection.
It may be possible to accomplish some of this in other ways, but for now, we provide Syfur
Syfur is a restricted DSL that translates to a subset of Cypher. See examples below.
code: validate
args:
depends: $biothings_module_4_and_5
tests:
test_type_2_diabetes_exists:
doc: Ensure type 2 diabetes mellitus and other conditions are present.
items: "match type=disease return id"
all: [ "OMIM:600001", "MONDO:0005148", "DOID:9352" ]
test_pioglitazone:
doc: Test attributes of a specific chemical. Ensure type 2 diabetes mellitus is present.
items: "match type=chemical_substance id=CHEMBL.COMPOUND:CHEMBL595 return node_attributes"
match:
- .*Thiazolidinedione.*
- ".*{'name': 'EPC', 'value': 'Peroxisome Proliferator Receptor gamma Agonist'}.*"
test_absence_of_something:
doc: Verify there is none of something in our graph.
items: "match return id"
none: [ 'BAD:123' ]
```
## Putting it All Together
Here's a usage example to put all of this in context.
### 1. Define A Template
We begin with the common use case of converting user supplied text into ontology identifiers. We create a template task for this purpose.
* It extends the builtin `get` http operator and sets the `pattern` argument to a defined value.
* It's saved to a file called `bionames.ros` in a directory that's on the library path.
The bionames template is now a reusable component that can be imported into a variety of workflows.
### 2. Optionally Model Input and Output Types
Though currently optional, the template also specifies
* The `meta` tag describes metadata about the operator.
* The `main` operator is used when no sub-operators are specified.
* Each operator has input and output sections.
* The **input** section specifies a list of input values.
* Each may have `doc`, `type`, and `required` tags.
* The **output** section may contain `doc` and `type` tags.
* In both cases, values of `type` must (currently) come from the Ros standard library, described elsewhere.
```
doc: |
This module defines a reusable template.
It can be imported into other workflows via the import directive.
templates:
bionames:
doc: |
This template extends the built in get operator.
code: get
args:
pattern: 'https://bionames.renci.org/lookup/{input}/{type}/'
meta:
main:
args:
input:
doc: The name of the object to find identifiers for.
type: string
required: true
type:
doc: The intended biolink_model type of the resulting identifiers.
type: biolink_model
required: true
output:
doc: A Translator standard knowledge graph.
type: knowledge_graph_standard
```
The `biolink_model` and `knowledge_graph_standard` types are currently modeled directly in the Ros [standard library](https://github.com/NCATS-Tangerine/ros/blob/master/ros/stdlib.yaml):
```
types:
string :
doc: A primitive string of characters.
extends: primitive
biolink_model:
doc: An element from the Biolink-model
extends: string
knowledge_graph_standard:
doc: A Translator knowledge graph standard (KGS) knowledge graph.
extends: primitive
```
### 3. Build the Workflow
Next, we import the template above into a workflow definition.
```
doc: |
NCATS Biomedical Translator - Workflow One
import:
- bionames
workflow:
disease_identifiers:
doc: |
Resolve an English disease name to an ontology identifier.
code: bionames
args:
type: disease
input: $disease_name
...
```
The `disease_identifiers` task instantiates the bionames template. It supplies the required arguments, including resolving the `disease_name` input argument specific to this workflow.
Once this module has executed, subsequent steps can reference the graph it produced via the variable `$disease_identifiers`.
The next step in the workflow makes use of this by referencing the output of our template invocation. The workflow engine sees this reference and makes the new job depend on the referenced job. This is how the job DAG governing execution order is calculated.
```
condition_to_drug:
doc: |
Module 1
* What are the defining symptoms / phenotypes of [condition x]?
* What conditions present [symptoms]?
* Filter [conditions] to only keep ones with defined genetic causes.
* What subset of conditions are most representative of [conditions]? (find archetypes)
Module 2
* What genes are implicated in [condition]?
* What subset of genes are most representative of [conditions]? (find archetypes)
* What pathways/processes are [genes] involved in?
* What genes are involved in [pathway/process]?
* What drugs/compounds target gene products of [gene]?
Invoke XRay module 1 and 2 given the disease identifier from bionames.
The graph argument references the entire bionames response.
The op argument specifies the XRay operation to execute.
code: xray
args:
op: condition_expansion_to_gene_pathway_drug
graph: $disease_identifiers
```
For more details, see the whole [workflow](https://github.com/NCATS-Tangerine/ros/blob/master/ros/workflow_one.ros).
## Execution
For all workflows, the engine builds a directed acyclic graph (DAG) of jobs by examining each job to determine its dependencies.
A topological sort of the jobs provides the execution order.
Execution is asynchronous. To the extent you subscribe to the [semantic distinction between 'concurrent' and 'parallel'](https://softwareengineering.stackexchange.com/questions/190719/the-difference-between-concurrent-and-parallel-execution) workflow execution is concurrent but not parallel.
The current implementation uses Python's [asyncio](https://docs.python.org/3/library/asyncio.html). This means multiple operations are able to make progress during the same time window. But it does not mean that the operations literally execute (run CPU operations) simultaneously. The current profile of operations is I/O bound rather than CPU bound so this approach is likely to be enough for a while. Several tasks can wait for an HTTP request to return while others use the processor to handle results.
The API also handles requests asynchronously using [Sanic](https://github.com/huge-success/sanic) and [Tornado](https://www.tornadoweb.org/en/stable/)
## Getting Started
### Docker
#### Requirements
* Docker
* Docker Compose (included with Docker on Mac)
* Git
* Ports 7474, 7687, and 5002 available
#### Start
```
git clone git@github.com:NCATS-Tangerine/ros.git
cd ros/deploy
source ros.env
docker-compose up
```
### Usage - Command Line
* Connect to the [local Neo4J](http://localhost:7474/browser/)
* Connect to the API docker container
* Run a workflow via the API.
```
$ cd ../ros
$ PYTHONPATH=$PWD/.. python app.py --api --workflow workflows/workflow_one.ros -l workflows -i disease_name="type 2 diabetes mellitus" --out stdout
```
### Usage - Programmatic
Ros can execute workflows remotely and return the resulting knowledge network. The client currently supports JSON and NetowrkX representations.
```
from ros.client import Client
ros = Client (url="http://localhost:5002")
response = ros.run (workflow='workflows/workflow_one.ros',
args = { "disease_name" : "type 2 diabetes mellitus" },
library_path = [ 'workflows' ])
graph = response.to_nx ()
for n in graph.nodes (data=True):
print (n)
```
### Install
**Requirements:**
* Python >3.7.x
* Neo4J >3.3.4
**Steps:**
These steps install the package, print help text, and execute workflow one. To run this, you'll need workflow_one.ros and bionames.ros from the repo. The `-l workflows` flag names the directory containing the workflows.
```
$ pip install ros
$ ros --help
$ ros --workflow workflow_one.ros --arg disease_name="diabetes mellitus type 2" -l workflows
```
### NDEx
To save a workflow to NDEx.
* Create an NDEx account.
* Create an ~/.ndex credential file like this:
```
{
"username" : "<username>",
"password" : "<password>"
}
```
* Run the workflow with NDEx output:
```
ros flow --workflow workflow_one.ros --out output.json --ndex wf1
```
### Help
```
$ PYTHONPATH=$PWD/.. python app.py --help
usage: app.py [-h] [-a] [-w WORKFLOW] [-s SERVER] [-i ARG] [-o OUT]
[-l LIBPATH] [-n NDEX] [--validate]
Ros Workflow CLI
optional arguments:
-h, --help show this help message and exit
-a, --api URL of the remote Ros server to use.
(default: False)
-w WORKFLOW, --workflow WORKFLOW Workflow to execute. (default:
workflow_one.ros)
-s SERVER, --server SERVER Hostname of api server (default:
http://localhost:5002)
-i ARG, --arg ARG Add an argument expressed as key=val
(default: [])
-o OUT, --out OUT Output the workflow result graph to a
file. Use 'stdout' to print to terminal.
(default: None)
-l LIBPATH, --libpath LIBPATH A directory containing workflow modules.
(default: ['.'])
-n NDEX, --ndex NDEX Name of the graph to publish to NDEx.
Requires valid ~/.ndex credential file.
(default: None)
--validate Validate inputs and outputs (default:
False)
```
## Next
* **Information Architecture**: Develop:
* **Controlled vocabulary**: Especially regarding what the modules are and how they relate
* **Input and Output Signatures**: For the modules
* **Provenance**: Both in terms of workflow provenance (which user, how long, etc) and metadata about sources (SCEPIO?).
* **Polymorphism**: It would be really helpful if multiple entities implementing a capability could implement the same OpenAPI interface to enable polymorphic invocation. This would also help with parallelism.
* **[KGX](https://github.com/NCATS-Tangerine/kgx)**: Maybe KGX should be the shared graph, at least optionally. Just need to design that connection.
* **Concurrent / Parallel / Distributed**: Ros now supports concurrent task execution via Python async. If this turns out not to be enough, explore running via something capable of parallel and maybe distributed execution.
* **Composability**: Allow workflows to import and reuse other workflows.
| /ros-0.119.tar.gz/ros-0.119/README.md | 0.949786 | 0.969556 | README.md | pypi |
import hypothesis.strategies as st
from collections import namedtuple
from hypothesis.errors import InvalidArgument
STRING_MIN_SIZE = 0
"""int: Minimal string size."""
STRING_MAX_SIZE = 1000
"""int: Maximal string size."""
@st.defines_strategy
def string(min_size=STRING_MIN_SIZE, max_size=STRING_MAX_SIZE):
"""
Generate value for ROS1 builtin message type "string".
:param min_size: int
Minimal size to generate
:param max_size: int
Maximal size to generate
:return: :func:`hypothesis.strategies.binary()`
Strategy with preconfigured default values.
"""
if not STRING_MIN_SIZE <= min_size <= max_size <= STRING_MAX_SIZE:
raise InvalidArgument
return st.binary(min_size=min_size, max_size=max_size)
@st.composite
def time(draw, secs=st.integers(min_value=0), nsecs=st.integers(min_value=0)):
"""
Generate value for ROS1 builtin message type "time".
:param secs: hypothesis_ros.message_fields.uint32()
Seconds
:param nsecs: hypothesis_ros.message_fields.uint32()
Nano seconds
:return: :class:`hypothesis_ros.message_fields.Time()`
Strategy with preconfigured default values.
"""
_Time = namedtuple('Time', 'secs nsecs')
secs_value, nsecs_value = draw(secs), draw(nsecs)
assert isinstance(secs_value, int), 'drew invalid sec={secs_value} from {secs} for integer field'. \
format(secs_value, secs)
assert isinstance(nsecs_value, int), 'drew invalid nsec={nsecs_value} from {nsecs} for integer field'. \
format(nsecs_value, nsecs)
return _Time(secs_value, nsecs_value)
@st.composite
def duration(draw, secs=st.integers(min_value=0), nsecs=st.integers(min_value=0)):
"""
Generate value for ROS1 builtin message type "duration".
:param secs: hypothesis_ros.message_fields.int32()
Seconds
:param nsecs: hypothesis_ros.message_fields.int32()
Nano seconds
:return: :class:`hypothesis_ros.message_fields.Duration()`
Namedtuple with drawn values for secs and nsecs.
"""
_Duration = namedtuple('Duration', 'secs nsecs')
secs_value, nsecs_value = draw(secs), draw(nsecs)
assert isinstance(secs_value, int), 'drew invalid sec={secs_value} from {secs} for integer field'. \
format(secs_value, secs)
assert isinstance(nsecs_value, int), 'drew invalid nsec={nsecs_value} from {nsecs} for integer field'. \
format(nsecs_value, nsecs)
return _Duration(secs_value, nsecs_value)
@st.defines_strategy
def array(elements=None, min_size=None, max_size=None, unique_by=None, unique=None):
"""
Generate variable length array with ROS1 builtin message types as elements.
To generate a fixed length array define `min_size == max_size`.
:param elements: hypothesis_ros.message_fields
Strategies for pritive types from hypothesis_ros.message_fields.
:param min_size: integer
Minimal size of the array.
:param max_size: integer
Maximal size of the array.
:param unique_by: callable
Function returning a hashable type when given a value from elements.
The resulting array (list) will satisfy `unique_by(result[i]) != unique_by(result[j])`.
:param unique: boolean
Function returning a hashable type. For comparison of directy object equality.
:return: :func:`hypothesis.strategies.lists()`
A variable or fixed length array containing values drawn from elements with
length in the interval [min_size, max_size] (no bounds in that direction
if these are None).
"""
# TODO: Assert that strategy for elements is from supported strategies.
if not min_size:
min_size = 0
return st.lists(elements=elements, min_size=min_size, max_size=max_size, unique_by=unique_by, unique=unique) | /ros1_fuzzer-1.0.0.tar.gz/ros1_fuzzer-1.0.0/ros1_fuzzer/ros_basic_strategies.py | 0.841223 | 0.533033 | ros_basic_strategies.py | pypi |
import importlib
import re
import numpy as np
import hypothesis.extra.numpy as npst
import hypothesis.strategies as st
from ros_basic_strategies import array, string, time, duration
try:
import rospy
import rosmsg
import rospkg
except ImportError:
print "Please install ROS first"
def ros_type_to_dict(msg_type):
"""
Create a dictionary which values say if the ROS message type is complex (not basic), which is its parent
ROS message module, its type, if it is an array and if so, its size.
:param msg_type: ROS message type.
:return: A dictionary which values say if the ROS message type is complex (not basic), which is its parent
ROS message module, its type, if it is an array and if so, its size.
"""
type_regexp = re.compile(
r'^(?P<complex>(?P<module>[\w]+)/)?(?P<type>[\w]+)(?P<array>\[(?P<array_size>[0-9]*)?\])?$')
type_match = type_regexp.match(msg_type)
if type_match:
return type_match.groupdict()
else:
return None
def ros_msg_loader(type_dict):
"""
Dynamically import ROS message modules.
:param type_dict: A dictionary which values say if the ROS message type is complex (not basic), which is its parent
ROS message module, its type, if it is an array and if so, its size.
:return: The ROS message class. If the provided type does not exist, raises an import error.
"""
try:
module = importlib.import_module(type_dict['module'] + '.msg')
return module.__dict__[type_dict['type']]
except KeyError:
raise KeyError('ROS message type: {} not included in message module: {}'.format(type_dict['type'],
type_dict['module']))
except ImportError:
raise ImportError('ROS message module: {} does not exist.'.format(type_dict['module']))
except TypeError:
raise TypeError('ROS message type: {} does not exist'.format(type_dict['type']))
def ros_msg_loader_str(msg_type):
"""
Wrapper for the :func:`ros_msg_loader` to treat string type command line arguments.
:param msg_type: A string type ROS message type (e.g. "Log").
:return: The :func:`ros_msg_loader` function.
"""
type_dict = ros_type_to_dict(msg_type)
if type_dict:
return ros_msg_loader(type_dict)
else:
raise ImportError('Unable to find defined ROS Message type: {}'.format(msg_type))
def create_publisher(topic, msg_type):
"""
Create an instance of a ROS publisher object an initialize it.
:param topic: The ROS topic that the publisher object is going to write in.
:param msg_type: ROS message type (e.g. Log).
:return: The newly created publisher object.
"""
pub = rospy.Publisher(topic, msg_type, queue_size=10)
rospy.init_node('fuzzer_node', anonymous=False)
return pub
def map_ros_types(ros_class):
"""
A recursive function that maps ROS message fields to Hypothesis strategies.
:param ros_class: The ROS class to be fuzzed.
:return: A function that generates Hypothesis strategies for a given ROS message type.
"""
strategy_dict = {}
slot_names = ros_class.__slots__
slot_types = ros_class._slot_types
slots_full = list(zip(slot_names, slot_types))
for s_name, s_type in slots_full:
type_dict = ros_type_to_dict(s_type)
if type_dict:
if not type_dict['complex']:
if type_dict['array']:
parse_basic_arrays(s_name, type_dict, strategy_dict)
elif type_dict['type'] is 'string':
strategy_dict[s_name] = st.text()
elif type_dict['type'] is 'time':
strategy_dict[s_name] = time()
elif type_dict['type'] is 'duration':
strategy_dict[s_name] = duration()
else: # numpy compatible ROS built-in types
strategy_dict[s_name] = npst.from_dtype(np.dtype(type_dict['type']))
else:
parse_complex_types(s_name, type_dict, strategy_dict)
return dynamic_strategy_generator_ros(ros_class, strategy_dict)
def parse_basic_arrays(s_name, type_dict, strategy_dict):
"""
Generate Hypothesis strategies for array types.
:param s_name: Slot name to be parsed.
:param type_dict: A dictionary which values say if the ROS message type is complex (not basic), which is its parent
ROS message module, its type, if it is an array and if so, its size.
:param strategy_dict: A pointer to a dictionary to be filled with Hypothesis strategies.
"""
if type_dict['array_size']:
array_size = int(type_dict['array_size'])
else:
array_size = None
if type_dict['type'] == 'string':
strategy_dict[s_name] = array(elements=string(), min_size=array_size, max_size=array_size)
else:
strategy_dict[s_name] = array(elements=npst.from_dtype(np.dtype(type_dict['type'])), min_size=array_size,
max_size=array_size)
def parse_complex_types(s_name, type_dict, strategy_dict):
"""
Generate Hypothesis strategies for complex ROS types.
:param s_name: Slot name to be parsed.
:param type_dict: A dictionary which values say if the ROS message type is complex (not basic), which is its parent
ROS message module, its type, if it is an array and if so, its size.
:param strategy_dict: A pointer to a dictionary to be filled with Hypothesis strategies.
"""
if not type_dict['array']:
strategy_dict[s_name] = map_ros_types(ros_msg_loader(type_dict))
else:
if type_dict['array_size']:
strategy_dict[s_name] = array(elements=map_ros_types(ros_msg_loader(type_dict)),
min_size=int(type_dict['array_size']),
max_size=int(type_dict['array_size']))
else:
strategy_dict[s_name] = array(elements=map_ros_types(ros_msg_loader(type_dict)))
@st.composite
def dynamic_strategy_generator_ros(draw, ros_class, strategy_dict): # This generates existing ROS msgs objects
"""
Generates Hypothesis strategies for a certain ROS class.
:param ros_class: The ROS class to be filed with fuzzed values.
:param strategy_dict: Strategy dictionary.
:return: A pointer to a dictionary filled with Hypothesis strategies.
"""
aux_obj = ros_class()
for key, value in strategy_dict.iteritems():
setattr(aux_obj, key, draw(value))
return aux_obj | /ros1_fuzzer-1.0.0.tar.gz/ros1_fuzzer-1.0.0/ros1_fuzzer/ros_commons.py | 0.591369 | 0.284644 | ros_commons.py | pypi |
from dataclasses import dataclass
import typing
from typing import Optional
import os
import numpy as np
import yaml
#!!!RELATIVE IMPORTS MUST HAVE A DOT OR THEY THROW AN ERROR WHEN THE FILE IMPORTING THE IMPORTING FILE TRYS THE IMPORT THE IMPORTING FILE!!!
from .Config import Config
PROJECT_PATH = os.getcwd() + "/"
class Package():
"""A ros2 package and its relevant information."""
global local_directory_for
local_directory_for = {
"URDFS": "urdf/",
"MODELS": "models/",
"RVIZ": "rviz/",
"PACKAGES": "src/",
}
"""people store files like models, urdfs, etc.. in different ways, refer to this schema for file paths on where to find file types"""
def __init__(self, name:str, executable_name:str, config:str = None, output:str= "screen", build:bool= False, optional_launch_file_node_args = None, entry_point:str = None):
#self.parent_pkg: "Package" = parent_pkg
#"""ROS2 package that is parent of this package."""
self.name: str = name
"""name of this package"""
self.executable_name: str = executable_name
"""
name of executable used by package. In a ros2 package, this is generally the name of the file executing code,
E.G:
in model_pkg:
`model_pkg -> src -> model_pkg -> model.py`
is package executable, so
`model` is executable_name
"""
self.config: Optional[Config] = config
"""config info about this package if relevant"""
#self.urdf_path: str = self.urdf_folder + self.urdf_name
self.output: Optional[str] = output
"""output for package, used in launch file"""
self.build: Optional[bool] = build
"""weather colcon builds this package. is set to no by default"""
self.entry_point: Optional[str] = entry_point
"""entry point for this package(assuming this package is executable), used for initializing setup.py"""
self.optional_launch_file_node_args: Optional[typing.Dict[str, str]] = optional_launch_file_node_args
"""optional arguements to be a part of the launch file node list. Set this for packages with custom node arguements like rviz2."""
def as_node_conf_dict(self):
"""launch files represent ros2 packages as dicitionaries. return this package as a dict for that"""
result = {
"package": "'%s'" % self.name,
"executable": "'%s'" % self.executable_name,
"output": "'%s'" % self.output,
"parameters": "[]"
}
if(self.optional_launch_file_node_args != None):
result.update(self.optional_launch_file_node_args)
return
def __repr__(self):
return str(self.__dict__)
"""optional arguements to be a part of the launch file node list. Set this for packages with custom node arguements like rviz2."""
def as_node_conf_dict(self):
"""launch files represent ros2 packages as dicitionaries. return this package as a dict for that"""
result = {
"package": "'%s'" % self.name,
"executable": "'%s'" % self.executable_name,
"output": "'%s'" % self.output,
"parameters": "[]"
}
if(self.optional_launch_file_node_args != None):
result.update(self.optional_launch_file_node_args)
return result
@property
def path(self):
"""returns path to this package... assuming this is a package that is built"""
if(self.build == True):
return PROJECT_PATH + local_directory_for["PACKAGES"] + self.name + "/"
else:
raise "this property is intended for built packages, mabye different behaviour can be added here for things like Rviz2, for example."
@property
def path_dict(self):
return {
"URDFS": self.path + local_directory_for["URDFS"],
"MODELS": self.path + local_directory_for["MODELS"],
"RVIZ": self.path + local_directory_for["RVIZ"],
}
"""paths to various config files (urdfs, models, etc..)"""
#print(yaml.dump(self.__dict__, default_flow_style=False))
#model_pkg = Package(None, "model_pkg", "model", build=True, urdf_name="diff_bot.urdf.xml") | /ros2_easy-0.4-py3-none-any.whl/ros2_easy/classes/Package.py | 0.696475 | 0.18188 | Package.py | pypi |
import importlib
import re
import numpy as np
import hypothesis.extra.numpy as npst
import hypothesis.strategies as st
import rclpy
from rclpy.node import Node
from ros2_fuzzer.ros_basic_strategies import array, string
class ROS2NodeFuzzer(Node):
"""
Class Helper to create ROS2 Nodes and execute common actions
Defined context manager to start and kill the node when finished with its execution
"""
def __init__(self):
self.pub = None
self.client = None
def __enter__(self):
rclpy.init()
super().__init__('ROS2_Fuzzer')
return self
def __exit__(self, exc_type, exc_val, exc_tb):
if self.pub:
self.pub.destroy()
if self.client:
self.client.destroy()
rclpy.shutdown()
def publish(self, msg_type, msg, topic):
if self.pub:
self.pub.publish(msg)
else:
self.pub = self.create_publisher(msg_type, topic)
self.publish(msg_type, msg, topic)
def send_request(self, srv_type, srv_name, srv_request):
if self.client:
while not self.client.wait_for_service(timeout_sec=1.0):
self.get_logger().info('service not available, waiting again...')
future = self.client.call_async(srv_request)
rclpy.spin_until_future_complete(self, future)
else:
self.client = self.create_client(srv_type, srv_name)
self.send_request(srv_type, srv_name, srv_request)
def ros_type_to_dict(msg_type):
"""
Create a dictionary which values say if the ROS2 message type is complex (not basic), which is its parent
ROS message module, its type, if it is an array and if so, its size.
:param msg_type: ROS2 message type.
:return: A dictionary which values say if the ROS2 message type is complex (not basic), which is its parent
ROS2 message module, its type, if it is an array and if so, its size.
"""
type_regexp = re.compile(
r'^((?P<sequence>[\w]+)\<|(?P<complex>(?P<module>[\w]+)/)?(?P<type>[\w]+)|(?P<array>\[(?P<array_size>[0-9]*)?\])?|\>)+$')
type_match = type_regexp.match(msg_type)
if type_match:
return type_match.groupdict()
else:
return None
# TODO possible duplicated functions ros_msg_loader and ros_srv_loader (srv loader called once,
# msg_loader called more than once)
def ros_msg_loader(type_dict):
"""
Dynamically import ROS2 message modules.
:param type_dict: A dictionary which values say if the ROS message type is complex (not basic), which is its parent
ROS2 message module, its type, if it is an array and if so, its size.
:return: The ROS2 message class. If the provided type does not exist, raises an import error.
"""
try:
module = importlib.import_module(type_dict['module'] + '.msg')
return module.__dict__[type_dict['type']]
except KeyError:
raise KeyError('ROS2 message type: {} not included in message module: {}'.format(type_dict['type'],
type_dict['module']))
except ImportError:
raise ImportError('ROS2 message module: {} does not exist.'.format(type_dict['module']))
except TypeError:
raise TypeError('ROS2 message type: {} does not exist'.format(type_dict['type']))
def ros_srv_loader(type_dict):
"""
Dynamically import ROS2 service modules.
:param type_dict: A dictionary which values say if the ROS service type is complex (not basic), which is its parent
ROS2 service module, its type, if it is an array and if so, its size.
:return: The ROS2 service class. If the provided type does not exist, raises an import error.
"""
try:
module = importlib.import_module(type_dict['module'] + '.srv')
return module.__dict__[type_dict['type']]
except KeyError:
raise KeyError('ROS2 service type: {} not included in service module: {}'.format(type_dict['type'],
type_dict['module']))
except ImportError:
raise ImportError('ROS2 service module: {} does not exist.'.format(type_dict['module']))
except TypeError:
raise TypeError('ROS2 service type: {} does not exist'.format(type_dict['type']))
def ros_interface_loader_str(ros2_type, interface_type):
"""
Wrapper for the :func:`ros_msg_loader` to treat string type command line arguments.
:param interface_type: A string representing the interface type (message, service,...)
:param ros2_type: A string type ROS2 interface type (e.g. "rosgraph_msgs/Log").
:return: The :func:`ros_srv_loader` or :func:`ros_msg_loader` function.
"""
type_dict = ros_type_to_dict(ros2_type)
if type_dict:
if interface_type == 'service':
return ros_srv_loader(type_dict)
else:
return ros_msg_loader(type_dict)
else:
raise ImportError('Unable to find defined ROS2 Interface type: {}'.format(ros2_type))
def map_ros_types(ros_class):
"""
A recursive function that maps ROS2 message fields to Hypothesis strategies.
:param ros_class: The ROS2 class to be fuzzed.
:return: A function that generates Hypothesis strategies for a given ROS message type.
"""
strategy_dict = {}
slot_dict = ros_class.get_fields_and_field_types()
for s_name, s_type in slot_dict.items():
type_dict = ros_type_to_dict(s_type)
if type_dict:
if not type_dict['complex']:
if type_dict['array'] or type_dict['sequence']:
parse_basic_arrays(s_name, type_dict, strategy_dict)
elif type_dict['type'] == 'string':
strategy_dict[s_name] = st.text()
elif type_dict['type'] == 'boolean':
strategy_dict[s_name] = st.booleans()
elif type_dict['type'] == 'octet':
strategy_dict[s_name] = st.binary(min_size=1, max_size=1)
else: # numpy compatible ROS built-in types
strategy_dict[s_name] = npst.from_dtype(np.dtype(type_dict['type']))
else:
parse_complex_types(s_name, type_dict, strategy_dict)
return dynamic_strategy_generator_ros(ros_class, strategy_dict)
def parse_basic_arrays(s_name, type_dict, strategy_dict):
"""
Generate Hypothesis strategies for array types.
:param s_name: Slot name to be parsed.
:param type_dict: A dictionary which values say if the ROS2 message type is complex (not basic), which is its parent
ROS2 message module, its type, if it is an array and if so, its size.
:param strategy_dict: A pointer to a dictionary to be filled with Hypothesis strategies.
"""
if type_dict['array_size']:
array_size = int(type_dict['array_size'])
else:
array_size = None
if type_dict['type'] == 'string':
strategy_dict[s_name] = array(elements=string(), min_size=array_size, max_size=array_size)
elif type_dict['type'] == 'boolean':
strategy_dict[s_name] = array(elements=npst.from_dtype(np.dtype('bool')), min_size=array_size,
max_size=array_size)
# TODO correct data type?
elif type_dict['type'] == 'octet':
strategy_dict[s_name] = array(elements=st.binary(min_size=1, max_size=1), min_size=array_size,
max_size=array_size)
else:
strategy_dict[s_name] = array(elements=npst.from_dtype(np.dtype(type_dict['type'])), min_size=array_size,
max_size=array_size)
def parse_complex_types(s_name, type_dict, strategy_dict):
"""
Generate Hypothesis strategies for complex ROS2 types.
:param s_name: Slot name to be parsed.
:param type_dict: A dictionary which values say if the ROS2 message type is complex (not basic), which is its parent
ROS2 message module, its type, if it is an array or sequence and if so, its size.
:param strategy_dict: A pointer to a dictionary to be filled with Hypothesis strategies.
"""
if not type_dict['array'] and not type_dict['sequence']:
strategy_dict[s_name] = map_ros_types(ros_msg_loader(type_dict))
else:
if type_dict['array_size']:
strategy_dict[s_name] = array(elements=map_ros_types(ros_msg_loader(type_dict)),
min_size=int(type_dict['array_size']),
max_size=int(type_dict['array_size']))
else:
strategy_dict[s_name] = array(elements=map_ros_types(ros_msg_loader(type_dict)))
# A better approach. It returns an instance of a ROS2 msg directly, so no need for mapping! :)
@st.composite
def dynamic_strategy_generator_ros(draw, type_name, strategy_dict): # This generates existing ROS msgs objects
aux_obj = type_name()
for key, value in strategy_dict.items():
value = draw(value)
# If it is array of numpy, get array python basic type
if isinstance(value, list) and value and hasattr(value[0], 'dtype'):
value = np.array(value)
value = value.tolist()
elif hasattr(value, 'dtype'):
value = value.item()
setattr(aux_obj, key, value)
return aux_obj | /ros2_fuzzer-1.0.0.tar.gz/ros2_fuzzer-1.0.0/ros2_fuzzer/ros_commons.py | 0.446736 | 0.201126 | ros_commons.py | pypi |
# ros2_graph
Generate mermaid description of ROS2 graphs to add on your markdown files.
## Motivation
In order to have better architecture documentation, graphs of nodes and topics are needed. Nonetheless, nobody wants to maintain these graphs and even do it from scratch. Because of that, a tool that does it automatedly is required. The first alternative is [rqt-graph](http://wiki.ros.org/rqt_graph) but it does not include services/actions information and adds some non-required information when we filter by a node. Normally the workflow includes connecting to a terminal where the ros system is running, launching the `rqt-graph`, saving the resulting image, and uploading it to the cloud to include it in the documentation.
To make our life easier and to generate graphs that include all the information that we want this tool was created
## Installation
You need to have already installed ROS2 (tested on humble distro).
```
pip install ros2-graph
```
To be able to export the diagram as an image install npm and [mermaid-cli](https://github.com/mermaid-js/mermaid-cli) on your computer
```
curl -sL https://deb.nodesource.com/setup_16.x | sudo -E bash -
sudo apt install nodejs
npm install -g @mermaid-js/mermaid-cli
```
## How it works
Suppose you want to generate a graph that shows how a node it's relates to other nodes by topics, services, and actions. All you need to do is run the script:
```
ros2_graph your_node
```
This will print in the console a graph description in the mermaid language, then you have to copy and paste it on the node's readme and enjoy. But if you want export it to a file use the `-o` flag.
Example
```
ros2_graph /turtlesim -o turtle_diagram.md
```
You can also export the diagram as an image (png, svg or pdf) by setting the right file extension or using the flag --outputFormat:
```
ros2_graph /turtlesim -o turtle_diagram.png
ros2_graph /turtlesim -o turtle_diagram --outputFormat png
```
**Note:** you must copy everything between *\`\`\`mermaid* and *\`\`\`* including both marks.
GitHub can display mermaid graphs. You can also display it on VS code by adding an extension in the devcontainer.json: "bierner.markdown-mermaid"
But what about nodes highly correlated as the range sensors, it does not make sense to have a graph for each node, Well don't worry you can include all the nodes that you want:
```
ros2_graph node_1 node_2 … node_n
```
Example:
```
ros2_graph /turtlesim /teleop_turtle
```
See an example graph:
```mermaid
flowchart LR
/turtlesim:::main
/teleop_turtle:::node
/turtle1cmd_vel([/turtle1cmd_vel<br>geometry_msgs/msg/Twist]):::topic
/turtle1color_sensor([/turtle1color_sensor<br>turtlesim/msg/Color]):::bugged
/turtle1pose([/turtle1pose<br>turtlesim/msg/Pose]):::bugged
/clear[//clear<br>std_srvs/srv/Empty\]:::bugged
/kill[//kill<br>turtlesim/srv/Kill\]:::bugged
/reset[//reset<br>std_srvs/srv/Empty\]:::bugged
/spawn[//spawn<br>turtlesim/srv/Spawn\]:::bugged
/turtle1set_pen[//turtle1set_pen<br>turtlesim/srv/SetPen\]:::bugged
/turtle1teleport_absolute[//turtle1teleport_absolute<br>turtlesim/srv/TeleportAbsolute\]:::bugged
/turtle1teleport_relative[//turtle1teleport_relative<br>turtlesim/srv/TeleportRelative\]:::bugged
/turtle1/rotate_absolute{{/turtle1/rotate_absolute<br>turtlesim/action/RotateAbsolute}}:::action
/clear o-.-o /turtlesim
/kill o-.-o /turtlesim
/reset o-.-o /turtlesim
/spawn o-.-o /turtlesim
/turtle1set_pen o-.-o /turtlesim
/turtle1teleport_absolute o-.-o /turtlesim
/turtle1teleport_relative o-.-o /turtlesim
/teleop_turtle <==> /turtle1/rotate_absolute
/turtle1/rotate_absolute o==o /turtlesim
/turtle1cmd_vel --> /turtlesim
/turtlesim --> /turtle1color_sensor
/turtlesim --> /turtle1pose
/teleop_turtle --> /turtle1cmd_vel
subgraph keys[<b>Keys<b/>]
subgraph nodes[<b><b/>]
topicb((No connected)):::bugged
main_node:::main
end
subgraph connection[<b><b/>]
node1:::node
node2:::node
node1 o-. to server .-o service[/Service<br>service/Type\]:::service
service <-. to client .-> node2
node1 -- publish --> topic([Topic<br>topic/Type]):::topic
topic -- subscribe --> node2
node1 o== to server ==o action{{/Action<br>action/Type/}}:::action
action <== to client ==> node2
end
end
classDef node opacity:0.9,fill:#2A0,stroke:#391,stroke-width:4px,color:#fff
classDef action opacity:0.9,fill:#66A,stroke:#225,stroke-width:2px,color:#fff
classDef service opacity:0.9,fill:#3B8062,stroke:#3B6062,stroke-width:2px,color:#fff
classDef topic opacity:0.9,fill:#852,stroke:#CCC,stroke-width:2px,color:#fff
classDef main opacity:0.9,fill:#059,stroke:#09F,stroke-width:4px,color:#fff
classDef bugged opacity:0.9,fill:#933,stroke:#800,stroke-width:2px,color:#fff
style keys opacity:0.15,fill:#FFF
style nodes opacity:0.15,fill:#FFF
style connection opacity:0.15,fill:#FFF
```
```
flowchart LR
/turtlesim:::main
/teleop_turtle:::node
/turtle1cmd_vel([/turtle1cmd_vel<br>geometry_msgs/msg/Twist]):::topic
/turtle1color_sensor([/turtle1color_sensor<br>turtlesim/msg/Color]):::bugged
/turtle1pose([/turtle1pose<br>turtlesim/msg/Pose]):::bugged
/clear[//clear<br>std_srvs/srv/Empty\]:::bugged
/kill[//kill<br>turtlesim/srv/Kill\]:::bugged
/reset[//reset<br>std_srvs/srv/Empty\]:::bugged
/spawn[//spawn<br>turtlesim/srv/Spawn\]:::bugged
/turtle1set_pen[//turtle1set_pen<br>turtlesim/srv/SetPen\]:::bugged
/turtle1teleport_absolute[//turtle1teleport_absolute<br>turtlesim/srv/TeleportAbsolute\]:::bugged
/turtle1teleport_relative[//turtle1teleport_relative<br>turtlesim/srv/TeleportRelative\]:::bugged
/turtle1/rotate_absolute{{/turtle1/rotate_absolute<br>turtlesim/action/RotateAbsolute}}:::action
/clear o-.-o /turtlesim
/kill o-.-o /turtlesim
/reset o-.-o /turtlesim
/spawn o-.-o /turtlesim
/turtle1set_pen o-.-o /turtlesim
/turtle1teleport_absolute o-.-o /turtlesim
/turtle1teleport_relative o-.-o /turtlesim
/teleop_turtle <==> /turtle1/rotate_absolute
/turtle1/rotate_absolute o==o /turtlesim
/turtle1cmd_vel --> /turtlesim
/turtlesim --> /turtle1color_sensor
/turtlesim --> /turtle1pose
/teleop_turtle --> /turtle1cmd_vel
subgraph keys[<b>Keys<b/>]
subgraph nodes[<b><b/>]
topicb((No connected)):::bugged
main_node:::main_node
end
subgraph connection[<b><b/>]
node1:::node
node2:::node
node1 o-. to server .-o service[/Service<br>service/Type\]:::service
service <-. to client .-> node2
node1 -- publish --> topic([Topic<br>topic/Type]):::topic
topic -- subscribe --> node2
node1 o== to server ==o action{{/Action<br>action/Type/}}:::action
action <== to client ==> node2
end
end
classDef node opacity:0.9,fill:#2A0,stroke:#391,stroke-width:4px,color:#fff
classDef action opacity:0.9,fill:#66A,stroke:#225,stroke-width:2px,color:#fff
classDef service opacity:0.9,fill:#3B8062,stroke:#3B6062,stroke-width:2px,color:#fff
classDef topic opacity:0.9,fill:#852,stroke:#CCC,stroke-width:2px,color:#fff
classDef main opacity:0.9,fill:#059,stroke:#09F,stroke-width:4px,color:#fff
classDef bugged opacity:0.9,fill:#933,stroke:#800,stroke-width:2px,color:#fff
style keys opacity:0.15,fill:#FFF
style nodes opacity:0.15,fill:#FFF
style connection opacity:0.15,fill:#FFF
```
## Custom syle
For custom mermaid styles use the `--styleConfig` flag to load a style .yaml file, it must look like this (Example with the default values, if a field is not defined the default will be used):
```yaml
shapes:
main: ["[", "]"]
node: ["[", "]"]
topic: ["([", "])"]
service: ["[/", "\\]"]
action: ["{{", "}}"]
colors:
main: "opacity:0.9,fill:#059,stroke:#09F,stroke-width:4px,color:#fff"
node: "opacity:0.9,fill:#2A0,stroke:#391,stroke-width:4px,color:#fff"
topic: "opacity:0.9,fill:#852,stroke:#CCC,stroke-width:2px,color:#fff"
service: "opacity:0.9,fill:#3B8062,stroke:#3B6062,stroke-width:2px,color:#fff"
action: "opacity:0.9,fill:#66A,stroke:#225,stroke-width:2px,color:#fff"
no_conected: "opacity:0.9,fill:#933,stroke:#800,stroke-width:2px,color:#fff"
links_display:
topics_publisher: "-->"
topics_subscriber: "-->"
services_server: "o-.-o"
services_client: "<-.->"
action_server: "o==o"
action_client: "<==>"
links_style:
topics_publisher:
topics_subscriber:
services_server:
services_client:
action_server: fill:none,stroke:green;
action_client: fill:none,stroke:green;
display_keys: True
ignore:
nodes:
- "/Graph_generator"
topics:
services:
actions:
```
Use the `ignore` field to don not include some node, topic, service or action in your graph, [regular expressions](https://docs.python.org/3/library/re.html) are supported. | /ros2_graph-0.0.4.tar.gz/ros2_graph-0.0.4/README.md | 0.432423 | 0.840913 | README.md | pypi |
import subprocess
from typing import List, Tuple
import os
def remove_file(file: str) -> None:
"""!
Just remove a file if ist exist
"""
if os.path.exists(file):
os.remove(file)
def save_ros_node_info(node_name: str, file: str) -> None:
"""!
Save ros node informatin in a text file
"""
remove_file(file)
subprocess.check_output(f"ros2 node info {node_name} >> {file}", shell=True)
def between_patterns(pattern: Tuple[str], file: str) -> str:
"""!
Return sed instruction to get text between two patters
@param pattern (tuple) size two tuple with both patterns
@param file (str) File to filter
@return str bash instruction to filter a text file
"""
instruction = ("sed -n '/%s/, /%s/{ /%s/! { /%s/! p } }' %s") % (
pattern[0],
pattern[1],
pattern[0],
pattern[1],
file,
)
return instruction
def after_pattern(pattern: str, file: str) -> str:
"""!
Return sed instruction to get text after a pattern
@param pattern (str) pattern to filter
@param file (str) File to filter
@return str bash instruction to filter a text file
"""
instruction = f"sed -n '/{pattern}/,$p' {file} | sed '1d'"
return instruction
def get_clean_lines(query_instruction: str) -> List[str]:
"""! Perform a shell instruction and return the answer as a list of string
@param query_instruction (str) ros2 cli query plus sed or grep filter instruction
@return list lines
"""
line_list = (
subprocess.check_output(query_instruction, shell=True)
.decode("utf-8")
.splitlines()
)
return list(filter(lambda x: x != "", line_list))
def split_full_name(full_name: str) -> Tuple[str, str]:
"""!
split a ros name into name and namespace
"""
namespace, name = full_name.rsplit("/", 1)
if len(namespace) < 1:
namespace = "/"
return name, namespace
def get_name_namespace_type(line: str) -> Tuple[str]:
"""! split name, namespace and type from a line of a ros cli response
@param line: a line of the ros2 cli response. Format: namespace/name:type
"""
full_name, type = line.split(":")
name, namespace = split_full_name(full_name)
name = "/" + name
return name, namespace, type
def get_node_info_block(pattern: tuple, file: str) -> Tuple[Tuple[str]]:
"""! Get the name and the type of the ros elements in an ros2 node info block
@param pattern: tuple of strings, marks that indicate the start and the end of that block
@param file_name: File where is stored the ros node info response
@return tuples (element_name, element_namespace, ros_type)
"""
filter_rule = (
between_patterns(pattern, file)
if len(pattern) > 1
else after_pattern(pattern[0], file)
)
filter_rule += " | tr -d '[:blank:]'"
elements = tuple(map(get_name_namespace_type, get_clean_lines(filter_rule)))
return elements
def get_action_related_nodes(action_name: str, clients: bool) -> Tuple[Tuple[str]]:
"""!
Get clients or servers nodes for the specified action
@param actions tuples of tuples(name, name_space, type)
@param clients get client or server nodes
@return tuple of tuples (name, namespace)
"""
pattern = ("Action clients:", "Action servers:")
aux_file = "actions.txt"
filter_command = (
between_patterns(pattern, aux_file)
if clients
else after_pattern(pattern[1], aux_file)
) + " | tr -d '[:blank:]'"
raw_nodes_names = get_clean_lines(
f"ros2 action info {action_name} >> {aux_file} && {filter_command} && rm {aux_file}"
)
nodes_names = map(split_full_name, raw_nodes_names)
return nodes_names | /ros2_graph-0.0.4.tar.gz/ros2_graph-0.0.4/ros2_graph/ros_cli_utils.py | 0.776114 | 0.365938 | ros_cli_utils.py | pypi |
import argparse
import subprocess
from os.path import splitext
from os import remove
import yaml
from collections import defaultdict
from .graph_generator import GraphGenerator
from .ros_element import ElementType, LinkType
def get_style(style_file: str = None):
"""!
Load custom style configs, or use the default
@param style_file: style .yaml file
"""
style_dict = {}
if style_file:
with open(style_file, encoding="UTF-8") as f:
yaml_data = f.read()
style_dict = yaml.load(yaml_data, Loader=yaml.Loader)
shapes = style_dict.get("shapes", {})
colors = style_dict.get("colors", {})
links_display = style_dict.get("links_display", {})
links_style = style_dict.get("links_style", {})
display_keys = style_dict.get("display_keys", True)
to_ignore = style_dict.get("ignore", defaultdict(lambda: []))
shapes_dict = {
ElementType.MAIN: shapes.get("main", ["[", "]"]),
ElementType.NODE: shapes.get("node", ["[", "]"]),
ElementType.TOPIC: shapes.get("topic", ["([", "])"]),
ElementType.SERVICE: shapes.get("service", ["[/", "\\]"]),
ElementType.ACTION: shapes.get("action", ["{{", "}}"]),
}
colors_dict = {
ElementType.MAIN: colors.get(
"main", "opacity:0.9,fill:#059,stroke:#09F,stroke-width:4px,color:#fff"
),
ElementType.NODE: colors.get(
"node", "opacity:0.9,fill:#2A0,stroke:#391,stroke-width:4px,color:#fff"
),
ElementType.TOPIC: colors.get(
"topic", "opacity:0.9,fill:#852,stroke:#CCC,stroke-width:2px,color:#fff"
),
ElementType.SERVICE: colors.get(
"service",
"opacity:0.9,fill:#3B8062,stroke:#3B6062,stroke-width:2px,color:#fff",
),
ElementType.ACTION: colors.get(
"action", "opacity:0.9,fill:#66A,stroke:#225,stroke-width:2px,color:#fff"
),
}
no_conected = colors.get(
"no_conected", "opacity:0.9,fill:#933,stroke:#800,stroke-width:2px,color:#fff"
)
link_strs = {
LinkType.TOPIC_PUBLISHER: links_display.get("topics_publisher", "-->"),
LinkType.TOPIC_SUBSCRIBER: links_display.get("topics_subscriber", "-->"),
LinkType.SERVICE_SERVER: links_display.get("services_server", "o-.-o"),
LinkType.SERVICE_CLIENT: links_display.get("services_client", "<-.->"),
LinkType.ACTION_SERVER: links_display.get("action_server", "o==o"),
LinkType.ACTION_CLIENT: links_display.get("action_client", "<==>"),
}
link_style = {
LinkType.TOPIC_PUBLISHER: links_style.get("topics_publisher", None),
LinkType.TOPIC_SUBSCRIBER: links_style.get("topics_subscriber", None),
LinkType.SERVICE_SERVER: links_style.get("services_server", None),
LinkType.SERVICE_CLIENT: links_style.get("services_client", None),
LinkType.ACTION_SERVER: links_style.get(
"action_server", "fill:none,stroke:green;"
),
LinkType.ACTION_CLIENT: links_style.get(
"action_client", "fill:none,stroke:green;"
),
}
to_ignore["nodes"] = to_ignore.get("nodes", ["/Graph_generator"])
to_ignore["services"] = to_ignore.get("services", []) + [
".*/change_state",
".*/describe_parameters",
".*/get_available_states",
".*/get_available_transitions",
".*/get_parameter_types",
".*/get_parameters",
".*/get_state",
".*/get_transition_graph",
".*/list_parameters",
".*/set_parameters",
".*/set_parameters_atomically",
".*/_action",
]
to_ignore["topics"] = to_ignore.get("topics",[]) + [
"/parameter_events",
"/rosout",
"/tf",
"/cascade_lifecycle_activations",
"/cascade_lifecycle_states",
".*/transition_event",
".*/_action",
]
style_settings = {
"shapes": shapes_dict,
"colors": colors_dict,
"no_conected": no_conected,
"links_str": link_strs,
"links_style": link_style,
"display_keys": display_keys,
"to_ignore": to_ignore,
}
return style_settings
def main():
parser = argparse.ArgumentParser(
description="Create mermaid graphs from your ros2 nodes"
)
parser.add_argument(
"nodes", metavar="/node", type=str, nargs="+", help="main nodes of your graph"
)
parser.add_argument(
"-o",
"--out_file",
dest="out_file",
help="set output file otherwise the graph will be printed on the console",
default="None",
type=str,
)
parser.add_argument(
"--outputFormat",
dest="out_type",
help="set an output format",
choices=("console", "md", "svg", "png", "pdf"),
default="console",
type=str,
)
parser.add_argument(
"--styleConfig",
dest="style_config",
help="Pass a yaml file for style configuration",
default=None,
type=str,
)
args = parser.parse_args()
nodes = args.nodes
out_file, aux_out_type = splitext(args.out_file)
out_type = "console"
style_config = get_style(args.style_config)
# use file extension as default type
if aux_out_type != "":
out_type = aux_out_type
if args.out_type != "console":
out_type = "." + args.out_type
# use .md as output type if is not declared but there is an output file
if out_file != "None" and out_type == "console":
out_type = ".md"
if out_type != "console" and out_file == "None":
raise Exception("Output file is missing")
graph_generator = GraphGenerator(style_config)
for node in nodes:
graph_generator.get_node_graph(node)
mermaid_graph, links_ranges = graph_generator.get_mermaid()
links_str = style_config["links_str"]
shapes = style_config["shapes"]
mermaid_convention = (
"\n".join(
[
"subgraph keys[<b>Keys<b/>]",
"subgraph nodes[<b><b/>]",
"topicb((No connected)):::bugged",
f"main_node{shapes[ElementType.MAIN][0]}main{shapes[ElementType.MAIN][1]}:::main",
"end",
"subgraph connection[<b><b/>]",
f"node1{shapes[ElementType.NODE][0]}node1{shapes[ElementType.NODE][1]}:::node",
f"node2{shapes[ElementType.NODE][0]}node2{shapes[ElementType.NODE][1]}:::node",
f"node1 {links_str[LinkType.SERVICE_SERVER]}|to server| service{shapes[ElementType.SERVICE][0]}Service<br>service/Type{shapes[ElementType.SERVICE][1]}:::service",
f"service {links_str[LinkType.SERVICE_CLIENT]}|to client| node2",
f"node1 {links_str[LinkType.TOPIC_PUBLISHER]}|publish| topic{shapes[ElementType.TOPIC][0]}Topic<br>topic/Type{shapes[ElementType.TOPIC][1]}:::topic",
f"topic {links_str[LinkType.TOPIC_SUBSCRIBER]}|subscribe| node2",
f"node1 {links_str[LinkType.ACTION_SERVER]}|to server| action{shapes[ElementType.ACTION][0]}/Action<br>action/Type/{shapes[ElementType.ACTION][1]}:::action",
f"action {links_str[LinkType.ACTION_CLIENT]}|to client| node2",
"end",
"end",
]
)
if style_config["display_keys"]
else ""
)
links_numbers = {
link_type: list(range(*ranges))
for link_type, ranges in links_ranges.items()
if ranges[1] - ranges[0] > 0
}
# Add keys box links
if style_config["display_keys"]:
last_link = links_ranges[LinkType.ACTION_CLIENT][1]
key_box_order = [
LinkType.SERVICE_SERVER,
LinkType.SERVICE_CLIENT,
LinkType.TOPIC_PUBLISHER,
LinkType.TOPIC_SUBSCRIBER,
LinkType.ACTION_SERVER,
LinkType.ACTION_CLIENT,
]
# Add style for the key box links
for i, link_type in enumerate(key_box_order):
if link_type in links_numbers:
links_numbers[link_type].append(last_link + i)
links_styles = "\n".join(
[
"linkStyle "
+ ",".join(map(str, numbers))
+ " "
+ style_config["links_style"][link_type]
for link_type, numbers in links_numbers.items()
if style_config["links_style"][link_type] is not None
and style_config["links_style"][link_type] != "None"
]
)
colors = style_config["colors"]
mermaid_style = [
"classDef node " + colors[ElementType.NODE],
"classDef action " + colors[ElementType.ACTION],
"classDef service " + colors[ElementType.SERVICE],
"classDef topic " + colors[ElementType.TOPIC],
"classDef main " + colors[ElementType.MAIN],
"classDef bugged " + style_config["no_conected"],
]
if style_config["display_keys"]:
mermaid_style += [
"style keys opacity:0.15,fill:#FFF",
"style nodes opacity:0.15,fill:#FFF",
"style connection opacity:0.15,fill:#FFF",
]
mermaid_style = "\n".join(mermaid_style)
heading = "```mermaid\nflowchart LR\n"
mermaid_graph = "\n".join(
[
heading,
mermaid_graph,
mermaid_convention,
mermaid_style,
links_styles,
"```\n",
]
)
# print on console
if out_file == "None":
print(mermaid_graph)
return
with open(out_file + ".md", "a", encoding="UTF-8") as file:
file.write(mermaid_graph)
# Save .md file
if out_type == ".md":
return
# Export image
try:
command = (
"npx -p @mermaid-js/mermaid-cli mmdc -i "
+ out_file
+ ".md -o "
+ out_file
+ out_type
+ " -b transparent"
)
subprocess.run(command, shell=True)
except:
print(
"An error using mermaid-cli look for more details in https://github.com/mermaid-js/mermaid-cli"
)
finally:
remove(out_file + ".md")
if __name__ == "__main__":
main() | /ros2_graph-0.0.4.tar.gz/ros2_graph-0.0.4/ros2_graph/__main__.py | 0.426799 | 0.1933 | __main__.py | pypi |
from dataclasses import dataclass
from enum import Enum
from typing import List, Dict
class ElementType(Enum):
"""!
Enumeration class for ROS element types
"""
MAIN = 0
NODE = 1
TOPIC = 2
SERVICE = 3
ACTION = 4
def __str__(self):
"""!
Just map element types and and it's string
"""
return self.name.lower()
class LinkType(Enum):
"""!
Enumeration class for ROS relationships types
"""
TOPIC_PUBLISHER = 0
TOPIC_SUBSCRIBER = 1
SERVICE_SERVER = 2
SERVICE_CLIENT = 3
ACTION_SERVER = 4
ACTION_CLIENT = 5
@classmethod
def inverse_link(cls, link_type: int) -> int:
"""!
Map "from" links to "to" links and vice versa
"""
if link_type == LinkType.TOPIC_SUBSCRIBER:
return LinkType.TOPIC_PUBLISHER
if link_type == LinkType.TOPIC_PUBLISHER:
return LinkType.TOPIC_SUBSCRIBER
if link_type == LinkType.SERVICE_SERVER:
return LinkType.SERVICE_CLIENT
if link_type == LinkType.SERVICE_CLIENT:
return LinkType.SERVICE_SERVER
if link_type == LinkType.ACTION_SERVER:
return LinkType.ACTION_CLIENT
if link_type == LinkType.ACTION_CLIENT:
return LinkType.ACTION_SERVER
raise ValueError("Non valid link type code")
@dataclass
class RosElement:
"""!
RosElement Class store basic information of ROS elements:
Nodes, topics, services and actions
"""
name: str
namespace: str
type: ElementType
def full_name(self) -> str:
"""! Put togheter name and name space on a sigle string
@return str namespace/name
"""
if self.namespace is None:
return self.name
return self.namespace + self.name
def list_ros_element_2_list_str(elements: List[RosElement]) -> List[str]:
"""!
convert a RosElement list to its string list representation
"""
return list(map(str, elements))
@dataclass
class NoNodeElement(RosElement):
"""!
NoNodeElement Class store aditional information of ROS elements
that are not nodes.
Atributes:
ros_type: ros topic, service or action type
from_connected: bool, has at least one publisher or server
to_connected: bool, has at least one subscriber or client
brackets: for mermaid diplay, default ("([", "])")
"""
ros_type: str
from_connected: bool = False
to_connected: bool = False
brackets: List[str] = ("([", "])")
def __str__(self) -> str:
name = self.full_name()
style = (
str(self.type) if self.from_connected and self.to_connected else "bugged"
)
return f"{name}{self.brackets[0]} {name}<br>{self.ros_type} {self.brackets[1]}:::{style}"
def __eq__(self, another) -> bool:
return self.name == another.name and self.namespace == another.namespace
def __hash__(self) -> int:
return hash(self.name) ^ hash(self.namespace)
@dataclass
class Link:
"""!
contains the relashionship information from a ROS node
to some other ROS element
Atributes:
linked_element: NoNodeElement object
link_str: for mermaid display
"""
linked_element: NoNodeElement
link_str: str
def __str__(self) -> str:
return self.linked_element.full_name()
def __eq__(self, another) -> bool:
return (
self.linked_element == another.linked_element
and self.link_str == another.link_str
)
def __hash__(self) -> int:
return hash(self.linked_element) ^ hash(self.link_str)
@dataclass
class NodeElement(RosElement):
"""!
NoNodeElement Class store aditional information of ROS nodes.
Atributes:
brackets: for mermaid diplay
"""
brackets: List[str]
def __post_init__(self):
self.links: List[Dict[int, Link]] = [dict() for i in range(len(LinkType))]
def add_link(
self, linked_element: NoNodeElement, link_str: str, link_type: LinkType
):
"""!
Add a relashion ship with a no node element,
but only if it doesn't already exist
@param linked_element: a topic, sevice or action
@param link_str: for mermaid display
@param link_type: which kind of relashionship is
"""
link = Link(linked_element=linked_element, link_str=link_str)
link_hash = hash(link)
index = link_type.value
if link_hash not in self.links[index]:
self.links[index][link_hash] = link
if index % 2:
linked_element.from_connected = True
else:
linked_element.to_connected = True
def get_links_str(self, which: LinkType) -> List[str]:
"""!
Get al links string representation from a desired type
@param which: specify the link type
"""
name = self.full_name()
index = which.value
linksStr = [
name + " " + link.link_str + " " + str(link)
if index % 2
else str(link) + " " + link.link_str + " " + name
for link in self.links[index].values()
]
return linksStr
def __str__(self):
name = self.full_name()
return f"{name}{self.brackets[0]} {name} {self.brackets[1]}:::{self.type}"
def __eq__(self, another) -> bool:
return self.name == another.name and self.namespace == another.namespace
def __hash__(self) -> int:
return hash(self.name) ^ hash(self.namespace) | /ros2_graph-0.0.4.tar.gz/ros2_graph-0.0.4/ros2_graph/ros_element.py | 0.890002 | 0.310446 | ros_element.py | pypi |
from functools import partial
from typing import Dict, List, Tuple
import re
import rclpy
from rclpy.node import Node
from .ros_element import (
ElementType,
LinkType,
NoNodeElement,
NodeElement,
list_ros_element_2_list_str,
)
from . import ros_cli_utils as rcu
from functools import reduce
ElementNameTypes = Tuple[str, List[str]]
RelatedNodes = Dict[str, List[str]]
ElementRelatedNodes = Dict[str, RelatedNodes]
class GraphGenerator:
def __init__(self, style_config: Dict[str, any]):
"""!
style_config: style .yaml values as dictionary
"""
rclpy.init()
self.dummy = Node("Graph_generator")
self.ros_node_info_file = "node_info.txt"
self.mainNodes: Dict[int, NodeElement] = dict()
self.nodes: Dict[int, NodeElement] = dict()
self.topics: Dict[int, NoNodeElement] = dict()
self.services: Dict[int, NoNodeElement] = dict()
self.actions: Dict[int, NoNodeElement] = dict()
self.link_strs = style_config["links_str"]
self.brackets = style_config["shapes"]
self.to_ignore = style_config["to_ignore"]
def new_no_node(
self, new_element: NoNodeElement, elemt_dict: Dict[int, NoNodeElement]
) -> NoNodeElement:
"""!
Add new_element to the elemt_dict if it not already exist
"""
new_hash = hash(new_element)
if new_hash not in elemt_dict:
elemt_dict[new_hash] = new_element
return elemt_dict[new_hash]
def new_action(self, name: str, namespace: str, ros_type: str) -> NoNodeElement:
"""! Initialize a NoNodeElement action object form a string tuple (name, namespace, ros_type) or return the already existing action
@param action data tuples (name, namespace, ros_type)
@return NoNodeElement action object
"""
new_action = NoNodeElement(
name=name,
namespace=namespace,
ros_type=ros_type,
type=ElementType.ACTION,
brackets=self.brackets[ElementType.ACTION],
)
if new_action.full_name() in self.to_ignore["actions"]:
return None
return self.new_no_node(new_action, self.actions)
def actions_tuple(self, actions_data: Tuple[Tuple[str]]) -> Tuple[NoNodeElement]:
"""!
create a group of actions objects from a tuple of data
@param actions_data actions info in (name, namespace, ros_type) format
@return a tuple of NoNodeElement action objects
"""
actions = (self.new_action(*data) for data in actions_data)
return tuple(action for action in actions if action is not None)
def new_topic(self, name: str, namespace: str, ros_type: str) -> NoNodeElement:
"""! Initialize a NoNodeElement topic object form a string tuple (name, namespace, ros_type) or return the already existing action
@param topic data tuples (name, namespace, ros_type)
@return NoNodeElement topic object
"""
new_topic = NoNodeElement(
name,
namespace,
ros_type=ros_type,
type=ElementType.TOPIC,
brackets=self.brackets[ElementType.TOPIC],
)
return self.new_no_node(new_topic, self.topics)
def new_service(self, name: str, namespace: str, ros_type: str) -> NoNodeElement:
"""! Initialize a NoNodeElement service object form a string tuple (name, namespace, ros_type) or return the already existing action
@param service data tuples (name, namespace, ros_type)
@return NoNodeElement service object
"""
new_service = NoNodeElement(
name,
namespace,
ros_type=ros_type,
type=ElementType.SERVICE,
brackets=self.brackets[ElementType.SERVICE],
)
return self.new_no_node(new_service, self.services)
def get_actions(self, node: str) -> Dict[str, Tuple[NoNodeElement]]:
"""! Get Action related to some node
@param node, the node to inspect its actions
"""
patterns = {
"action_servers": ("Action Servers:", "Action Clients:"),
"action_client": ("Action Clients:",),
}
rcu.save_ros_node_info(node_name=node, file=self.ros_node_info_file)
elements = {
k: self.actions_tuple(
rcu.get_node_info_block(pattern, file=self.ros_node_info_file)
)
for k, pattern in patterns.items()
}
rcu.remove_file(self.ros_node_info_file)
return elements
def new_node(self, name: str, namespace: str) -> NodeElement:
"""! Create a new node if is not already created given its data
and return it
@param data a tuple (name, namespace)
@return the NodeElement object
"""
new_node = NodeElement(
name,
namespace,
type=ElementType.NODE,
brackets=self.brackets[ElementType.NODE],
)
if new_node.full_name() in self.to_ignore["nodes"]:
return None
node_hash = hash(new_node)
if node_hash in self.mainNodes:
return self.mainNodes[node_hash]
if node_hash not in self.nodes:
self.nodes[node_hash] = new_node
return self.nodes[node_hash]
def nodes_from_data(self, nodes_data: Tuple[Tuple[str]]) -> Tuple[NodeElement]:
"""!
create a group of nodes objects from a tuple of data
@param nodes_data: nodes info in (name, namespace) format
@return a tuple of NodeElement objects
"""
nodes = (self.new_node(*node) for node in nodes_data)
return tuple((node for node in nodes if node is not None))
def not_match(self, r, topic_info : Tuple[str, List[str]]):
"""
Return True if the string do not match with the regular expresion
@param r: compiled regex expresion
@param topic_info: tuple (name, type)
"""
return not r.match(topic_info[0])
def get_topics_related_nodes(
self, topics: List[ElementNameTypes], subscribers: bool
) -> Dict[NoNodeElement, List[NodeElement]]:
"""!
Get publishers or subcribers nodes for the specified topics
@param topics (list[tuple(name, types list)]) List of topics with names and type
@param publishers (bool) get publishers or subscribers nodes
@return dict {topic_name: {type: str, nodes: [nodes_names]}}
"""
get_endpoints_function = (
self.dummy.get_publishers_info_by_topic
if subscribers
else self.dummy.get_subscriptions_info_by_topic
)
topics_and_nodes = {}
blacklist = "|".join(self.to_ignore["topics"])
r = re.compile(blacklist)
not_match_partial = partial(self.not_match, r)
for topic in filter(not_match_partial, topics):
name, namespace = rcu.split_full_name(topic[0])
ros_type = "<br>".join(topic[1])
topicObj = self.new_topic(name, namespace, ros_type)
endpoints = get_endpoints_function(topic[0])
new_nodes = (
self.new_node(endpoint.node_name, endpoint.node_namespace)
for endpoint in endpoints
)
nodes = [node for node in new_nodes if node is not None]
topics_and_nodes[topicObj] = nodes
return topics_and_nodes
def get_services_related_nodes(
self, services: List[ElementNameTypes], clients: bool
) -> Dict[NoNodeElement, List[NodeElement]]:
"""! Get servers or clients nodes for the specified services
@param services list of tuple(name: str, types: list)
@param clients, True for get clients names, false for server names
@return dictonary with services and related nodes
"""
get_services_function = (
self.dummy.get_client_names_and_types_by_node
if clients
else self.dummy.get_service_names_and_types_by_node
)
blacklist = "|".join(self.to_ignore["services"])
r = re.compile(blacklist)
not_match_partial = partial(self.not_match, r)
services_and_nodes = {
service[0]: {"type": "<br>".join(service[1]), "nodes": []}
for service in filter(not_match_partial, services)
}
services_names = services_and_nodes.keys()
nodes_list = self.dummy.get_node_names_and_namespaces()
for node in nodes_list:
services = tuple(map(lambda x: x[0], get_services_function(*node)))
filtered_services = tuple(
filter((lambda service: service in services_names), services)
)
for service in filtered_services:
new_node = self.new_node(*node)
if new_node is not None:
services_and_nodes[service]["nodes"].append(new_node)
services_and_nodes_obj = {}
for service, sub_dict in services_and_nodes.items():
name, namespace = rcu.split_full_name(service)
ros_type = sub_dict["type"]
service_obj = self.new_service(name, namespace, ros_type)
services_and_nodes_obj[service_obj] = sub_dict["nodes"]
return services_and_nodes_obj
def create_links(
self,
main_node: NodeElement,
relations: Dict[NoNodeElement, List[NodeElement]],
link_type: LinkType,
) -> None:
"""! Add links to the nodes from a relations dictionary
@param relations, dictonary with the relationships
@link_type: subscription, publisher, service server ...
"""
inv_link_type = LinkType.inverse_link(link_type)
link_str1 = self.link_strs[inv_link_type]
link_str2 = self.link_strs[link_type]
for linked_element, nodes in relations.items():
main_node.add_link(linked_element, link_str1, inv_link_type)
for node in nodes:
node.add_link(linked_element, link_str2, link_type)
def get_node_graph(self, node: str):
"""!
get relashionship links from some ros2 node
"""
name, namespace = rcu.split_full_name(node)
newMain = NodeElement(
name,
namespace,
type=ElementType.MAIN,
brackets=self.brackets[ElementType.MAIN],
)
main_hash = hash(newMain)
if main_hash in self.mainNodes:
return
self.mainNodes[main_hash] = newMain
elements = self.get_actions(node)
action_clients_data = {
action: rcu.get_action_related_nodes(action.full_name(), clients=True)
for action in elements["action_servers"]
}
action_clients = {
k: self.nodes_from_data(v) for k, v in action_clients_data.items()
}
action_servers_data = {
action: rcu.get_action_related_nodes(action.full_name(), clients=False)
for action in elements["action_client"]
}
action_servers = {
k: self.nodes_from_data(v) for k, v in action_servers_data.items()
}
subscribers = self.dummy.get_subscriber_names_and_types_by_node(name, namespace)
publishers = self.dummy.get_publisher_names_and_types_by_node(name, namespace)
services_server = self.dummy.get_service_names_and_types_by_node(
name, namespace
)
services_client = self.dummy.get_client_names_and_types_by_node(name, namespace)
topics_subscribers = self.get_topics_related_nodes(
subscribers, subscribers=True
)
topics_publishers = self.get_topics_related_nodes(publishers, subscribers=False)
service_clients = self.get_services_related_nodes(services_server, clients=True)
service_servers = self.get_services_related_nodes(
services_client, clients=False
)
self.create_links(
main_node=newMain,
relations=topics_subscribers,
link_type=LinkType.TOPIC_SUBSCRIBER,
)
self.create_links(
main_node=newMain,
relations=topics_publishers,
link_type=LinkType.TOPIC_PUBLISHER,
)
self.create_links(
main_node=newMain,
relations=service_clients,
link_type=LinkType.SERVICE_CLIENT,
)
self.create_links(
main_node=newMain,
relations=service_servers,
link_type=LinkType.SERVICE_SERVER,
)
self.create_links(
main_node=newMain,
relations=action_clients,
link_type=LinkType.ACTION_CLIENT,
)
self.create_links(
main_node=newMain,
relations=action_servers,
link_type=LinkType.ACTION_SERVER,
)
def get_nodes_mermaid(
self, nodes: Dict[int, NodeElement]
) -> Tuple[str, Dict[LinkType, List[str]]]:
"""!
get mermaid graph description from a node and
its relationships whit other elements
"""
nodes_list = [str(val) for val in nodes.values()]
nodes_mermaid = "\n".join(nodes_list)
links_mermaid = {
name: reduce(
lambda mermaid_lines, node: mermaid_lines + node.get_links_str(name),
nodes.values(),
list(),
)
for name in LinkType
}
return nodes_mermaid, links_mermaid
def get_mermaid(self) -> Tuple[str, Tuple[Tuple[int, int]]]:
"""!
get mermaid graph description from all requested nodes
and concatenate it
"""
main_style, str_main_links = self.get_nodes_mermaid(self.mainNodes)
nodes_style, str_nodes_links = self.get_nodes_mermaid(self.nodes)
topics_str = list_ros_element_2_list_str(self.topics.values())
services_str = list_ros_element_2_list_str(self.services.values())
actions_str = list_ros_element_2_list_str(self.actions.values())
topics_style = "\n".join(topics_str)
services_style = "\n".join(services_str)
actions_style = "\n".join(actions_str)
all_links = {
name: str_main_links[name] + str_nodes_links[name] for name in LinkType
}
num_topic_publisher_links = [0, len(all_links[LinkType.TOPIC_PUBLISHER])]
num_topic_subscriber_links = [
num_topic_publisher_links[1],
len(all_links[LinkType.TOPIC_SUBSCRIBER]) + num_topic_publisher_links[1],
]
num_service_server_links = [
num_topic_subscriber_links[1],
len(all_links[LinkType.SERVICE_SERVER]) + num_topic_subscriber_links[1],
]
num_service_client_links = [
num_service_server_links[1],
len(all_links[LinkType.SERVICE_CLIENT]) + num_service_server_links[1],
]
num_action_server_links = [
num_service_client_links[1],
len(all_links[LinkType.ACTION_SERVER]) + num_service_client_links[1],
]
num_action_client_links = [
num_action_server_links[1],
len(all_links[LinkType.ACTION_CLIENT]) + num_action_server_links[1],
]
links_ranges = {
LinkType.TOPIC_PUBLISHER: num_topic_publisher_links,
LinkType.TOPIC_SUBSCRIBER: num_topic_subscriber_links,
LinkType.SERVICE_SERVER: num_service_server_links,
LinkType.SERVICE_CLIENT: num_service_client_links,
LinkType.ACTION_SERVER: num_action_server_links,
LinkType.ACTION_CLIENT: num_action_client_links,
}
mermaid_graph = [
main_style,
nodes_style,
topics_style,
services_style,
actions_style,
"\n".join(all_links[LinkType.TOPIC_PUBLISHER]),
"\n".join(all_links[LinkType.TOPIC_SUBSCRIBER]),
"\n".join(all_links[LinkType.SERVICE_SERVER]),
"\n".join(all_links[LinkType.SERVICE_CLIENT]),
"\n".join(all_links[LinkType.ACTION_SERVER]),
"\n".join(all_links[LinkType.ACTION_CLIENT]),
]
mermaid_str = "\n".join(mermaid_graph)
return mermaid_str, links_ranges | /ros2_graph-0.0.4.tar.gz/ros2_graph-0.0.4/ros2_graph/graph_generator.py | 0.806014 | 0.3043 | graph_generator.py | pypi |
import subprocess
from functools import reduce, partial
import rclpy
from rclpy.node import Node
rclpy.init()
dummy = Node("Graph_generator")
def between_patterns(pattern: tuple, file: str) -> str:
"""!
Return sed instruction to get text between two patters
@param pattern (tuple) size tow tuple with both patterns
@param file (str) File to filter
@return str filtered text
"""
instruction = ("sed -n '/%s/, /%s/{ /%s/! { /%s/! p } }' %s") % (
pattern[0],
pattern[1],
pattern[0],
pattern[1],
file,
)
return instruction
def after_pattern(pattern: str, file: str) -> str:
"""!
Return sed instruction to get text after a pattern
@param pattern (str) pattern to filter
@param file (str) File to filter
@return str filterd text
"""
instruction = f"sed -n '/{pattern}/,$p' {file} | sed '1d'"
return instruction
def get_clean_lines(query_instruction: str) -> list:
"""! Extrac nodes names from ros cli query
@param query_instruction (str) ros2 cli query plus sed or grep filter instruction
@return list lines
"""
line_list = (
subprocess.check_output(
query_instruction,
shell=True,
)
.decode("utf-8")
.splitlines()
)
return filter(lambda x: x != "", line_list)
def get_node_info_block(pattern: tuple):
"""! Extract info from an specific block of ros2 node info instruction
@param pattern: tuple of strings, marks taht indicate the start and the end of that block
@return tuples (element, type)
"""
file_name = "node_info.txt"
filter_rule = (
between_patterns(pattern, file_name)
if len(pattern) > 1
else after_pattern(pattern[0], file_name)
)
filter_rule += " | tr -d '[:blank:]'"
return tuple(x.split(":") for x in get_clean_lines(filter_rule))
def join_name_and_namespace(name: str, namespace: str = None):
if namespace is None:
return name
if len(namespace) > 1:
namespace += "/"
return namespace + name
def is_not_exclude(service, exclude):
for e in exclude:
if e in service[0]:
return False
return True
def get_topic_info(topics: list, publishers: bool) -> dict:
"""!
Get publishers or subcribers nodes from nodes names
@param topics (list[tuples]) List of topics with names and type
@param publishers (bool) get publishers or subscribers nodes
@return tuples (topic_name, [nodes_names])
"""
def filter_topics(topic):
exclude = (
"/parameter_events",
"/rosout",
"/tf",
"/cascade_lifecycle_activations",
"/cascade_lifecycle_states",
"",
)
exclude_fracment = ("/transition_event", "/_action")
if topic[0] in exclude:
return False
return is_not_exclude(topic, exclude_fracment)
topics_and_nodes = {
topic[0]: {"type": topic[1][0], "nodes": []}
for topic in filter(filter_topics, topics)
}
topics_names = topics_and_nodes.keys()
get_endpoints_function = (
dummy.get_publishers_info_by_topic
if publishers
else dummy.get_subscriptions_info_by_topic
)
for topic in topics_names:
endpoints = get_endpoints_function(topic)
topics_and_nodes[topic]["nodes"] = [
join_name_and_namespace(endpoint.node_name, endpoint.node_namespace)
for endpoint in endpoints
]
return topics_and_nodes
def get_server_info(services: map, clients: bool):
"""! Filter avalible services
@param services (map) _description_
"""
exclude = (
"/change_state",
"/describe_parameters",
"/get_available_states",
"/get_available_transitions",
"/get_parameter_types",
"/get_parameters",
"/get_state",
"/get_transition_graph",
"/list_parameters",
"/set_parameters",
"/set_parameters_atomically",
"/_action",
)
filter_services = partial(is_not_exclude, exclude=exclude)
services_and_nodes = {
service[0]: {"type": service[1][0], "nodes": []}
for service in filter(filter_services, services)
}
services_names = services_and_nodes.keys()
nodes_list = dummy.get_node_names_and_namespaces()
get_services_function = (
dummy.get_client_names_and_types_by_node
if clients
else dummy.get_service_names_and_types_by_node
)
for node in nodes_list:
services = tuple(map(lambda x: x[0], get_services_function(*node)))
filtered_services = tuple(
filter((lambda service: service in services_names), services)
)
for service in filtered_services:
services_and_nodes[service]["nodes"].append(join_name_and_namespace(*node))
return services_and_nodes
def get_action_info(actions: map, clients: bool):
"""!
Get publishers or subcribers nodes from nodes names
@param raw_topic_list (map) tuples actions and types
@param subscribers (bool) get subscribers or publishers nodes
@return dict {action_name: [nodes_names]}
"""
pattern = ("Action clients:", "Action servers:")
aux_file = "actions.txt"
filter_command = (
between_patterns(pattern, aux_file)
if clients
else after_pattern(pattern[1], aux_file)
) + " | tr -d '[:blank:]'"
actions_and_nodes = {
action[0]: {"type": action[1], "nodes": []} for action in actions
}
actions_names = actions_and_nodes.keys()
for action in actions_names:
actions_and_nodes[action]["nodes"] = tuple(
get_clean_lines(
f"ros2 action info {action} >> {aux_file} && {filter_command} && rm {aux_file}",
)
)
return actions_and_nodes
def mermaid_topics(node: str, topics: dict, subscribers: bool, links_count: int):
mermaid_topic_description = []
for topic, topic_info in topics.items():
n_publishers = len(topic_info["nodes"])
links_count += 1 + n_publishers
style = "topic" if n_publishers else "bugged"
topic_node = f"{topic}([{topic}<br>{topic_info['type']}]):::{style}"
if subscribers:
topic_node += f" --> {node}"
mermaid_topic_description.append(topic_node)
mermaid_topic_description.extend(
[f"{node}:::node --> {topic}" for node in topic_info["nodes"]]
)
else:
topic_node = f"{node} --> " + topic_node
mermaid_topic_description.append(topic_node)
mermaid_topic_description.extend(
[f"{topic} --> {node}:::node" for node in topic_info["nodes"]]
)
return mermaid_topic_description, links_count
def mermaid_services(
node: str, service_dictionary: dict, clients: bool, links_count: int
):
mermaid_service_description = []
for service, service_info in service_dictionary.items():
n_clients = len(service_info["nodes"])
links_count += 1 + n_clients
style = "service" if n_clients else "bugged"
service_node = f"{service}[/{service}<br>{service_info['type']}\]:::{style}"
if clients:
service_node = f"{node} o-.-o " + service_node
mermaid_service_description.append(service_node)
mermaid_service_description.extend(
[f"{service} <-.-> {node}:::node" for node in service_info["nodes"]]
)
else:
service_node = service_node + f" <-.-> {node}"
mermaid_service_description.append(service_node)
mermaid_service_description.extend(
[f"{node}:::node o-.-o {service}" for node in service_info["nodes"]]
)
return mermaid_service_description, links_count
def mermaid_actions(
node: str, action_dictionary: dict, clients: bool, links_count: int
):
mermaid_action_description = []
for action, action_info in action_dictionary.items():
n_clients = len(action_info["nodes"])
links_count += 1 + n_clients
style = "action" if n_clients else "bugged"
action_node = (
action + "{{" + action + "<br>" + action_info["type"] + "}}:::" + style
)
if clients:
action_node = f"{node} <==> " + action_node
mermaid_action_description.append(action_node)
mermaid_action_description.extend(
[f"{action} o==o {node}:::node" for node in action_info["nodes"]]
)
else:
action_node += f" o==o {node}"
mermaid_action_description.append(action_node)
mermaid_action_description.extend(
[f"{action} o==o {node}:::node" for node in action_info["nodes"]]
)
return mermaid_action_description, links_count
def get_node_graph(node, links_count):
patterns = {
"action_servers": ("Action Servers:", "Action Clients:"),
"action_client": ("Action Clients:",),
}
subprocess.check_output(
f"ros2 node info {node} >> node_info.txt",
shell=True,
)
elements = {k: get_node_info_block(pattern) for k, pattern in patterns.items()}
subprocess.check_output(
"rm node_info.txt",
shell=True,
)
action_clients = get_action_info(elements["action_servers"], True)
action_servers = get_action_info(elements["action_client"], False)
namespace_name = node.split("/")
name = namespace_name[-1]
namespace = "/".join(namespace_name[:-1])
if namespace == "":
namespace = "/"
name_and_namespace = (name, namespace)
subscribers = dummy.get_subscriber_names_and_types_by_node(*name_and_namespace)
publishers = dummy.get_publisher_names_and_types_by_node(*name_and_namespace)
services_server = dummy.get_service_names_and_types_by_node(*name_and_namespace)
services_client = dummy.get_client_names_and_types_by_node(*name_and_namespace)
topics_subscribers = get_topic_info(subscribers, True)
topics_publishers = get_topic_info(publishers, False)
service_clients = get_server_info(services_server, True)
service_servers = get_server_info(services_client, False)
mermaid_graph_description, links_count = mermaid_topics(
node, topics_subscribers, subscribers=True, links_count=links_count
)
mermaid_list, links_count = mermaid_topics(
node, topics_publishers, subscribers=False, links_count=links_count
)
mermaid_graph_description.extend(mermaid_list)
mermaid_list, links_count = mermaid_services(
node, service_clients, clients=True, links_count=links_count
)
mermaid_graph_description.extend(mermaid_list)
mermaid_list, links_count = mermaid_services(
node, service_servers, clients=False, links_count=links_count
)
mermaid_graph_description.extend(mermaid_list)
start_action_links = links_count
mermaid_list, links_count = mermaid_actions(
node, action_clients, clients=False, links_count=links_count
)
mermaid_graph_description.extend(mermaid_list)
mermaid_list, links_count = mermaid_actions(
node, action_servers, clients=True, links_count=links_count
)
mermaid_graph_description.extend(mermaid_list)
action_links = list(range(start_action_links, links_count))
return mermaid_graph_description, action_links, links_count | /ros2_graphs_mermaid-0.0.1-py3-none-any.whl/ros2_graphs_mermaid/graph_generator.py | 0.677474 | 0.343507 | graph_generator.py | pypi |
from .registry import converts_from_numpy, converts_to_numpy
from geometry_msgs.msg import Transform, Vector3, Quaternion, Point, Pose
import transformations as transformations
from . import numpify
import numpy as np
# basic types
@converts_to_numpy(Vector3)
def vector3_to_numpy(msg, hom=False):
if hom:
return np.array([msg.x, msg.y, msg.z, 0])
else:
return np.array([msg.x, msg.y, msg.z])
@converts_from_numpy(Vector3)
def numpy_to_vector3(arr):
if arr.shape[-1] == 4:
assert np.all(arr[...,-1] == 0)
arr = arr[...,:-1]
if len(arr.shape) == 1:
return Vector3(**dict(zip(['x', 'y', 'z'], arr)))
else:
return np.apply_along_axis(
lambda v: Vector3(**dict(zip(['x', 'y', 'z'], v))), axis=-1,
arr=arr)
@converts_to_numpy(Point)
def point_to_numpy(msg, hom=False):
if hom:
return np.array([msg.x, msg.y, msg.z, 1])
else:
return np.array([msg.x, msg.y, msg.z])
@converts_from_numpy(Point)
def numpy_to_point(arr):
if arr.shape[-1] == 4:
arr = arr[...,:-1] / arr[...,-1]
if len(arr.shape) == 1:
return Point(**dict(zip(['x', 'y', 'z'], arr)))
else:
return np.apply_along_axis(
lambda v: Point(**dict(zip(['x', 'y', 'z'], v))), axis=-1, arr=arr)
@converts_to_numpy(Quaternion)
def quat_to_numpy(msg):
return np.array([msg.x, msg.y, msg.z, msg.w])
@converts_from_numpy(Quaternion)
def numpy_to_quat(arr):
assert arr.shape[-1] == 4
if len(arr.shape) == 1:
return Quaternion(**dict(zip(['x', 'y', 'z', 'w'], arr)))
else:
return np.apply_along_axis(
lambda v: Quaternion(**dict(zip(['x', 'y', 'z', 'w'], v))),
axis=-1, arr=arr)
# compound types
# all of these take ...x4x4 homogeneous matrices
@converts_to_numpy(Transform)
def transform_to_numpy(msg):
return np.dot(
transformations.translation_matrix(numpify(msg.translation)),
transformations.quaternion_matrix(numpify(msg.rotation))
)
@converts_from_numpy(Transform)
def numpy_to_transform(arr):
shape, rest = arr.shape[:-2], arr.shape[-2:]
assert rest == (4,4)
if len(shape) == 0:
trans = transformations.translation_from_matrix(arr)
quat = transformations.quaternion_from_matrix(arr)
return Transform(
translation=Vector3(**dict(zip(['x', 'y', 'z'], trans))),
rotation=Quaternion(**dict(zip(['x', 'y', 'z', 'w'], quat)))
)
else:
res = np.empty(shape, dtype=np.object_)
for idx in np.ndindex(shape):
res[idx] = Transform(
translation=Vector3(
**dict(
zip(['x', 'y', 'z'],
transformations.translation_from_matrix(arr[idx])))),
rotation=Quaternion(
**dict(
zip(['x', 'y', 'z', 'w'],
transformations.quaternion_from_matrix(arr[idx]))))
)
@converts_to_numpy(Pose)
def pose_to_numpy(msg):
return np.dot(
transformations.translation_matrix(numpify(msg.position)),
transformations.quaternion_matrix(numpify(msg.orientation))
)
@converts_from_numpy(Pose)
def numpy_to_pose(arr):
shape, rest = arr.shape[:-2], arr.shape[-2:]
assert rest == (4,4)
if len(shape) == 0:
trans = transformations.translation_from_matrix(arr)
quat = transformations.quaternion_from_matrix(arr)
return Pose(
position=Point(**dict(zip(['x', 'y', 'z'], trans))),
orientation=Quaternion(**dict(zip(['x', 'y', 'z', 'w'], quat)))
)
else:
res = np.empty(shape, dtype=np.object_)
for idx in np.ndindex(shape):
res[idx] = Pose(
position=Point(
**dict(
zip(['x', 'y', 'z'],
transformations.translation_from_matrix(arr[idx])))),
orientation=Quaternion(
**dict(
zip(['x', 'y', 'z', 'w'],
transformations.quaternion_from_matrix(arr[idx]))))
) | /ros2_numpy-0.0.4.tar.gz/ros2_numpy-0.0.4/ros2_numpy/geometry.py | 0.594669 | 0.55254 | geometry.py | pypi |
import rclpy
from rclpy.node import Node
from rclpy.time import Time
from rclpy.duration import Duration
from sensor_msgs.msg import Joy
from std_srvs.srv import Empty
from .common import get_var
def make_mask(vec, size):
return [True if n in vec else False for n in range(size)]
class Joy2SM(Node):
def __init__(self):
super().__init__('Joy2SM')
self.declare_parameter("buttons", [4, 5])
self.buttons = self.get_parameter("buttons").value
self.declare_parameter("axes", [2, 5])
self.axes = self.get_parameter("axes").value
self.declare_parameter("timeout", 3)
self._timeout_number = int(self.get_parameter("timeout").value)
self.declare_parameter("name_service", 'shutdown')
self._name_service = self.get_parameter("name_service").value
self.cli = self.create_client(Empty, self._name_service)
# Initialize timer
self._first = None
self.send_message = True
self._timeout = Duration(seconds=self._timeout_number)
# Register subcriber
self.subscription = self.create_subscription(
Joy,
'joy',
self.joy_callback,
1)
self.subscription # prevent unused variable warning
# Get version
version = get_var()
self.get_logger().info(f'joy2sm {version} started')
self.get_logger().info(f"Buttons: {self.buttons} - Axes: {self.axes}")
self.get_logger().info(f"Timeout: {self._timeout_number} Service name: {self._name_service}")
def joy_callback(self, msg):
# Decode joystick message
axes_buttons = [True if axe < 0 else False for axe in msg.axes]
mask_axes = make_mask(self.axes, len(axes_buttons))
buttons = [True if but == 1 else False for but in msg.buttons]
mask_buttons = make_mask(self.buttons, len(buttons))
# Check if all buttons are all pressed
if (buttons == mask_buttons) and (axes_buttons == mask_axes):
if self._first is None:
self._first = Time(seconds=msg.header.stamp.sec, nanoseconds=msg.header.stamp.nanosec)
self.get_logger().info(f"All buttons pressed, wait {self._timeout_number} seconds")
# Compare time
now = Time(seconds=msg.header.stamp.sec, nanoseconds=msg.header.stamp.nanosec)
# Compare time
if now - self._first > self._timeout and self.send_message:
self.send_message = False
self.get_logger().info(f"Call service {self._name_service}")
# Send service message
self.req = Empty.Request()
self.future = self.cli.call_async(self.req)
else:
# Reset last time
self._first = None
self.send_message = True
def main(args=None):
rclpy.init(args=args)
# Start Nanosaur
joy2sm = Joy2SM()
try:
rclpy.spin(joy2sm)
except (KeyboardInterrupt, SystemExit):
pass
# Destroy the node explicitly
joy2sm.destroy_node()
rclpy.shutdown()
if __name__ == '__main__':
main()
# EOF | /ros2_system_manager-0.1.5.tar.gz/ros2_system_manager-0.1.5/ros2_system_manager/joy2sm.py | 0.519278 | 0.175079 | joy2sm.py | pypi |
import numpy as np
from .led import LED
from .wheel import Wheel
from .remote_io import RemoteIO
from .remote_cam import Camera
class Rosa(object):
def __init__(self, host):
""" Connects to the robot.
Host is a string representing the robot address. Can be "rosa.local" when using ZeroConf or directly the IP address such as "192.168.0.45".
"""
self._io = RemoteIO(host)
self._host = host
self._left_wheel = Wheel(id='b', side='left', remote_io=self._io)
self._right_wheel = Wheel(id='a', side='right', remote_io=self._io, inverse=True)
self._cam = Camera(host)
self._left_led = LED(side='left', remote_io=self._io)
self._front_led = LED(side='center', remote_io=self._io)
self._right_led = LED(side='right', remote_io=self._io)
def __repr__(self):
return 'RosaClient(host="{}", connected={})'.format(self._host, self._io.connected)
@property
def left_wheel(self):
return self._left_wheel
@property
def right_wheel(self):
return self._right_wheel
@property
def left_led(self):
return self._left_led
@property
def front_led(self):
return self._front_led
@property
def right_led(self):
return self._right_led
@property
def camera(self):
return self._cam
@property
def front_distance_sensors(self):
return ['front-left', 'front-center', 'front-right']
def get_front_distances(self):
""" Return distance from the front sensors (left, center, right). """
return np.array([self.get_distance(name) for name in self.front_distance_sensors])
@property
def ground_distance_sensors(self):
return [
'ground-front-left', 'ground-front-right',
'ground-rear-left', 'ground-rear-right',
]
def get_ground_distances(self):
""" Return distance from the ground sensors (front left, front right, rear left, rear right). """
return np.array([self.get_distance(name) for name in self.ground_distance_sensors])
@property
def distance_sensors(self):
return self.front_distance_sensors + self.ground_distance_sensors
def get_distance(self, sensor):
"""
Return distance from the given sensor.
See Rosa.distance_sensors for a list of all available sensors.
"""
if sensor not in self.distance_sensors:
raise ValueError('sensor should be one of {}!'.format(self.distance_sensors))
return 255 - self._io.last_state['distance'][sensor]
def get_color(self):
""" Return RGBAmbient detected from the front center sensor. """
return self._io.last_state['color']['front-center']
def buzz(self, duration):
""" Trigger a buzz for duration (in sec). """
self._io.buzz(duration) | /rosa_robot-0.1.0-py3-none-any.whl/rosa/rosa.py | 0.923773 | 0.304449 | rosa.py | pypi |
from __future__ import division
import colorsys
import os
from timeit import default_timer as timer
import numpy as np
from keras import backend as K
from keras.models import load_model
from keras.layers import Input
from PIL import Image, ImageFont, ImageDraw
from .yolo3.model import yolo_eval, yolo_body, tiny_yolo_body
from .yolo3.utils import letterbox_image
from keras.utils import multi_gpu_model
class YOLO(object):
_defaults = {
"model_path": 'model_data/yolo.h5',
"anchors_path": 'model_data/yolo_anchors.txt',
"classes_path": 'model_data/coco_classes.txt',
"score": 0.3,
"iou": 0.45,
"model_image_size": (416, 416),
"gpu_num": 1,
}
@classmethod
def get_defaults(cls, n):
if n in cls._defaults:
return cls._defaults[n]
else:
return "Unrecognized attribute name '" + n + "'"
def __init__(self, **kwargs):
self.__dict__.update(self._defaults) # set up default values
self.__dict__.update(kwargs) # and update with user overrides
self.class_names = self._get_class()
self.anchors = self._get_anchors()
self.sess = K.get_session()
self.boxes, self.scores, self.classes = self.generate()
def _get_class(self):
classes_path = os.path.expanduser(self.classes_path)
with open(classes_path) as f:
class_names = f.readlines()
class_names = [c.strip() for c in class_names]
return class_names
def _get_anchors(self):
anchors_path = os.path.expanduser(self.anchors_path)
with open(anchors_path) as f:
anchors = f.readline()
anchors = [float(x) for x in anchors.split(',')]
return np.array(anchors).reshape(-1, 2)
def generate(self):
model_path = os.path.expanduser(self.model_path)
assert model_path.endswith('.h5'), 'Keras model or weights must be a .h5 file.'
# Load model, or construct model and load weights.
num_anchors = len(self.anchors)
num_classes = len(self.class_names)
is_tiny_version = num_anchors == 6 # default setting
try:
self.yolo_model = load_model(model_path, compile=False)
except Exception:
self.yolo_model = tiny_yolo_body(Input(shape=(None, None, 3)), num_anchors // 2, num_classes) \
if is_tiny_version else yolo_body(Input(shape=(None, None, 3)), num_anchors // 3, num_classes)
self.yolo_model.load_weights(self.model_path) # make sure model, anchors and classes match
else:
assert self.yolo_model.layers[-1].output_shape[-1] == \
num_anchors / len(self.yolo_model.output) * (num_classes + 5), \
'Mismatch between model and given anchor and class sizes'
print('{} model, anchors, and classes loaded.'.format(model_path))
# Generate colors for drawing bounding boxes.
hsv_tuples = [(x / len(self.class_names), 1., 1.)
for x in range(len(self.class_names))]
self.colors = list(map(lambda x: colorsys.hsv_to_rgb(*x), hsv_tuples))
self.colors = list(
map(lambda x: (int(x[0] * 255), int(x[1] * 255), int(x[2] * 255)),
self.colors))
np.random.seed(10101) # Fixed seed for consistent colors across runs.
np.random.shuffle(self.colors) # Shuffle colors to decorrelate adjacent classes.
np.random.seed(None) # Reset seed to default.
# Generate output tensor targets for filtered bounding boxes.
self.input_image_shape = K.placeholder(shape=(2, ))
if self.gpu_num >= 2:
self.yolo_model = multi_gpu_model(self.yolo_model, gpus=self.gpu_num)
boxes, scores, classes = yolo_eval(self.yolo_model.output, self.anchors,
len(self.class_names), self.input_image_shape,
score_threshold=self.score, iou_threshold=self.iou)
return boxes, scores, classes
def detect_image(self, image):
if self.model_image_size != (None, None):
assert self.model_image_size[0] % 32 == 0, 'Multiples of 32 required'
assert self.model_image_size[1] % 32 == 0, 'Multiples of 32 required'
boxed_image = letterbox_image(image, tuple(reversed(self.model_image_size)))
else:
new_image_size = (image.width - (image.width % 32),
image.height - (image.height % 32))
boxed_image = letterbox_image(image, new_image_size)
image_data = np.array(boxed_image, dtype='float32')
image_data /= 255.
image_data = np.expand_dims(image_data, 0) # Add batch dimension.
out_boxes, out_scores, out_classes = self.sess.run(
[self.boxes, self.scores, self.classes],
feed_dict={
self.yolo_model.input: image_data,
self.input_image_shape: [image.size[1], image.size[0]],
K.learning_phase(): 0
})
out_boxes, out_scores, out_classes = self.remove_duplicate_boxes(out_boxes, out_scores, out_classes)
font_path = os.path.join(
os.path.dirname(__file__),
'font/FiraMono-Medium.otf'
)
font = ImageFont.truetype(font=font_path,
size=np.floor(3e-2 * image.size[1] + 0.5).astype('int32'))
thickness = 5
for i, c in reversed(list(enumerate(out_classes))):
predicted_class = self.class_names[c]
box = out_boxes[i]
score = out_scores[i]
# print(predicted_class, score)
label = '{} {:.2f}'.format(predicted_class, score)
draw = ImageDraw.Draw(image)
label_size = draw.textsize(label, font)
top, left, bottom, right = box
top = max(0, np.floor(top + 0.5).astype('int32'))
left = max(0, np.floor(left + 0.5).astype('int32'))
bottom = min(image.size[1], np.floor(bottom + 0.5).astype('int32'))
right = min(image.size[0], np.floor(right + 0.5).astype('int32'))
if top - label_size[1] >= 0:
text_origin = np.array([left, top - label_size[1]])
else:
text_origin = np.array([left, top + 1])
# My kingdom for a good redistributable image drawing library.
for i in range(thickness):
draw.rectangle(
[left + i, top + i, right - i, bottom - i],
outline=self.colors[c])
draw.rectangle(
[tuple(text_origin), tuple(text_origin + label_size)],
fill=self.colors[c])
draw.text(text_origin, label, fill=(0, 0, 0), font=font)
return image, (out_boxes, out_scores, out_classes)
def close_session(self):
self.sess.close()
def remove_duplicate_boxes(self, out_boxes, out_scores, out_classes):
center = [
np.array(((ly + 0.5 * (ry - ly)), (lx + 0.5 * (rx - lx))))
for (ly, lx, ry, rx) in out_boxes
]
dist = {
i: {j: np.linalg.norm(c - center[j])
for j in range(i + 1, len(center))}
for i, c in enumerate(center)
}
dup = {
i: [j for j, norm in d.items() if norm < 30]
for i, d in dist.items()
}
selected = np.array(list({
i if len(js) == 0 else max(js, key=lambda j: out_scores[j])
for i, js in dup.items()
}), dtype=np.int64)
return out_boxes[selected], out_scores[selected], out_classes[selected]
def detect_video(yolo, video_path, output_path=""):
import cv2
vid = cv2.VideoCapture(video_path)
if not vid.isOpened():
raise IOError("Couldn't open webcam or video")
video_FourCC = int(vid.get(cv2.CAP_PROP_FOURCC))
video_fps = vid.get(cv2.CAP_PROP_FPS)
video_size = (int(vid.get(cv2.CAP_PROP_FRAME_WIDTH)),
int(vid.get(cv2.CAP_PROP_FRAME_HEIGHT)))
isOutput = True if output_path != "" else False
if isOutput:
print("!!! TYPE:", type(output_path), type(video_FourCC), type(video_fps), type(video_size))
out = cv2.VideoWriter(output_path, video_FourCC, video_fps, video_size)
accum_time = 0
curr_fps = 0
fps = "FPS: ??"
prev_time = timer()
while True:
return_value, frame = vid.read()
image = Image.fromarray(frame)
image = yolo.detect_image(image)
result = np.asarray(image)
curr_time = timer()
exec_time = curr_time - prev_time
prev_time = curr_time
accum_time = accum_time + exec_time
curr_fps = curr_fps + 1
if accum_time > 1:
accum_time = accum_time - 1
fps = "FPS: " + str(curr_fps)
curr_fps = 0
cv2.putText(result, text=fps, org=(3, 15), fontFace=cv2.FONT_HERSHEY_SIMPLEX,
fontScale=0.50, color=(255, 0, 0), thickness=2)
cv2.namedWindow("result", cv2.WINDOW_NORMAL)
cv2.imshow("result", result)
if isOutput:
out.write(result)
if cv2.waitKey(1) & 0xFF == ord('q'):
break
yolo.close_session() | /rosa_robot-0.1.0-py3-none-any.whl/rosa/vision/yolov3/yolo.py | 0.830594 | 0.279073 | yolo.py | pypi |
from __future__ import division
from functools import wraps
import numpy as np
import tensorflow as tf
from keras import backend as K
from keras.layers import Conv2D, Add, ZeroPadding2D, UpSampling2D, Concatenate, MaxPooling2D
from keras.layers.advanced_activations import LeakyReLU
from keras.layers.normalization import BatchNormalization
from keras.models import Model
from keras.regularizers import l2
from .utils import compose
@wraps(Conv2D)
def DarknetConv2D(*args, **kwargs):
"""Wrapper to set Darknet parameters for Convolution2D."""
darknet_conv_kwargs = {'kernel_regularizer': l2(5e-4)}
darknet_conv_kwargs['padding'] = 'valid' if kwargs.get('strides') == (2, 2) else 'same'
darknet_conv_kwargs.update(kwargs)
return Conv2D(*args, **darknet_conv_kwargs)
def DarknetConv2D_BN_Leaky(*args, **kwargs):
"""Darknet Convolution2D followed by BatchNormalization and LeakyReLU."""
no_bias_kwargs = {'use_bias': False}
no_bias_kwargs.update(kwargs)
return compose(
DarknetConv2D(*args, **no_bias_kwargs),
BatchNormalization(),
LeakyReLU(alpha=0.1))
def resblock_body(x, num_filters, num_blocks):
'''A series of resblocks starting with a downsampling Convolution2D'''
# Darknet uses left and top padding instead of 'same' mode
x = ZeroPadding2D(((1, 0), (1, 0)))(x)
x = DarknetConv2D_BN_Leaky(num_filters, (3, 3), strides=(2, 2))(x)
for i in range(num_blocks):
y = compose(
DarknetConv2D_BN_Leaky(num_filters // 2, (1, 1)),
DarknetConv2D_BN_Leaky(num_filters, (3, 3)))(x)
x = Add()([x, y])
return x
def darknet_body(x):
'''Darknent body having 52 Convolution2D layers'''
x = DarknetConv2D_BN_Leaky(32, (3, 3))(x)
x = resblock_body(x, 64, 1)
x = resblock_body(x, 128, 2)
x = resblock_body(x, 256, 8)
x = resblock_body(x, 512, 8)
x = resblock_body(x, 1024, 4)
return x
def make_last_layers(x, num_filters, out_filters):
'''6 Conv2D_BN_Leaky layers followed by a Conv2D_linear layer'''
x = compose(
DarknetConv2D_BN_Leaky(num_filters, (1, 1)),
DarknetConv2D_BN_Leaky(num_filters * 2, (3, 3)),
DarknetConv2D_BN_Leaky(num_filters, (1, 1)),
DarknetConv2D_BN_Leaky(num_filters * 2, (3, 3)),
DarknetConv2D_BN_Leaky(num_filters, (1, 1)))(x)
y = compose(
DarknetConv2D_BN_Leaky(num_filters * 2, (3, 3)),
DarknetConv2D(out_filters, (1, 1)))(x)
return x, y
def yolo_body(inputs, num_anchors, num_classes):
"""Create YOLO_V3 model CNN body in Keras."""
darknet = Model(inputs, darknet_body(inputs))
x, y1 = make_last_layers(darknet.output, 512, num_anchors * (num_classes + 5))
x = compose(
DarknetConv2D_BN_Leaky(256, (1, 1)),
UpSampling2D(2))(x)
x = Concatenate()([x, darknet.layers[152].output])
x, y2 = make_last_layers(x, 256, num_anchors * (num_classes + 5))
x = compose(
DarknetConv2D_BN_Leaky(128, (1, 1)),
UpSampling2D(2))(x)
x = Concatenate()([x, darknet.layers[92].output])
x, y3 = make_last_layers(x, 128, num_anchors * (num_classes + 5))
return Model(inputs, [y1, y2, y3])
def tiny_yolo_body(inputs, num_anchors, num_classes):
'''Create Tiny YOLO_v3 model CNN body in keras.'''
x1 = compose(
DarknetConv2D_BN_Leaky(16, (3, 3)),
MaxPooling2D(pool_size=(2, 2), strides=(2, 2), padding='same'),
DarknetConv2D_BN_Leaky(32, (3, 3)),
MaxPooling2D(pool_size=(2, 2), strides=(2, 2), padding='same'),
DarknetConv2D_BN_Leaky(64, (3, 3)),
MaxPooling2D(pool_size=(2, 2), strides=(2, 2), padding='same'),
DarknetConv2D_BN_Leaky(128, (3, 3)),
MaxPooling2D(pool_size=(2, 2), strides=(2, 2), padding='same'),
DarknetConv2D_BN_Leaky(256, (3, 3)))(inputs)
x2 = compose(
MaxPooling2D(pool_size=(2, 2), strides=(2, 2), padding='same'),
DarknetConv2D_BN_Leaky(512, (3, 3)),
MaxPooling2D(pool_size=(2, 2), strides=(1, 1), padding='same'),
DarknetConv2D_BN_Leaky(1024, (3, 3)),
DarknetConv2D_BN_Leaky(256, (1, 1)))(x1)
y1 = compose(
DarknetConv2D_BN_Leaky(512, (3, 3)),
DarknetConv2D(num_anchors * (num_classes + 5), (1, 1)))(x2)
x2 = compose(
DarknetConv2D_BN_Leaky(128, (1, 1)),
UpSampling2D(2))(x2)
y2 = compose(
Concatenate(),
DarknetConv2D_BN_Leaky(256, (3, 3)),
DarknetConv2D(num_anchors * (num_classes + 5), (1, 1)))([x2, x1])
return Model(inputs, [y1, y2])
def yolo_head(feats, anchors, num_classes, input_shape, calc_loss=False):
"""Convert final layer features to bounding box parameters."""
num_anchors = len(anchors)
# Reshape to batch, height, width, num_anchors, box_params.
anchors_tensor = K.reshape(K.constant(anchors), [1, 1, 1, num_anchors, 2])
grid_shape = K.shape(feats)[1:3] # height, width
grid_y = K.tile(K.reshape(K.arange(0, stop=grid_shape[0]), [-1, 1, 1, 1]),
[1, grid_shape[1], 1, 1])
grid_x = K.tile(K.reshape(K.arange(0, stop=grid_shape[1]), [1, -1, 1, 1]),
[grid_shape[0], 1, 1, 1])
grid = K.concatenate([grid_x, grid_y])
grid = K.cast(grid, K.dtype(feats))
feats = K.reshape(
feats, [-1, grid_shape[0], grid_shape[1], num_anchors, num_classes + 5])
# Adjust preditions to each spatial grid point and anchor size.
box_xy = (K.sigmoid(feats[..., :2]) + grid) / K.cast(grid_shape[::-1], K.dtype(feats))
box_wh = K.exp(feats[..., 2:4]) * anchors_tensor / K.cast(input_shape[::-1], K.dtype(feats))
box_confidence = K.sigmoid(feats[..., 4:5])
box_class_probs = K.sigmoid(feats[..., 5:])
if calc_loss:
return grid, feats, box_xy, box_wh
return box_xy, box_wh, box_confidence, box_class_probs
def yolo_correct_boxes(box_xy, box_wh, input_shape, image_shape):
'''Get corrected boxes'''
box_yx = box_xy[..., ::-1]
box_hw = box_wh[..., ::-1]
input_shape = K.cast(input_shape, K.dtype(box_yx))
image_shape = K.cast(image_shape, K.dtype(box_yx))
new_shape = K.round(image_shape * K.min(input_shape / image_shape))
offset = (input_shape - new_shape) / 2. / input_shape
scale = input_shape / new_shape
box_yx = (box_yx - offset) * scale
box_hw *= scale
box_mins = box_yx - (box_hw / 2.)
box_maxes = box_yx + (box_hw / 2.)
boxes = K.concatenate([
box_mins[..., 0:1], # y_min
box_mins[..., 1:2], # x_min
box_maxes[..., 0:1], # y_max
box_maxes[..., 1:2] # x_max
])
# Scale boxes back to original image shape.
boxes *= K.concatenate([image_shape, image_shape])
return boxes
def yolo_boxes_and_scores(feats, anchors, num_classes, input_shape, image_shape):
'''Process Conv layer output'''
box_xy, box_wh, box_confidence, box_class_probs = yolo_head(feats,
anchors, num_classes, input_shape)
boxes = yolo_correct_boxes(box_xy, box_wh, input_shape, image_shape)
boxes = K.reshape(boxes, [-1, 4])
box_scores = box_confidence * box_class_probs
box_scores = K.reshape(box_scores, [-1, num_classes])
return boxes, box_scores
def yolo_eval(yolo_outputs,
anchors,
num_classes,
image_shape,
max_boxes=20,
score_threshold=.6,
iou_threshold=.5):
"""Evaluate YOLO model on given input and return filtered boxes."""
num_layers = len(yolo_outputs)
anchor_mask = [[6, 7, 8], [3, 4, 5], [0, 1, 2]] if num_layers == 3 else [[3, 4, 5], [1, 2, 3]] # default setting
input_shape = K.shape(yolo_outputs[0])[1:3] * 32
boxes = []
box_scores = []
for l in range(num_layers):
_boxes, _box_scores = yolo_boxes_and_scores(yolo_outputs[l],
anchors[anchor_mask[l]], num_classes, input_shape, image_shape)
boxes.append(_boxes)
box_scores.append(_box_scores)
boxes = K.concatenate(boxes, axis=0)
box_scores = K.concatenate(box_scores, axis=0)
mask = box_scores >= score_threshold
max_boxes_tensor = K.constant(max_boxes, dtype='int32')
boxes_ = []
scores_ = []
classes_ = []
for c in range(num_classes):
# TODO: use keras backend instead of tf.
class_boxes = tf.boolean_mask(boxes, mask[:, c])
class_box_scores = tf.boolean_mask(box_scores[:, c], mask[:, c])
nms_index = tf.image.non_max_suppression(
class_boxes, class_box_scores, max_boxes_tensor, iou_threshold=iou_threshold)
class_boxes = K.gather(class_boxes, nms_index)
class_box_scores = K.gather(class_box_scores, nms_index)
classes = K.ones_like(class_box_scores, 'int32') * c
boxes_.append(class_boxes)
scores_.append(class_box_scores)
classes_.append(classes)
boxes_ = K.concatenate(boxes_, axis=0)
scores_ = K.concatenate(scores_, axis=0)
classes_ = K.concatenate(classes_, axis=0)
return boxes_, scores_, classes_
def preprocess_true_boxes(true_boxes, input_shape, anchors, num_classes):
'''Preprocess true boxes to training input format
Parameters
----------
true_boxes: array, shape=(m, T, 5)
Absolute x_min, y_min, x_max, y_max, class_id relative to input_shape.
input_shape: array-like, hw, multiples of 32
anchors: array, shape=(N, 2), wh
num_classes: integer
Returns
-------
y_true: list of array, shape like yolo_outputs, xywh are reletive value
'''
assert (true_boxes[..., 4] < num_classes).all(), 'class id must be less than num_classes'
num_layers = len(anchors) // 3 # default setting
anchor_mask = [[6, 7, 8], [3, 4, 5], [0, 1, 2]] if num_layers == 3 else [[3, 4, 5], [1, 2, 3]]
true_boxes = np.array(true_boxes, dtype='float32')
input_shape = np.array(input_shape, dtype='int32')
boxes_xy = (true_boxes[..., 0:2] + true_boxes[..., 2:4]) // 2
boxes_wh = true_boxes[..., 2:4] - true_boxes[..., 0:2]
true_boxes[..., 0:2] = boxes_xy / input_shape[::-1]
true_boxes[..., 2:4] = boxes_wh / input_shape[::-1]
m = true_boxes.shape[0]
grid_shapes = [input_shape // {0: 32, 1: 16, 2: 8}[l] for l in range(num_layers)]
y_true = [np.zeros((m, grid_shapes[l][0], grid_shapes[l][1], len(anchor_mask[l]), 5 + num_classes), dtype='float32') for l in range(num_layers)]
# Expand dim to apply broadcasting.
anchors = np.expand_dims(anchors, 0)
anchor_maxes = anchors / 2.
anchor_mins = -anchor_maxes
valid_mask = boxes_wh[..., 0] > 0
for b in range(m):
# Discard zero rows.
wh = boxes_wh[b, valid_mask[b]]
if len(wh) == 0:
continue
# Expand dim to apply broadcasting.
wh = np.expand_dims(wh, -2)
box_maxes = wh / 2.
box_mins = -box_maxes
intersect_mins = np.maximum(box_mins, anchor_mins)
intersect_maxes = np.minimum(box_maxes, anchor_maxes)
intersect_wh = np.maximum(intersect_maxes - intersect_mins, 0.)
intersect_area = intersect_wh[..., 0] * intersect_wh[..., 1]
box_area = wh[..., 0] * wh[..., 1]
anchor_area = anchors[..., 0] * anchors[..., 1]
iou = intersect_area / (box_area + anchor_area - intersect_area)
# Find best anchor for each true box
best_anchor = np.argmax(iou, axis=-1)
for t, n in enumerate(best_anchor):
for l in range(num_layers):
if n in anchor_mask[l]:
i = np.floor(true_boxes[b, t, 0] * grid_shapes[l][1]).astype('int32')
j = np.floor(true_boxes[b, t, 1] * grid_shapes[l][0]).astype('int32')
k = anchor_mask[l].index(n)
c = true_boxes[b, t, 4].astype('int32')
y_true[l][b, j, i, k, 0:4] = true_boxes[b, t, 0:4]
y_true[l][b, j, i, k, 4] = 1
y_true[l][b, j, i, k, 5 + c] = 1
return y_true
def box_iou(b1, b2):
'''Return iou tensor
Parameters
----------
b1: tensor, shape=(i1,...,iN, 4), xywh
b2: tensor, shape=(j, 4), xywh
Returns
-------
iou: tensor, shape=(i1,...,iN, j)
'''
# Expand dim to apply broadcasting.
b1 = K.expand_dims(b1, -2)
b1_xy = b1[..., :2]
b1_wh = b1[..., 2:4]
b1_wh_half = b1_wh / 2.
b1_mins = b1_xy - b1_wh_half
b1_maxes = b1_xy + b1_wh_half
# Expand dim to apply broadcasting.
b2 = K.expand_dims(b2, 0)
b2_xy = b2[..., :2]
b2_wh = b2[..., 2:4]
b2_wh_half = b2_wh / 2.
b2_mins = b2_xy - b2_wh_half
b2_maxes = b2_xy + b2_wh_half
intersect_mins = K.maximum(b1_mins, b2_mins)
intersect_maxes = K.minimum(b1_maxes, b2_maxes)
intersect_wh = K.maximum(intersect_maxes - intersect_mins, 0.)
intersect_area = intersect_wh[..., 0] * intersect_wh[..., 1]
b1_area = b1_wh[..., 0] * b1_wh[..., 1]
b2_area = b2_wh[..., 0] * b2_wh[..., 1]
iou = intersect_area / (b1_area + b2_area - intersect_area)
return iou
def yolo_loss(args, anchors, num_classes, ignore_thresh=.5, print_loss=False):
'''Return yolo_loss tensor
Parameters
----------
yolo_outputs: list of tensor, the output of yolo_body or tiny_yolo_body
y_true: list of array, the output of preprocess_true_boxes
anchors: array, shape=(N, 2), wh
num_classes: integer
ignore_thresh: float, the iou threshold whether to ignore object confidence loss
Returns
-------
loss: tensor, shape=(1,)
'''
num_layers = len(anchors) // 3 # default setting
yolo_outputs = args[:num_layers]
y_true = args[num_layers:]
anchor_mask = [[6, 7, 8], [3, 4, 5], [0, 1, 2]] if num_layers == 3 else [[3, 4, 5], [1, 2, 3]]
input_shape = K.cast(K.shape(yolo_outputs[0])[1:3] * 32, K.dtype(y_true[0]))
grid_shapes = [K.cast(K.shape(yolo_outputs[l])[1:3], K.dtype(y_true[0])) for l in range(num_layers)]
loss = 0
m = K.shape(yolo_outputs[0])[0] # batch size, tensor
mf = K.cast(m, K.dtype(yolo_outputs[0]))
for l in range(num_layers):
object_mask = y_true[l][..., 4:5]
true_class_probs = y_true[l][..., 5:]
grid, raw_pred, pred_xy, pred_wh = yolo_head(yolo_outputs[l],
anchors[anchor_mask[l]], num_classes, input_shape, calc_loss=True)
pred_box = K.concatenate([pred_xy, pred_wh])
# Darknet raw box to calculate loss.
raw_true_xy = y_true[l][..., :2] * grid_shapes[l][::-1] - grid
raw_true_wh = K.log(y_true[l][..., 2:4] / anchors[anchor_mask[l]] * input_shape[::-1])
raw_true_wh = K.switch(object_mask, raw_true_wh, K.zeros_like(raw_true_wh)) # avoid log(0)=-inf
box_loss_scale = 2 - y_true[l][..., 2:3] * y_true[l][..., 3:4]
# Find ignore mask, iterate over each of batch.
ignore_mask = tf.TensorArray(K.dtype(y_true[0]), size=1, dynamic_size=True)
object_mask_bool = K.cast(object_mask, 'bool')
def loop_body(b, ignore_mask):
true_box = tf.boolean_mask(y_true[l][b, ..., 0:4], object_mask_bool[b, ..., 0])
iou = box_iou(pred_box[b], true_box)
best_iou = K.max(iou, axis=-1)
ignore_mask = ignore_mask.write(b, K.cast(best_iou < ignore_thresh, K.dtype(true_box)))
return b + 1, ignore_mask
_, ignore_mask = K.control_flow_ops.while_loop(lambda b, *args: b < m, loop_body, [0, ignore_mask])
ignore_mask = ignore_mask.stack()
ignore_mask = K.expand_dims(ignore_mask, -1)
# K.binary_crossentropy is helpful to avoid exp overflow.
xy_loss = object_mask * box_loss_scale * K.binary_crossentropy(raw_true_xy, raw_pred[..., 0:2], from_logits=True)
wh_loss = object_mask * box_loss_scale * 0.5 * K.square(raw_true_wh - raw_pred[..., 2:4])
confidence_loss = object_mask * K.binary_crossentropy(object_mask, raw_pred[..., 4:5], from_logits=True) + \
(1 - object_mask) * K.binary_crossentropy(object_mask, raw_pred[..., 4:5], from_logits=True) * ignore_mask
class_loss = object_mask * K.binary_crossentropy(true_class_probs, raw_pred[..., 5:], from_logits=True)
xy_loss = K.sum(xy_loss) / mf
wh_loss = K.sum(wh_loss) / mf
confidence_loss = K.sum(confidence_loss) / mf
class_loss = K.sum(class_loss) / mf
loss += xy_loss + wh_loss + confidence_loss + class_loss
if print_loss:
loss = tf.Print(loss, [loss, xy_loss, wh_loss, confidence_loss, class_loss, K.sum(ignore_mask)], message='loss: ')
return loss | /rosa_robot-0.1.0-py3-none-any.whl/rosa/vision/yolov3/yolo3/model.py | 0.937117 | 0.568536 | model.py | pypi |
import hashlib
import heapq
import os
from argparse import Namespace
from contextlib import ExitStack, contextmanager
from rosbags.rosbag1 import Reader, ReaderError, Writer, WriterError
from rosbags.typesys import get_types_from_msg
from tqdm import tqdm
"""
Copyright open_rosbag1 and read_messages comes from marv_robotics
https://gitlab.com/ternaris/marv-robotics/-/blob/master/code/marv-robotics/marv_robotics/bag.py#L360
# Copyright 2016 - 2018 Ternaris.
# SPDX-License-Identifier: AGPL-3.0-only
"""
@contextmanager
def open_rosbag1(path):
try:
with Reader(path) as bag:
yield bag
except ReaderError:
raise ReaderError(
(
f'Unindexed bag file: {path}\n'
' File was not copied in full or recording did not finish properly\n'
' Use `rosbag reindex` to index what is there.'
),
) from None
def read_messages(paths, topics=None, start_time=None, end_time=None):
"""Iterate chronologically raw BagMessage for topic from paths."""
# pylint: disable=too-many-locals
with ExitStack() as stack:
bags = [stack.enter_context(open_rosbag1(path)) for path in paths]
gens = []
for bag in bags:
valid_connections = []
if (topics is None):
# connect to all topics
valid_connections = [x for x in bag.connections]
else:
valid_connections = [
x for x in bag.connections if x.topic in topics]
gens.append(
bag.messages(
connections=valid_connections,
start=start_time,
stop=end_time,
)
)
prev_time = 0
for connection, time, data in heapq.merge(*gens, key=lambda x: x[1]):
assert time >= prev_time, (repr(time), repr(prev_time))
yield connection, time, data
prev_time = time
MD5_DEFAULT = str(hashlib.md5())
def main(input_bags: 'list[str]', topics: 'list[str]', output_path: str, outbag_name: str, exists_ok: bool):
try:
full_bag_path = os.path.join(output_path, outbag_name+".bag")
# clean up the preexisting bag when the exists_okay flag is present
if (exists_ok and os.path.exists(full_bag_path)):
os.remove(full_bag_path)
for bag_name in input_bags:
if (os.path.basename(bag_name) == outbag_name+".bag"):
input_bags.remove(bag_name)
# open the output bag in an automatically closing context
with Writer(full_bag_path) as output_bag:
conn_map = {}
def read_messages_generator(): return read_messages(input_bags, topics=topics)
total = len(list(read_messages_generator()))
# process messages across input bag(s)
for connection, timestamp, rawdata in tqdm(read_messages_generator(), desc="Reading Bags", bar_format='{l_bar}{bar}{r_bar}', total=total):
# make dict for safe gets of connection attributes
try:
conn_map[connection.topic] = output_bag.add_connection(
topic=connection.topic,
msgtype=connection.msgtype,
msgdef=connection.msgdef,
# connection.digest found to be used in writer.py - > write_connection(..)
md5sum=connection.digest,
callerid=connection.ext.callerid,
latching=connection.ext.latching)
except WriterError:
pass
for connection, timestamp, rawdata in tqdm(read_messages_generator(), desc="Writing New Bag", bar_format='{l_bar}{bar}{r_bar}', total=total):
# write this message to the output bag
output_bag.write(
conn_map[connection.topic], timestamp, rawdata)
except KeyboardInterrupt:
pass
finally:
print("Done.") | /rosbag_merge-0.1.5.tar.gz/rosbag_merge-0.1.5/src/rosbag_merge/bag_stream.py | 0.523908 | 0.173358 | bag_stream.py | pypi |
from __future__ import annotations
import shutil
import warnings
from pathlib import Path
from typing import TYPE_CHECKING, cast
from rosbags.interfaces import ConnectionExtRosbag1, ConnectionExtRosbag2
from rosbags.rosbag1 import Reader as Reader1
from rosbags.rosbag1 import Writer as Writer1
from rosbags.rosbag2 import Reader as Reader2
from rosbags.rosbag2 import Writer as Writer2
from tqdm import tqdm
if TYPE_CHECKING:
from typing import Optional, Type
class UnknownStartTimeError(ValueError):
"""Exception for start times"""
pass
class UnknownEndTimeError(ValueError):
"""Exception for end times"""
pass
class UnorderedTimeError(ValueError):
"""Exception for time order (Start < End)"""
pass
class BagClipper:
"""Clipper: Cut a rosbag based on timestamps."""
def __init__(
self,
path: Path | str,
) -> None:
self._bag_start: float = None
self._bag_end: float = None
self._bag_duration: float = None
self._is_ros1_reader: bool = None
self._is_ros1_writer: bool = None
self.inbag: Path = Path(path)
@property
def inbag(self):
"""Path to input rosbag"""
return self._inbag
@inbag.setter
def inbag(self, value: Path | str):
# Check that path exists
if not Path(value).exists():
raise FileNotFoundError(
f"File {value} is not an existing file. Please provide a path that exists in your file system"
)
self._inbag = Path(value)
Reader = self.get_reader_class(self._inbag)
with Reader(self._inbag) as bag:
self._bag_start = bag.start_time
self._bag_end = bag.end_time
self._bag_duration = bag.duration
def get_reader_class(self, filename: Path | str) -> Type[Reader1 | Reader2]:
"""Return the reader class that corresponds to the filename
Needs the filename of the rosbag to read from
"""
is_ros1 = Path(filename).suffix == ".bag"
self._is_ros1_reader = is_ros1
return Reader1 if is_ros1 else Reader2
def get_writer_class(self, filename: Path | str) -> Type[Writer1 | Writer2]:
"""Return the writer class that corresponds to the filename
Needs the filename of the rosbag to write in
"""
is_ros1 = Path(filename).suffix == ".bag"
self._is_ros1_writer = is_ros1
return Writer1 if is_ros1 else Writer2
def delete_rosbag(self, path: Path | str):
"""Function to delete a rosbag at path `path`, to use with caution
Args:
path: Path to rosbag to delete.
"""
is_ros1 = path.is_file() and path.suffix == ".bag"
is_ros2 = path.is_dir() and len(tuple(path.glob("*.db3"))) > 0
if is_ros1:
path.unlink()
elif is_ros2:
shutil.rmtree(path)
else:
raise ValueError(f"Path {path} is not a valid rosbag")
def _check_cutoff_limits(
self, start: Optional[float] = None, end: Optional[float] = None
):
"""Check that clip limits are in the range of the bag
Args:
start (float, optional): Starting time. Defaults to None.
end (float, optional): Ending time. Defaults to None.
Raises:
UnknownStartTimeError: _raised if `start` is not in the rosbag_
UnknownEndTimeError: _raised if `end` is not in the rosbag_
UnorderedTimeError: _raised f `end` < `start`_
"""
slimit = start is not None
elimit = end is not None
start_ns = start * 10**9 if slimit else start
end_ns = end * 10**9 if elimit else end
if slimit and start_ns < 0 and start_ns > self._bag_duration:
raise UnknownStartTimeError(
f"Start time ({start} s) is not in the bag. "
f"Start time should be defined between 0 and {self._bag_duration} s."
)
if elimit and end_ns < 0 and end_ns > self._bag_duration:
raise UnknownEndTimeError(
f"End time ({end} s) is not in the bag. "
f"End time should be defined between 0 and {self._bag_duration} s."
)
if slimit and elimit and end < start:
raise UnorderedTimeError(
f"Start time (s: {start}) should come " f"before ending time (e: {end})."
)
def clip_rosbag(
self,
start: Optional[float] = None,
end: Optional[float] = None,
outbag_path: Path | str = None,
force_out: bool = False,
):
"""Clip rosbag between two elapsed times, given relative to the beginning of the rosbag
Args:
start (float, optional): Start of the clip, in seconds relative to the beginning of the bag. Defaults to None. If None, the clip starts at the beginning of the rosbag.
end (float, optional): End of the clip, in seconds relative to the beginning of the bag. Defaults to None. If None, the clip stops at the end of the rosbag.
outbag_path (Path | str): Path of output bag.
force_squash (bool); Force output bag overwriting, if outbag already exists. Defaults to False.
"""
self._check_cutoff_limits(start, end)
if start is None:
s_cliptstamp = self._bag_start
else:
start_ns = start * 10**9
s_cliptstamp = self._bag_start + start_ns
if end is None:
e_cliptstamp = self._bag_end
else:
end_ns = end * 10**9
e_cliptstamp = self._bag_start + end_ns
# Check Export Path
export_path = Path(outbag_path)
if export_path == self._inbag:
raise FileExistsError(
f"Cannot use same file as input and output [{export_path}]"
)
if export_path.exists() and not force_out:
raise FileExistsError(
f"Path {outbag_path} already exists. "
"Use 'force_out=True' or 'rosbag-tools clip -f' to "
f"export to {outbag_path} even if output bag already exists."
)
if export_path.exists() and force_out:
warnings.warn(
f"Output path {export_path} already exists, output overwriting flag has been set, deleting old output file"
)
self.delete_rosbag(export_path)
# Reader / Writer classes
Reader = self.get_reader_class(self._inbag)
Writer = self.get_writer_class(outbag_path)
if self._is_ros1_reader != self._is_ros1_writer:
raise NotImplementedError(
"Rosbag conversion (ROS 1->ROS 2 / ROS 2->ROS 1) is not supported. "
"Use `rosbags` to convert your rosbag before using `rosbag-tools clip`."
)
with Reader(self._inbag) as reader, Writer(export_path) as writer:
conn_map = {}
ConnectionExt = (
ConnectionExtRosbag1 if self._is_ros1_writer else ConnectionExtRosbag2
)
for conn in reader.connections:
ext = cast(ConnectionExt, conn.ext)
if self._is_ros1_writer:
# ROS 1
conn_map[conn.id] = writer.add_connection(
conn.topic,
conn.msgtype,
conn.msgdef,
conn.md5sum,
ext.callerid,
ext.latching,
)
else:
# ROS 2
conn_map[conn.id] = writer.add_connection(
conn.topic,
conn.msgtype,
ext.serialization_format,
ext.offered_qos_profiles,
)
with tqdm(total=reader.message_count) as pbar:
for conn, timestamp, data in reader.messages():
if s_cliptstamp <= timestamp <= e_cliptstamp:
writer.write(conn_map[conn.id], timestamp, data)
pbar.update(1)
print(f"[clip] Clipping done ! Exported in {outbag_path}") | /rosbag_tools-0.0.4-py3-none-any.whl/rosbag_tools/clip/clipper.py | 0.927314 | 0.261375 | clipper.py | pypi |
from __future__ import annotations
import fnmatch
import shutil
import warnings
from pathlib import Path
from typing import TYPE_CHECKING, cast
from rosbags.interfaces import ConnectionExtRosbag1, ConnectionExtRosbag2
from rosbags.rosbag1 import Reader as Reader1
from rosbags.rosbag1 import Writer as Writer1
from rosbags.rosbag2 import Reader as Reader2
from rosbags.rosbag2 import Writer as Writer2
from tqdm import tqdm
if TYPE_CHECKING:
from typing import Sequence, Tuple, Type
class BagTopicRemover:
"""Topic Remover : Remove topics from a rosbag"""
def __init__(self, path: Path | str) -> None:
"""Create a BagTopicRemover instance
Args:
path: Path to the input rosbag
"""
self._intopics: Tuple[str] = None
self._is_ros1_reader: bool = None
self._is_ros1_writer: bool = None
self.inbag = Path(path)
@property
def inbag(self):
"""The inbag property."""
return self._inbag
@inbag.setter
def inbag(self, value: Path | str):
"""Setter for `inbag`"""
vpath = Path(value)
if vpath.is_file() or vpath.is_dir():
self._inbag = vpath
Reader = self.get_reader_class(self._inbag)
with Reader(self._inbag) as inbag:
self._intopics = tuple(inbag.topics.keys())
else:
raise ValueError(f"{value} is not an existing file")
@property
def topics(self):
"""The topics property."""
return self._intopics
def get_reader_class(self, filename: Path | str) -> Type[Reader1 | Reader2]:
"""Return the reader class that corresponds to the filename
Needs the filename of the rosbag to read from
"""
is_ros1 = Path(filename).suffix == ".bag"
self._is_ros1_reader = is_ros1
return Reader1 if is_ros1 else Reader2
def get_writer_class(self, filename: Path | str) -> Type[Writer1 | Writer2]:
"""Return the writer class that corresponds to the filename
Needs the filename of the rosbag to write in
"""
is_ros1 = Path(filename).suffix == ".bag"
self._is_ros1_writer = is_ros1
return Writer1 if is_ros1 else Writer2
@staticmethod
def filter_out_topics(
bag_topics: Sequence[str], patterns_to_remove: Sequence[str]
) -> Tuple[str]:
"""Filter out topics
Examples:
>>> bag_topics = ('/cmd_vel', '/imu/data', '/imu/data_raw', '/imu/odom', '/lidar_packets', '/map', '/velocity')
>>> to_filter = ('/imu/*', '/lidar_packets')
>>> BagTopicRemover.filter_out_topics(bag_topics, to_filter)
('/cmd_vel', '/map', '/velocity')
>>> to_filter = ('/cmd_vel', '/map', '/velocity')
>>> BagTopicRemover.filter_out_topics(bag_topics, to_filter)
('/imu/data', '/imu/data_raw', '/imu/odom', '/lidar_packets')
>>> bag_topics = ('/imu/data', '/imu/data_raw', '/imu/odom')
>>> to_filter = ('/camera/image_raw')
>>> BagTopicRemover.filter_out_topics(bag_topics, to_filter)
('/imu/data', '/imu/data_raw', '/imu/odom')
>>> bag_topics = ('/imu/data', '/imu/data_raw', '/imu/odom')
>>> to_filter = ()
>>> BagTopicRemover.filter_out_topics(bag_topics, to_filter)
('/imu/data', '/imu/data_raw', '/imu/odom')
Args:
bag_topics: input rosbag's topics
patterns_to_remove: topics to filter out
Returns:
tuple: Filtered topics that were not targeted by the pattern
"""
# Accumulate a list of topics
topics_to_remove = []
for pattern in patterns_to_remove:
pattern_topics = fnmatch.filter(bag_topics, pattern)
topics_to_remove.extend(pattern_topics)
# Keep only one copy of each element in the list
topics_to_remove = tuple(set(topics_to_remove))
filtered_topics = tuple(
topic for topic in bag_topics if topic not in topics_to_remove
)
return filtered_topics
def remove(self, patterns: Sequence[str] | str = ("",)) -> None:
"""Remove topic patterns or specific topics from self._intopics
Args:
patterns: List, tuple of strings or string that contains a pattern or a specific topic name to remove from the bag
"""
if isinstance(patterns, str):
patterns = (patterns,)
self._intopics = self.filter_out_topics(self._intopics, patterns)
def delete_rosbag(self, path: Path | str):
"""Function to delete a rosbag at path `path`, to use with caution
Args:
path: Path to rosbag to delete.
"""
is_ros1 = path.is_file() and path.suffix == ".bag"
is_ros2 = path.is_dir() and len(tuple(path.glob("*.db3"))) > 0
if is_ros1:
path.unlink()
elif is_ros2:
shutil.rmtree(path)
else:
raise ValueError(f"Path {path} is not a valid rosbag")
def export(self, path: Path | str, force_output_overwrite: bool = False) -> None:
"""Export filtered rosbag to 'path'
Args:
path: Path to export the rosbag.
force_output_overwrite: Force output overwriting if path already exists. Defaults to False.
Raises:
FileExistsError: _description_
FileExistsError: _description_
"""
outpath = Path(path)
if outpath == self._inbag:
raise FileExistsError(f"Cannot use same file as input and output [{path}]")
if outpath.exists() and not force_output_overwrite:
raise FileExistsError(
f"Path {path} already exists. "
"Use 'force_output_overwrite=True' or `rosbag-tools topic-remove -f` "
f"to export to {path}, even if output bag already exists."
)
if outpath.exists() and force_output_overwrite:
warnings.warn(
f"Output path {outpath} already exists, output overwriting flag has been set, deleting old output file"
)
self.delete_rosbag(outpath)
# Reader / Writer classes
Reader = self.get_reader_class(self.inbag)
Writer = self.get_writer_class(path)
if self._is_ros1_reader != self._is_ros1_writer:
raise NotImplementedError(
"Rosbag conversion (ROS 1->ROS 2 / ROS 2->ROS 1) is not supported. "
"Use `rosbags` to convert your rosbag before using `rosbag-tools topic-remove`."
)
with Reader(self.inbag) as reader, Writer(outpath) as writer:
conn_map = {}
ConnectionExt = (
ConnectionExtRosbag1 if self._is_ros1_writer else ConnectionExtRosbag2
)
for conn in reader.connections:
if conn.topic in self._intopics:
ext = cast(ConnectionExt, conn.ext)
if self._is_ros1_writer:
conn_map[conn.id] = writer.add_connection(
conn.topic,
conn.msgtype,
conn.msgdef,
conn.md5sum,
ext.callerid,
ext.latching,
)
else:
# ROS 2
conn_map[conn.id] = writer.add_connection(
conn.topic,
conn.msgtype,
ext.serialization_format,
ext.offered_qos_profiles,
)
with tqdm(total=reader.message_count) as pbar:
for conn, timestamp, data in reader.messages():
if conn.topic in self._intopics:
writer.write(conn_map[conn.id], timestamp, data)
pbar.update(1)
print(f"[topic-remove] Done ! Exported in {path}") | /rosbag_tools-0.0.4-py3-none-any.whl/rosbag_tools/topic_remove/topic_remover.py | 0.900666 | 0.227856 | topic_remover.py | pypi |
from __future__ import annotations
import fnmatch
import shutil
import warnings
from pathlib import Path
from typing import TYPE_CHECKING, cast
from rosbags.interfaces import ConnectionExtRosbag1, ConnectionExtRosbag2
from rosbags.rosbag1 import Reader as Reader1
from rosbags.rosbag1 import Writer as Writer1
from rosbags.rosbag2 import Reader as Reader2
from rosbags.rosbag2 import Writer as Writer2
from tqdm import tqdm
if TYPE_CHECKING:
from typing import Sequence, Tuple, Type
class BagTopicRemover:
"""Topic remover class to delete some topics from a rosbag"""
def __init__(self, path: Path | str) -> None:
"""Create a BagTopicRemover instance
Args:
path: Path to the input rosbag
"""
self._intopics: Tuple[str] = None
self._is_ros1_reader: bool = None
self._is_ros1_writer: bool = None
self.inbag = Path(path)
@property
def inbag(self):
"""The inbag property."""
return self._inbag
@inbag.setter
def inbag(self, value: Path | str):
"""Setter for `inbag`"""
vpath = Path(value)
if vpath.is_file() or vpath.is_dir():
self._inbag = vpath
Reader = self.get_reader_class(self._inbag)
with Reader(self._inbag) as inbag:
self._intopics = tuple(inbag.topics.keys())
else:
raise ValueError(f"{value} is not an existing file")
@property
def topics(self):
"""The topics property."""
return self._intopics
def get_reader_class(self, filename: Path | str) -> Type[Reader1 | Reader2]:
"""Return the reader class that corresponds to the filename
Needs the filename of the rosbag to read from
"""
is_ros1 = Path(filename).suffix == ".bag"
self._is_ros1_reader = is_ros1
return Reader1 if is_ros1 else Reader2
def get_writer_class(self, filename: Path | str) -> Type[Writer1 | Writer2]:
"""Return the writer class that corresponds to the filename
Needs the filename of the rosbag to write in
"""
is_ros1 = Path(filename).suffix == ".bag"
self._is_ros1_writer = is_ros1
return Writer1 if is_ros1 else Writer2
@staticmethod
def filter_out_topics(
bag_topics: Sequence[str], patterns_to_remove: Sequence[str]
) -> Tuple[str]:
"""Filter out topics
Examples:
>>> bag_topics = ('/cmd_vel', '/imu/data', '/imu/data_raw', '/imu/odom', '/lidar_packets', '/map', '/velocity')
>>> to_filter = ('/imu/*', '/lidar_packets')
>>> BagTopicRemover.filter_out_topics(bag_topics, to_filter)
('/cmd_vel', '/map', '/velocity')
>>> to_filter = ('/cmd_vel', '/map', '/velocity')
>>> BagTopicRemover.filter_out_topics(bag_topics, to_filter)
('/imu/data', '/imu/data_raw', '/imu/odom', '/lidar_packets')
>>> bag_topics = ('/imu/data', '/imu/data_raw', '/imu/odom')
>>> to_filter = ('/camera/image_raw')
>>> BagTopicRemover.filter_out_topics(bag_topics, to_filter)
('/imu/data', '/imu/data_raw', '/imu/odom')
>>> bag_topics = ('/imu/data', '/imu/data_raw', '/imu/odom')
>>> to_filter = ()
>>> BagTopicRemover.filter_out_topics(bag_topics, to_filter)
('/imu/data', '/imu/data_raw', '/imu/odom')
Args:
bag_topics: input rosbag's topics
patterns_to_remove: topics to filter out
Returns:
tuple: Filtered topics that were not targeted by the pattern
"""
# Accumulate a list of topics
topics_to_remove = []
for pattern in patterns_to_remove:
pattern_topics = fnmatch.filter(bag_topics, pattern)
topics_to_remove.extend(pattern_topics)
# Keep only one copy of each element in the list
topics_to_remove = tuple(set(topics_to_remove))
filtered_topics = tuple(
topic for topic in bag_topics if topic not in topics_to_remove
)
return filtered_topics
def remove(self, patterns: Sequence[str] | str = ("",)) -> None:
"""Remove topic patterns or specific topics from self._intopics
Args:
patterns: List, tuple of strings or string that contains a pattern or a specific topic name to remove from the bag
"""
if isinstance(patterns, str):
patterns = (patterns,)
self._intopics = self.filter_out_topics(self._intopics, patterns)
def delete_rosbag(self, path: Path | str):
"""Function to delete a rosbag at path `path`, to use with caution
Args:
path: Path to rosbag to delete.
"""
is_ros1 = path.is_file() and path.suffix == ".bag"
is_ros2 = path.is_dir() and len(tuple(path.glob("*.db3"))) > 0
if is_ros1:
path.unlink()
elif is_ros2:
shutil.rmtree(path)
else:
raise ValueError(f"Path {path} is not a valid rosbag")
def export(self, path: Path | str, force_out: bool = False) -> None:
"""Export filtered rosbag to 'path'
Args:
path: Path to export the rosbag.
force_out: Force output overwriting if path already exists. Defaults to False.
Raises:
FileExistsError: _description_
FileExistsError: _description_
"""
outpath = Path(path)
if outpath == self._inbag:
raise FileExistsError(f"Cannot use same file as input and output [{path}]")
if outpath.exists() and not force_out:
raise FileExistsError(
f"Path {path} already exists. "
f"Use 'force_out=True' or 'rosbag-topic-remove -f' to export to {path} even if output bag already exists."
)
if outpath.exists() and force_out:
warnings.warn(
f"Output path {outpath} already exists, output overwriting flag has been set, deleting old output file"
)
self.delete_rosbag(outpath)
Reader = self.get_reader_class(self.inbag)
Writer = self.get_writer_class(path)
if self._is_ros1_reader != self._is_ros1_writer:
raise NotImplementedError(
"Rosbag conversion (ROS1->ROS2 / ROS2->ROS1) is not supported. Use `rosbags` to convert your rosbag before using `rosbag-topic-remove`."
)
with Reader(self.inbag) as reader, Writer(outpath) as writer:
conn_map = {}
ConnectionExt = (
ConnectionExtRosbag1 if self._is_ros1_writer else ConnectionExtRosbag2
)
for conn in reader.connections:
if conn.topic in self._intopics:
ext = cast(ConnectionExt, conn.ext)
if self._is_ros1_writer:
conn_map[conn.id] = writer.add_connection(
conn.topic,
conn.msgtype,
conn.msgdef,
conn.md5sum,
ext.callerid,
ext.latching,
)
else:
# ROS2
conn_map[conn.id] = writer.add_connection(
conn.topic,
conn.msgtype,
ext.serialization_format,
ext.offered_qos_profiles,
)
with tqdm(total=reader.message_count) as pbar:
for conn, timestamp, data in reader.messages():
if conn.topic in self._intopics:
writer.write(conn_map[conn.id], timestamp, data)
pbar.update(1)
print(f"[rosbag-topic-remove] Done ! Exported in {path}") | /rosbag_topic_remove-0.0.2-py3-none-any.whl/rosbag_topic_remove/topic_remover.py | 0.914953 | 0.201656 | topic_remover.py | pypi |
import rosbag_pandas
import matplotlib.pyplot as plt
import os
import argparse
def buildParser():
''' Builds the parser for reading the command line arguments'''
parser = argparse.ArgumentParser(
description='Script to parse bagfile to csv file')
parser.add_argument('bag', help='Bag file to read',
type=str)
parser.add_argument('-i', '--include',
help='list or regex for topics to include',
nargs='*')
parser.add_argument('-e', '--exclude',
help='list or regex for topics to exclude',
nargs='*')
parser.add_argument('-o', '--output',
help='name of the output file',
nargs='*')
parser.add_argument('-f', '--fill',
help='Fill the bag forward and backwards so no missing values when present',
action='store_true')
parser.add_argument('--include-header',
help='Include the header fields. By default they are excluded',
action='store_true')
return parser
def do_work(bag, include, exclude, output, fill, header):
# covert a lenght one value to a regex
if include is not None and len(include) == 1:
include = include[0]
# covert a lenght one value to a regex
if exclude is not None and len(exclude) == 1:
exclude = exclude[0]
df = rosbag_pandas.bag_to_dataframe(bag, include=include, exclude=exclude,
parse_header=header)
if fill:
df = df.ffill().bfill()
if output is None:
base, _ = os.path.splitext(bag)
output = base + '.csv'
df = rosbag_pandas.clean_for_export(df)
df.to_csv(output)
if __name__ == '__main__':
''' Main entry point for the function. Reads the command line arguements
and performs the requested actions '''
# Build the command line argument parser
parser = buildParser()
# Read the arguments that were passed in
args = parser.parse_args()
bag = args.bag
include = args.include
exclude = args.exclude
output = args.output
fill = args.fill
header = args.include_header
do_work(bag, include, exclude, output, fill, header) | /rosbag_pandas-0.5.0.0.tar.gz/rosbag_pandas-0.5.0.0/scripts/bag2csv.py | 0.51879 | 0.18188 | bag2csv.py | pypi |
import rosbag_pandas
import matplotlib.pyplot as plt
import argparse
def buildParser():
''' Builds the parser for reading the command line arguments'''
parser = argparse.ArgumentParser(description='Bagfile reader')
parser.add_argument('-b', '--bag', help='Bag file to read',
required=True, type=str)
parser.add_argument('-s', '--series',
help='Msg data fields to graph',
required=True, nargs='*')
parser.add_argument('-y ', '--ylim',
help='Set min and max y lim',
required=False, nargs=2)
parser.add_argument('-c', '--combined',
help="Graph them all on one",
required=False, action="store_true", dest="sharey")
return parser
def parse_series_args(topics, fields):
'''Return which topics and which field keys need to be examined
for plotting'''
keys = {}
for field in fields:
for topic in topics:
if field.startswith(topic):
keys[field] = (topic, field[len(topic) + 1:])
return keys
def graph(df, df_keys, sharey):
if sharey or len(df_keys) == 1:
fig, axes = plt.subplots()
for label, key in df_keys.items():
s = df[key].dropna()
axes.plot(s.index, s.values, label=label)
axes.legend(loc=0)
plt.show()
else:
fig, axes = plt.subplots(len(df_keys), sharex=True)
idx = 0
for label, key in df_keys.items():
s = df[key].dropna()
axes[idx].plot(s.index, s.values)
axes[idx].set_title(label)
idx = idx + 1
plt.show()
if __name__ == '__main__':
''' Main entry point for the function. Reads the command line arguements
and performs the requested actions '''
# Build the command line argument parser
parser = buildParser()
# Read the arguments that were passed in
args = parser.parse_args()
bag = args.bag
fields = args.series
sharey = args.sharey
yaml_info = rosbag_pandas.get_bag_info(bag)
topics = rosbag_pandas.get_topics(yaml_info)
data_keys = parse_series_args(topics, fields)
df_keys = {}
topics = []
for k, v in data_keys.items():
column = rosbag_pandas.get_key_name(
v[0]) + '__' + rosbag_pandas.get_key_name(v[1])
column = column.replace('.', '_')
df_keys[k] = column
topics.append(v[0])
df = rosbag_pandas.bag_to_dataframe(bag, include=topics, seconds=True)
graph(df, df_keys, sharey) | /rosbag_pandas-0.5.0.0.tar.gz/rosbag_pandas-0.5.0.0/scripts/bag_graph.py | 0.581065 | 0.308998 | bag_graph.py | pypi |
"""Conversion of rosbag topics to dataframes."""
from __future__ import annotations
from typing import TYPE_CHECKING
import pandas # type: ignore
from rosbags.serde.messages import get_msgdef
from rosbags.serde.utils import Valtype
if TYPE_CHECKING:
from typing import Callable, Sequence, Union
from rosbags.highlevel import AnyReader
AttrValue = Union[str, bool, int, float, object]
class DataframeError(Exception):
"""Dataframe conversion error."""
def get_dataframe(reader: AnyReader, topicname: str, keys: Sequence[str]) -> pandas.DataFrame:
"""Convert messages from a topic into a pandas dataframe.
Read all messages from a topic and extract referenced keys into
a pandas dataframe. The message timestamps are automatically added
as the dataframe index.
Keys support a dotted syntax to traverse nested messages.
Args:
reader: Opened rosbags reader.
topicname: Topic name of messages to process.
keys: Field names to get from each message.
Raises:
DataframeError: Reader not opened or topic or field name does not exist.
Returns:
Pandas dataframe.
"""
# pylint: disable=too-many-locals
if not reader.isopen:
raise DataframeError('RosbagReader needs to be opened before accessing messages.')
if topicname not in reader.topics:
raise DataframeError(f'Requested unknown topic {topicname!r}.')
topic = reader.topics[topicname]
assert topic.msgtype
msgdef = get_msgdef(topic.msgtype, reader.typestore)
def create_plain_getter(key: str) -> Callable[[object], AttrValue]:
"""Create getter for plain attribute lookups."""
def getter(msg: object) -> AttrValue:
return getattr(msg, key) # type: ignore
return getter
def create_nested_getter(keys: list[str]) -> Callable[[object], AttrValue]:
"""Create getter for nested lookups."""
def getter(msg: object) -> AttrValue:
value = msg
for key in keys:
value = getattr(value, key)
return value
return getter
getters = []
for key in keys:
subkeys = key.split('.')
subdef = msgdef
for subkey in subkeys[:-1]:
subfield = next((x for x in subdef.fields if x.name == subkey), None)
if not subfield:
raise DataframeError(f'Field {subkey!r} does not exist on {subdef.name!r}.')
if subfield.descriptor.valtype != Valtype.MESSAGE:
raise DataframeError(f'Field {subkey!r} of {subdef.name!r} is not a message.')
subdef = subfield.descriptor.args
if subkeys[-1] not in {x.name for x in subdef.fields}:
raise DataframeError(f'Field {subkeys[-1]!r} does not exist on {subdef.name!r}.')
if len(subkeys) == 1:
getters.append(create_plain_getter(subkeys[0]))
else:
getters.append(create_nested_getter(subkeys))
timestamps = []
data = []
for _, timestamp, rawdata in reader.messages(connections=topic.connections):
msg = reader.deserialize(rawdata, topic.msgtype)
timestamps.append(timestamp)
data.append([x(msg) for x in getters])
return pandas.DataFrame(data, columns=keys, index=pandas.to_datetime(timestamps)) | /rosbags_dataframe-0.9.0-py3-none-any.whl/rosbags/dataframe/dataframe.py | 0.929176 | 0.395835 | dataframe.py | pypi |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.